Types de données et pilotes MongoDB compatibles

Les tableaux suivants répertorient les types de données, les pilotes et les outils tiers MongoDB compatibles avec Firestore compatible avec MongoDB.

Types de données

Type BSON Compatible
Entier 32 bits Oui
Entier 64 bits Oui
Tableau Oui
Données binaires Oui
Booléen Oui
Date Oui
DBPointer Non
Decimal128 Oui
Double Oui
JavaScript Non
JavaScript (avec champ d'application) Non
MaxKey Oui
MinKey Oui
Vide Oui
Objet Oui
ObjectId Oui
Expression régulière Oui
Chaîne Oui
Symbole Non
Horodatage Oui
Indéterminé Non

_id du document

Le champ _id de premier niveau d'un document doit être de l'un des types suivants :

  • ObjectId
  • Chaîne
  • Entier 64 bits
  • Entier 32 bits
  • Double
  • Binaire
  • Objet
  • Booléen

La taille totale de _id ne doit pas dépasser 1 500 octets.

Chaque valeur d'un ID de type Object doit également être d'un type d'ID compatible ou d'un tableau de valeurs, chacune d'un type d'ID compatible.

Les autres types BSON ne sont pas acceptés.

Langages et pilotes MongoDB

Firestore compatible avec MongoDB accepte les versions de pilote suivantes :

Langue Versions des pilotes
Java 5.x
Node.js 6.x
5.x
Python 4.x
3.x (x ≥ 12)
Go 2.x
C# 3.x
Ruby 2.x (x ≥ 16)

Compatibilité avec l'authentification OIDC

Les pilotes Go, C# et Ruby sont compatibles avec l'authentification OpenID Connect (OIDC) à partir deGoogle Cloud pour toutes les versions de pilote compatibles.

Les pilotes Java, Node.js et Python sont compatibles avec l'authentification OIDC à partir deGoogle Cloud , à partir des versions de pilote suivantes :

  • Java : 4.10
  • Node.js : 6.7
  • Python : 4,7

Outils tiers

Firestore compatible avec MongoDB est compatible avec les outils tiers décrits dans cette section.

Outil Description Remarques
mongoimport Outils de base de données MongoDB Consultez Chargement groupé de données .
mongoexport Outils de base de données MongoDB
mongodump Outils de base de données MongoDB
mongorestore Outils de base de données MongoDB Consultez Chargement groupé de données .
mongosh Shell MongoDB
Mongoose Outil de modélisation d'objets MongoDB
MongoDB Compass Outil basé sur une IUG pour l'exploration des données

Compatibilité des types BSON et Firestore

Cette section récapitule le mappage entre les types BSON MongoDB et les valeurs Firestore. Étant donné que BSON est un format binaire et que l'API Firestore utilise des tampons de protocole, certains types sont mappés directement, tandis que d'autres nécessitent des représentations de mappage spéciales.

Présentation du mappage

Les tableaux suivants montrent comment les types de données BSON correspondent aux représentations de tampon de protocole Firestore.

Mappages directs

Ces types ont un équivalent direct dans les deux systèmes.

Type BSON BSON Firestore Proto Remarques
Double 1.23 double_value: 1.23
Chaîne "hello" string_value: "hello"
Objet 
{
  "a": 1.23
}
 
map_value {
  fields {
    key: "a"
    value {
      double_value: 1.23
    }
  }
}
Array 
[
  1.23,
  "a"
]
 
array_value {
  values {
    double_value: 1.23
  }
  values {
    string_value: "a"
  }
}
Binaire (sous-type zéro) BinData(0, 'SGVsbG8=') bytes_value: "Hello"
Booléen true boolean_value: true
Null null null_value: NULL_VALUE
Entier 64 bits Long('1234567890') integer_value: 1234567890
Date ISODate('2026-05-22T04:00:00Z') 
timestamp_value {
  seconds: 1779470400
  nanos: 0
}
 Les valeurs d'horodatage Firestore sont stockées avec une précision de l'ordre de la microseconde, mais toute précision supérieure à la milliseconde est perdue lors de la conversion en BSON.

Types BSON représentés sous forme de mappages dans l'API Firestore

Ces types BSON sont encapsulés dans le map_value Firestore avec des clés spéciales pour indiquer le type.

Type BSON BSON Firestore Proto Remarques
Entier 32 bits 123 
map_value {
  fields {
    key: "__int__"
    value {
      integer_value: 123
    }
  }
}
Binaire (sous-type non nul) BinData(1, 'AQIDBA==') 
map_value {
  fields {
    key: "__binary__"
    value {
      bytes_value: "<subtype + data>"
    }
  }
}
 Octet de sous-type ajouté aux données.
ObjectId ObjectId('67eea9446dc71ec469e9496a') 
map_value {
  fields {
    key: "__oid__"
    value {
      string_value:
        "67eea9446dc71ec469e9496a"
    }
  }
}
 Chaîne hexadécimale en minuscules.
Timestamp (Internal) Timestamp(123, 1) 
map_value {
  fields {
    key: "__request_timestamp__"
    value {
      map_value {
        fields {
          key: "seconds"
          value {
            integer_value: 123
          }
        }
        fields {
          key: "increment"
          value {
            integer_value: 1
          }
        }
      }
    }
  }
}
 Code temporel interne MongoDB.
Expression régulière RegExp('.*', 'im') 
map_value {
  fields {
    key: "__regex__"
    value {
      map_value {
        fields {
          key: "pattern"
          value {
            string_value: ".*"
          }
        }
        fields {
          key: "options"
          value {
            string_value: "im"
          }
        }
      }
    }
  }
}
Clé minimale MinKey() 
map_value {
  fields {
    key: "__min__"
    value {
      null_value: NULL_VALUE
    }
  }
}
Clé maximale MaxKey() 
map_value {
  fields {
    key: "__max__"
    value {
      null_value: NULL_VALUE
    }
  }
}
Decimal128 Decimal128('4E7') 
map_value {
  fields {
    key: "__decimal128__"
    value {
      string_value: "4E7"
    }
  }
}

Types Firestore non natifs dans BSON

Ces types Firestore sont représentés sous forme de mappages spécialement structurés lorsqu'ils sont convertis en BSON.

Type Firestore BSON Firestore Proto
GeoPoint 
{
  "__fs_geopoint__": {
    "latitude": 37.42,
    "longitude": -122.08
  }
}
 
geo_point_value {
  latitude: 37.42
  longitude: -122.08
}
Vecteur 
{
  "__fs_vector__": [
    1.0,
    2.0
  ]
}
 
map_value {
  fields {
    key: "__type__"
    value {
      string_value: "__vector__"
    }
  }
  fields {
    key: "value"
    value {
      array_value {
        ...
      }
    }
  }
}
Document Ref 
{
  "__fs_ref__": "projects/.../documents/col/doc"
}
 reference_value: "projects/.../documents/col/doc"

Noms des champs

Les noms de champs de MongoDB qui correspondent à __.*__ sont échappés en incorporant r: lorsqu'ils sont stockés dans Firestore. Par exemple, un champ BSON __foo__ devient __r:foo__ dans Firestore.

Types de données BSON dans les SDK client

Lorsque vous utilisez les SDK client Firestore, vous pouvez utiliser des classes de SDK spécialisées pour représenter les types de données BSON tels que les décimales 128 bits, les expressions régulières et les codes temporels BSON.

Node.js
const { RegexValue, Decimal128Value, BsonTimestamp } = require('@google-cloud/firestore');

// Setting fields with BSON data types
const res = await db.collection('foo').doc('bar').set({
  regex: new RegexValue('myRegexPattern', 'i'),
  decimal: new Decimal128Value('0.73e-7'),
  bsonTimestamp: new BsonTimestamp(1732754912, 500),
});
Java
import com.google.cloud.firestore.BsonTimestamp;
import com.google.cloud.firestore.Decimal128Value;
import com.google.cloud.firestore.RegexValue;
import java.util.HashMap;
import java.util.Map;

Map<String, Object> data = new HashMap<>();
data.put("regex", new RegexValue("myRegexPattern", "i"));
data.put("decimal", new Decimal128Value("0.73e-7"));
data.put("bson_timestamp", new BsonTimestamp(1732754912, 500));

db.collection("foo").doc("bar").set(data);
Java
Android
import com.google.firebase.firestore.BsonTimestamp;
import com.google.firebase.firestore.Decimal128Value;
import com.google.firebase.firestore.RegexValue;
import java.util.HashMap;
import java.util.Map;

Map<String, Object> data = new HashMap<>();
data.put("regex", new RegexValue("myRegexPattern", "i"));
data.put("decimal", new Decimal128Value("0.73e-7"));
data.put("bson_timestamp", new BsonTimestamp(1732754912, 500));

db.collection("foo").doc("bar").set(data);
Go
import (
    "context"

    "cloud.google.com/go/firestore"
)

func writeBsonTypes(ctx context.Context, client *firestore.Client) error {
    _, err := client.Collection("foo").Doc("bar").Set(ctx, map[string]interface{}{
        "regex":     firestore.RegexValue{Pattern: "myRegexPattern", Options: "i"},
        "decimal":   firestore.Decimal128Value{Value: "0.73e-7"},
        "bson_timestamp": firestore.BsonTimestamp{Seconds: 1732754912, Increment: 500},
    })
    return err
}

Étapes suivantes