Tipi di dati e driver MongoDB supportati

Le tabelle seguenti elencano i tipi di dati, i driver e gli strumenti di terze parti MongoDB supportati per Firestore con compatibilità MongoDB.

Tipi di dati

Tipo BSON Supportato
Numero intero a 32 bit Sì
Numero intero a 64 bit Sì
Array Sì
Dati binari Sì
Booleano Sì
Data Sì
DBPointer No
Decimal128 Sì
Doppio Sì
JavaScript No
JavaScript (con ambito) No
MaxKey Sì
MinKey Sì
Null Sì
Oggetto Sì
ObjectId Sì
Espressione regolare Sì
Stringa Sì
Simbolo No
Timestamp Sì
Non definito No

_id del documento

Il campo _id di primo livello in un documento deve essere uno dei seguenti tipi:

  • ObjectId
  • Stringa
  • Numero intero a 64 bit
  • Numero intero a 32 bit
  • Doppio
  • Binario
  • Oggetto
  • Booleano

La dimensione totale di _id non deve superare i 1500 byte.

Ogni valore all'interno di un ID di tipo Object deve essere anche di un tipo di ID supportato o un array di valori, ognuno dei quali è di un tipo di ID supportato.

Altri tipi BSON non sono supportati.

Linguaggi e driver MongoDB

Firestore con compatibilità MongoDB supporta le seguenti versioni dei driver:

Lingua Versioni dei driver
Java 5.x
Node.js 6.x
5.x
Python 4.x
3.x (x ≥ 12)
Vai 2.x
C# 3.x
Ruby 2.x (x ≥ 16)

Supporto dell'autenticazione OIDC

I driver Go, C# e Ruby supportano l'autenticazione OpenID Connect (OIDC) da Google Cloud per tutte le versioni dei driver supportate.

I driver Java, Node.js e Python supportano l'autenticazione OIDC diGoogle Cloud a partire dalle seguenti versioni dei driver:

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

Strumenti di terze parti

Firestore con compatibilità MongoDB supporta gli strumenti di terze parti descritti in questa sezione.

Strumento Descrizione Note
mongoimport Strumenti di database MongoDB Consulta Caricamento dei dati in blocco
mongoexport Strumenti di database MongoDB
mongodump Strumenti di database MongoDB
mongorestore Strumenti di database MongoDB Consulta Caricamento dei dati in blocco
mongosh Shell MongoDB
Mongoose Strumento di modellazione degli oggetti MongoDB
MongoDB Compass Strumento GUI per l'esplorazione dei dati

Compatibilità dei tipi BSON e Firestore

Questa sezione riassume la mappatura tra i tipi BSON di MongoDB e i valori di Firestore. Poiché BSON è un formato binario e l'API Firestore utilizza i buffer di protocollo, alcuni tipi vengono mappati direttamente, mentre altri richiedono rappresentazioni di mappe speciali.

Panoramica della mappatura

Le tabelle seguenti mostrano la corrispondenza tra i tipi di dati BSON e le rappresentazioni dei buffer di protocollo Firestore.

Mappature dirette

Questi tipi hanno un equivalente diretto in entrambi i sistemi.

Tipo BSON BSON Proto Firestore Note
Doppia 1.23 double_value: 1.23
Stringa "hello" string_value: "hello"
Oggetto 
{
  "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"
  }
}
Binary (Subtype Zero) BinData(0, 'SGVsbG8=') bytes_value: "Hello"
Boolean true boolean_value: true
Null null null_value: NULL_VALUE
Numero intero a 64 bit Long('1234567890') integer_value: 1234567890
Data ISODate('2026-05-22T04:00:00Z') 
timestamp_value {
  seconds: 1779470400
  nanos: 0
}
 I valori dei timestamp di Firestore vengono archiviati con una precisione di un microsecondo, ma qualsiasi precisione superiore a un millisecondo viene persa durante la conversione in BSON.

Tipi BSON rappresentati come mappe nell'API Firestore

Questi tipi BSON sono aggregati nel map_value di Firestore con chiavi speciali per indicare il tipo.

Tipo BSON BSON Proto Firestore Note
Numero intero a 32 bit 123 
map_value {
  fields {
    key: "__int__"
    value {
      integer_value: 123
    }
  }
}
Binary (Non-Zero Subtype) BinData(1, 'AQIDBA==') 
map_value {
  fields {
    key: "__binary__"
    value {
      bytes_value: "<subtype + data>"
    }
  }
}
 Byte del sottotipo anteposto ai dati.
ObjectId ObjectId('67eea9446dc71ec469e9496a') 
map_value {
  fields {
    key: "__oid__"
    value {
      string_value:
        "67eea9446dc71ec469e9496a"
    }
  }
}
 Stringa esadecimale minuscola.
Timestamp (interno) 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
          }
        }
      }
    }
  }
}
 Timestamp interno di MongoDB.
Espressione regolare RegExp('.*', 'im') 
map_value {
  fields {
    key: "__regex__"
    value {
      map_value {
        fields {
          key: "pattern"
          value {
            string_value: ".*"
          }
        }
        fields {
          key: "options"
          value {
            string_value: "im"
          }
        }
      }
    }
  }
}
Min Key MinKey() 
map_value {
  fields {
    key: "__min__"
    value {
      null_value: NULL_VALUE
    }
  }
}
Chiave massima MaxKey() 
map_value {
  fields {
    key: "__max__"
    value {
      null_value: NULL_VALUE
    }
  }
}
Decimal128 Decimal128('4E7') 
map_value {
  fields {
    key: "__decimal128__"
    value {
      string_value: "4E7"
    }
  }
}

Tipi di Firestore non nativi in BSON

Questi tipi di Firestore sono rappresentati come mappe strutturate in modo speciale quando vengono convertiti in BSON.

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

Nomi dei campi

I nomi dei campi di MongoDB che corrispondono a __.*__ vengono sottoposti a escape incorporando r: quando vengono archiviati in Firestore. Ad esempio, un campo BSON __foo__ diventa __r:foo__ in Firestore.

Tipi di dati BSON negli SDK client

Quando utilizzi gli SDK client di Firestore, puoi utilizzare classi SDK specializzate per rappresentare i tipi di dati BSON come decimali a 128 bit, espressioni regolari e timestamp 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);
Vai
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
}

Passaggi successivi