Panoramica dell'indicizzazione
Gli indici sono un fattore importante per le prestazioni di un database. Proprio come l'indice di un libro che mappa gli argomenti di un libro ai numeri delle pagine, un indice di database mappa gli elementi di un database alle loro posizioni nel database. Quando invii una query a un database, il database può utilizzare un indice per cercare rapidamente le posizioni degli elementi che hai richiesto.
In questa pagina vengono descritti i due tipi di indici utilizzati da Firestore: indici a campo singolo e indici composti.
Definizione e struttura dell'indice
Un indice viene definito su un elenco di campi di un determinato documento, con una modalità indice corrispondente per ogni campo.
Un indice contiene una voce per ogni campo denominato nella definizione dell'indice. L'indice include tutti i documenti che rappresentano i potenziali risultati per le query basate sull'indice. Un documento è incluso nell'indice solo se ha un valore indicizzato impostato per ogni campo utilizzato nell'indice; se la definizione dell'indice si riferisce a un campo per cui non è stato impostato alcun valore per il documento, quel documento non verrà visualizzato nell'indice e quindi non verrà mai restituito come risultato per nessuna query basata sull'indice.
L'indice composto viene ordinato in base ai valori dei campi, nell'ordine specificato nella definizione dell'indice.
Un indice dietro ogni query
Se non esiste un indice per una query, la maggior parte dei database esegue la scansione dei contenuti, elemento per elemento, un processo lento che rallenta ulteriormente man mano che il database cresce. Firestore garantisce prestazioni elevate delle query utilizzando gli indici per tutte le query. Di conseguenza, le prestazioni delle query dipendono dalla dimensione del set di risultati e non dal numero di elementi nel database.
Meno gestione degli indici, più sviluppo delle app
Firestore include funzionalità che riducono il tempo necessario per gestire gli indici. Gli indici necessari per le query di base vengono creati automaticamente. Quando utilizzi e testi la tua app, Firestore ti aiuta a identificare e creare indici aggiuntivi richiesti dalla tua app.
Tipi di indice
Firestore utilizza due tipi di indici: a campo singolo e composito. Oltre al numero di campi indicizzati, gli indici a campo singolo e compositi differiscono nella modalità di gestione.
Indici a campo singolo
Un indice a campo singolo archivia un mapping ordinato di tutti i documenti in una raccolta che contiene un campo specifico. Ogni voce in un indice a campo singolo registra il valore di un documento per un campo specifico e la posizione del documento nel database. Firestore usa questi indici per eseguire molte query di base. Puoi gestire gli indici a campo singolo configurando le impostazioni di indicizzazione automatica e le esenzioni degli indici del tuo database.
Indicizzazione automatica
Per impostazione predefinita, Firestore gestisce automaticamente indici a campo singolo per ogni campo di un documento e per ogni campo secondario di una mappa. Firestore utilizza le seguenti impostazioni predefinite per gli indici a campo singolo:
Per ogni campo non array e non mappa, Firestore definisce due indici a campo singolo collection-scope, uno in modalità crescente e uno in modalità decrescente.
Per ogni campo della mappa, Firestore crea quanto segue:
- Un indice crescente con ambito di raccolta per ogni sottocampo non array e non mappa.
- Un indice decrescente con ambito di raccolta per ogni sottocampo non array e non mappa.
- Un array nell'ambito della raccolta contiene un indice per ogni sottocampo dell'array.
- Firestore indicizza in modo ricorsivo ogni sottocampo della mappa.
Per ogni campo array in un documento, Firestore crea e gestisce un indice di tipo collection-scope-contiene un indice.
Gli indici a campo singolo con ambito del gruppo di raccolte non vengono gestiti per impostazione predefinita.
Esenzioni dell'indice a campo singolo
Puoi escludere un campo dalle impostazioni di indicizzazione automatica creando un'esenzione per l'indice a campo singolo. Un'esenzione dell'indicizzazione esegue l'override delle impostazioni dell'indice automatico a livello di database. Un'esenzione può abilitare un indice a campo singolo che altrimenti verrebbe disabilitato dalle impostazioni dell'indicizzazione automatica oppure può disabilitare un indice a campo singolo che altrimenti verrebbe abilitato dall'indicizzazione automatica. Per i casi in cui le esenzioni possono essere utili, consulta le best practice per l'indicizzazione.
Utilizza il valore del percorso del campo * per aggiungere esenzioni dell'indice a livello di raccolta su tutti i campi di un gruppo di raccolte. Ad esempio, per il gruppo di raccolte comments, imposta
il percorso del campo su * in modo che corrisponda a tutti i campi nel gruppo di raccolte comments e
disabilita l'indicizzazione di tutti i campi all'interno del gruppo di raccolte. Puoi quindi aggiungere esenzioni per indicizzare solo i campi obbligatori per le tue query. La riduzione del numero di campi indicizzati riduce i costi di archiviazione e può migliorare le prestazioni di scrittura.
Se crei un'esenzione per l'indice a campo singolo per un campo della mappa, i campi secondari della mappa ereditano queste impostazioni. Tuttavia, puoi definire esenzioni dell'indice a campo singolo per sottocampi specifici. Se elimini un'esenzione per un sottocampo, il sottocampo erediterà le impostazioni di esenzione del relativo elemento padre, se presenti, o le impostazioni a livello di database, in assenza di esenzioni padre.
Per creare e gestire esenzioni degli indici a campo singolo, consulta Gestione degli indici in Firestore.
Indici composti
Un indice composto archivia un mapping ordinato di tutti i documenti di una raccolta, in base a un elenco ordinato di campi da indicizzare.
Firestore utilizza indici composti per supportare query non supportate dagli indici a campo singolo.
Firestore non crea automaticamente indici composti come fa per gli indici a campo singolo a causa dell'elevato numero di combinazioni di campi possibili. Firestore ti aiuta invece a identificare e creare indici composti richiesti durante la creazione dell'app.
Se provi a eseguire la query precedente senza prima creare l'indice richiesto, Firestore restituisce un messaggio di errore contenente un link che puoi seguire per creare l'indice mancante. Questo accade ogni volta che tenti di eseguire una query non supportata da un indice. Puoi anche definire e gestire gli indici composti manualmente utilizzando la console o l'interfaccia a riga di comando di Firebase. Per saperne di più sulla creazione e sulla gestione degli indici composti, consulta Gestione degli indici.
Modalità di indice e ambiti di query
La configurazione degli indici a campo singolo e degli indici composti è differente, ma entrambi richiedono la configurazione delle modalità di indice e degli ambiti di query per gli indici.
Modalità indice
Quando definisci un indice, selezioni una modalità per ogni campo indicizzato. La modalità di indicizzazione di ogni campo supporta clausole di query specifiche per quel campo. Puoi scegliere tra le seguenti modalità di indice:
| Modalità indice | Descrizione |
|---|---|
| Crescente | Supporta le clausole di query <, <=, ==, >=, >, !=, in e not-in sul campo e supporta l'ordinamento dei risultati in ordine crescente in base a questo valore del campo. |
| Decrescente | Supporta le clausole di query <, <=, ==, >=, >, !=, in e not-in sul campo e supporta l'ordinamento dei risultati in ordine decrescente in base a questo valore del campo. |
| Array-contiene | Supporta le clausole di query array-contains e array-contains-any sul campo. |
| Vector | Supporta le clausole di query FindNearest sul campo. |
Ambiti di query
Ogni indice ha come ambito una raccolta o un gruppo di raccolte. Questo è noto come ambito di query dell'indice:
- Ambito della raccolta
- Firestore crea indici con ambito di raccolta per impostazione predefinita. Questi indici supportano le query che restituiscono risultati da una singola raccolta.
- Ambito del gruppo di raccolte
- Un gruppo di raccolte include tutte le collezioni con lo stesso ID raccolta. Per eseguire una query sul gruppo di raccolte che restituisce risultati filtrati o ordinati da un gruppo di raccolte, devi creare un indice corrispondente con l'ambito del gruppo di raccolte.
Ordine predefinito e campo __name__
Oltre a ordinare i documenti in base alle modalità di indice specificate per ogni campo (ordine crescente o decrescente) , gli indici applicano un ordinamento finale in base al campo __name__ di ogni documento. Il valore del campo __name__ è impostato sul percorso completo del documento. Ciò significa che i documenti nel set di risultati con gli stessi valori dei campi sono ordinati in base al percorso del documento.
Per impostazione predefinita, il campo __name__ viene ordinato nella stessa direzione dell'ultimo campo ordinato nella definizione dell'indice. Ad esempio:
| Raccolta | Campi indicizzati | Ambito di query |
|---|---|---|
| cities | Nome , __name__ |
Raccolta |
| cities | stato, __name__ |
Raccolta |
| cities | paese, popolazione, __name__ |
Raccolta |
Per ordinare i risultati in base alla direzione __name__ non predefinita, devi creare questo indice.
Indice perfetto
L'indice perfetto per una query, che consente di eseguirla nel modo più efficiente, viene definito nelle seguenti proprietà, in ordine:
- Campi utilizzati nei filtri di uguaglianza
- Campi utilizzati negli ordini
- Campi utilizzati nei filtri di intervallo e disuguaglianza (non ancora inclusi negli ordini di ordinamento)
- Campi utilizzati nelle aggregazioni (non ancora inclusi negli ordini di ordinamento e nei filtri di intervallo e disuguaglianza)
Firestore calcola i risultati delle query nel seguente modo:
- Identifica l'indice corrispondente alla raccolta, alle proprietà di filtro, agli operatori di filtro e agli ordini di ordinamento della query
- Identifica la posizione dell'indice da cui iniziare la scansione utilizzando i filtri di uguaglianza e l'intervallo e la disuguaglianza della query nel primo ordine per campo
- Avvia la scansione dell'indice, restituendo ogni documento che soddisfa tutti i filtri finché:
- rileva un documento che non soddisfa le condizioni di filtro e conferma che qualsiasi documento successivo non soddisferà mai completamente le condizioni di filtro, oppure
- raggiunge la fine dell'indice o
- ha raccolto il numero massimo di risultati richiesti dalla query
Esempio di indicizzazione
Creando automaticamente indici a campo singolo, Firestore consente all'applicazione di supportare rapidamente le query di base dei database.
Gli indici a campo singolo consentono di eseguire query semplici basate sui valori dei campi e sui comparatori <, <=, ==, >=, > e in. Per i campi array, consentono di eseguire query array-contains e array-contains-any.
Per spiegarci meglio, esamina i seguenti esempi dal punto di vista della creazione dell'indice. Lo snippet seguente crea alcuni
documenti city in una raccolta cities e imposta i campi name, state,
country, capital, population e tags per ciascun documento:
Web
var citiesRef = db.collection("cities");
citiesRef.doc("SF").set({
name: "San Francisco", state: "CA", country: "USA",
capital: false, population: 860000,
regions: ["west_coast", "norcal"] });
citiesRef.doc("LA").set({
name: "Los Angeles", state: "CA", country: "USA",
capital: false, population: 3900000,
regions: ["west_coast", "socal"] });
citiesRef.doc("DC").set({
name: "Washington, D.C.", state: null, country: "USA",
capital: true, population: 680000,
regions: ["east_coast"] });
citiesRef.doc("TOK").set({
name: "Tokyo", state: null, country: "Japan",
capital: true, population: 9000000,
regions: ["kanto", "honshu"] });
citiesRef.doc("BJ").set({
name: "Beijing", state: null, country: "China",
capital: true, population: 21500000,
regions: ["jingjinji", "hebei"] });
Supponendo le impostazioni di indicizzazione automatica predefinite, Firestore aggiorna un indice a campo singolo crescente per campo non array, un indice a campo singolo decrescente per campo non array e un indice a campo singolo contenente un array per il campo dell'array. Ogni riga nella tabella seguente rappresenta una voce in un indice a campo singolo:
| Raccolta | Campo indicizzato | Ambito di query |
|---|---|---|
| cities | Nome | Raccolta |
| cities | stato | Raccolta |
| cities | paese | Raccolta |
| cities | maiuscola | Raccolta |
| cities | popolazione | Raccolta |
| cities | Nome | Raccolta |
| cities | stato | Raccolta |
| cities | paese | Raccolta |
| cities | maiuscola | Raccolta |
| cities | popolazione | Raccolta |
| cities | array-contains regioni |
Raccolta |
Query supportate da indici a campo singolo
Utilizzando questi indici a campo singolo creati automaticamente, puoi eseguire query semplici come le seguenti:
Web
const stateQuery = citiesRef.where("state", "==", "CA");
const populationQuery = citiesRef.where("population", "<", 100000);
const nameQuery = citiesRef.where("name", ">=", "San Francisco");
Puoi anche creare query in e di uguaglianza composta (==):
Web
citiesRef.where('country', 'in', ["USA", "Japan", "China"])
// Compound equality queries
citiesRef.where("state", "==", "CO").where("name", "==", "Denver")
citiesRef.where("country", "==", "USA")
.where("capital", "==", false)
.where("state", "==", "CA")
.where("population", "==", 860000)
Se devi eseguire una query composta che utilizza un confronto di intervalli (<, <=, > o >=) o se devi ordinare i dati in base a un campo diverso, devi creare un indice composto per la query.
L'indice array-contains consente di eseguire query sul campo array regions:
Web
citiesRef.where("regions", "array-contains", "west_coast")
// array-contains-any and array-contains use the same indexes
citiesRef.where("regions", "array-contains-any", ["west_coast", "east_coast"])
Query supportate da indici composti
Firestore utilizza indici composti per supportare query composte non ancora supportate dagli indici a campo singolo. Ad esempio, dovresti avere un indice composto per le seguenti query:
Web
citiesRef.where("country", "==", "USA").orderBy("population", "asc")
citiesRef.where("country", "==", "USA").where("population", "<", 3800000)
citiesRef.where("country", "==", "USA").where("population", ">", 690000)
// in and == clauses use the same index
citiesRef.where("country", "in", ["USA", "Japan", "China"])
.where("population", ">", 690000)
Queste query richiedono l'indice composto di seguito. Poiché la query utilizza
un'uguaglianza (== o in) per il campo country, puoi utilizzare
una modalità di indice crescente o decrescente per questo campo. Per impostazione predefinita, le clausole di disuguaglianza applicano un ordinamento crescente in base al campo nella clausola di disuguaglianza.
| Raccolta | Campi indicizzati | Ambito di query |
|---|---|---|
| cities | (o ) paese, popolazione | Raccolta |
Per eseguire le stesse query, ma in un ordinamento decrescente, devi disporre di un indice composto aggiuntivo in direzione decrescente per population:
Web
citiesRef.where("country", "==", "USA").orderBy("population", "desc")
citiesRef.where("country", "==", "USA")
.where("population", "<", 3800000)
.orderBy("population", "desc")
citiesRef.where("country", "==", "USA")
.where("population", ">", 690000)
.orderBy("population", "desc")
citiesRef.where("country", "in", ["USA", "Japan", "China"])
.where("population", ">", 690000)
.orderBy("population", "desc")
| Raccolta | Campi indicizzati | Ambito di query |
|---|---|---|
| cities | paese, popolazione | Raccolta |
| città | paese, popolazione | Raccolta |
Devi anche creare un indice composto per combinare una query array-contains o array-contains-any con clausole aggiuntive.
Web
citiesRef.where("regions", "array-contains", "east_coast")
.where("capital", "==", true)
// array-contains-any and array-contains use the same index
citiesRef.where("regions", "array-contains-any", ["west_coast", "east_coast"])
.where("capital", "==", true)
| Raccolta | Campi indicizzati | Ambito di query |
|---|---|---|
| cities | Tag array-contains, tag (o ) con lettere maiuscole | Raccolta |
Query supportate dagli indici dei gruppo di raccolte
Per dimostrare un indice con l'ambito del gruppo di raccolte, immagina di aggiungere una
sottoraccolta landmarks ad alcuni dei documenti city:
Web
var citiesRef = db.collection("cities");
citiesRef.doc("SF").collection("landmarks").doc().set({
name: "Golden Gate Bridge",
category : "bridge" });
citiesRef.doc("SF").collection("landmarks").doc().set({
name: "Golden Gate Park",
category : "park" });
citiesRef.doc("DC").collection("landmarks").doc().set({
name: "National Gallery of Art",
category : "museum" });
citiesRef.doc("DC").collection("landmarks").doc().set({
name: "National Mall",
category : "park" });
Utilizzando il seguente indice a campo singolo con ambito di raccolta, puoi eseguire query sulla raccolta landmarks di una singola città in base al campo category:
| Raccolta | Campi indicizzati | Ambito di query |
|---|---|---|
| punti di riferimento | Categoria (o ) | Raccolta |
Web
citiesRef.doc("SF").collection("landmarks").where("category", "==", "park")
citiesRef.doc("SF").collection("landmarks").where("category", "in", ["park", "museum"])
Ora, immagina di essere interessato a interrogare i punti di riferimento di tutte le città.
Per eseguire questa query sul gruppo di raccolte composto da tutte le raccolte landmarks, devi abilitare un indice a campo singolo landmarks con ambito del gruppo di raccolta:
| Raccolta | Campi indicizzati | Ambito di query |
|---|---|---|
| punti di riferimento | Categoria (o ) | Gruppo di raccolte |
Con questo indice abilitato, puoi eseguire query sul gruppo di raccolte landmarks:
Web
var landmarksGroupRef = db.collectionGroup("landmarks");
landmarksGroupRef.where("category", "==", "park")
landmarksGroupRef.where("category", "in", ["park", "museum"])
Per eseguire una query su un gruppo di raccolte che restituisce risultati filtrati o ordinati, devi abilitare un indice a campo singolo o composto corrispondente con ambito del gruppo di raccolte. Le query sui gruppi di raccolte che non filtrano o ordinano i risultati, tuttavia, non richiedono definizioni di indice aggiuntive.
Ad esempio, puoi eseguire la seguente query sul gruppo di raccolte senza abilitare un indice aggiuntivo:
Web
db.collectionGroup("landmarks").get()
Voci di indice
Gli indici configurati del progetto e la struttura di un documento determinano il numero di voci di indice per un documento. Le voci di indice vengono conteggiate ai fini del limite del numero di voci di indice.
L'esempio seguente illustra le voci di indice di un documento.
Documento
/cities/SF
city_name : "San Francisco"
temperatures : {summer: 67, winter: 55}
neighborhoods : ["Mission", "Downtown", "Marina"]
Indici a campo singolo
- ASC nome_città
- nome_città DESC
- temperature.estate ASC
- temperature.estate DESC
- temperature.inverno ASC
- temperature.inverno DESC
- Array di quartieri contiene (ASC e DESC)
Indici composti
- city_name ASC, quartieri ARRAY
- city_name DESC, quartieri ARRAY
Voci di indice
Questa configurazione di indicizzazione genera le seguenti 18 voci di indice per il documento:
| Indice | Dati indicizzati |
|---|---|
| Voci di indice a campo singolo | |
| ASC nome_città | city_name: "San Francisco" |
| nome_città DESC | city_name: "San Francisco" |
| temperature.estate ASC | temperature.estate: 67 |
| temperature.estate DESC | temperature.estate: 67 |
| temperature.inverno ASC | temperature.inverno: 55 |
| temperature.inverno DESC | temperature.inverno: 55 |
| quartieri Array contiene ASC | quartieri: "Missione" |
| Array di quartieri Contiene DESC | quartieri: "Missione" |
| quartieri Array contiene ASC | quartieri: "Centro" |
| Array di quartieri Contiene DESC | quartieri: "Centro" |
| quartieri Array contiene ASC | quartieri: "Marina" |
| Array di quartieri Contiene DESC | quartieri: "Marina" |
| Voci di indice composite | |
| city_name ASC, quartieri ARRAY | city_name: "Roma", quartieri: "Mission" |
| city_name ASC, quartieri ARRAY | city_name: "San Francisco", quartieri: "Centro" |
| city_name ASC, quartieri ARRAY | city_name: "Roma", quartieri: "Marina" |
| city_name DESC, quartieri ARRAY | city_name: "Roma", quartieri: "Mission" |
| city_name DESC, quartieri ARRAY | city_name: "San Francisco", quartieri: "Centro" |
| city_name DESC, quartieri ARRAY | city_name: "Roma", quartieri: "Marina" |
Indici e prezzi
Gli indici contribuiscono ai costi di archiviazione dell'applicazione. Per saperne di più su come vengono calcolate le dimensioni di archiviazione per gli indici, consulta Dimensioni delle voci di indice.
Sfruttamento dell'unione degli indici
Anche se Firestore utilizza un indice per ogni query, non richiede necessariamente un indice per query. Per le query con più clausole di uguaglianza
(==) e, facoltativamente, una clausola orderBy, Firestore può
riutilizzare gli indici esistenti. Firestore può unire gli indici per semplici filtri di uguaglianza al fine di creare gli indici composti necessari per query con uguaglianza più grandi.
Puoi ridurre i costi di indicizzazione identificando situazioni in cui puoi trarre vantaggio dall'unione degli indici. Ad esempio, immagina una raccolta restaurants per
un'app di valutazione di ristoranti:
ristoranti
burgerthyme di
name : "Burger Thyme"
category : "burgers"
city : "San Francisco"
editors_pick : true
star_rating : 4
Ora, immagina che questa app utilizzi query come quelle riportate di seguito. Tieni presente che l'app utilizza
combinazioni di clausole di uguaglianza per category, city e editors_pick
e ordina sempre in ordine crescente star_rating:
Web
db.collection("restaurants").where("category", "==", "burgers")
.orderBy("star_rating")
db.collection("restaurants").where("city", "==", "San Francisco")
.orderBy("star_rating")
db.collection("restaurants").where("category", "==", "burgers")
.where("city", "==", "San Francisco")
.orderBy("star_rating")
db.collection("restaurants").where("category", "==", "burgers")
.where("city", "==" "San Francisco")
.where("editors_pick", "==", true )
.orderBy("star_rating")
Potresti creare un indice per ogni query:
| Raccolta | Campi indicizzati | Ambito di query |
|---|---|---|
| ristoranti | Categoria , star_rating | Raccolta |
| ristoranti | città, star_rating | Raccolta |
| ristoranti | Categoria , città, star_rating | Raccolta |
| ristoranti | Categoria , città, editor_pick, star_rating | Raccolta |
Come soluzione migliore, puoi ridurre il numero di indici sfruttando la capacità di Firestore di unire gli indici per le clausole di uguaglianza:
| Raccolta | Campi indicizzati | Ambito di query |
|---|---|---|
| ristoranti | Categoria , star_rating | Raccolta |
| ristoranti | città, star_rating | Raccolta |
| ristoranti | editor_scegli, star_rating | Raccolta |
Questo insieme di indici non solo è più piccolo, ma supporta anche una query aggiuntiva:
Web
db.collection("restaurants").where("editors_pick", "==", true)
.orderBy("star_rating")
Limiti di indicizzazione
Agli indici si applicano i seguenti limiti. Per tutte le quote e i limiti, consulta Quote e limiti.
Questa pagina identifica le quote e i limiti delle richieste per Firestore.
| Limite | Dettagli |
|---|---|
| Numero massimo di indici composti per un database |
|
| Numero massimo di configurazioni a campo singolo per un database |
Una configurazione a livello di campo può contenere più configurazioni per lo stesso campo. Ad esempio, un'esenzione dell'indicizzazione a campo singolo e un criterio TTL nello stesso campo vengono conteggiati come una configurazione del campo per il limite. |
|
Numero massimo di voci di indice per ogni documento |
40.000 Il numero di voci di indice corrisponde alla somma di quanto segue per un documento:
Per scoprire in che modo Firestore trasforma un documento e una serie di indici in voci di indice, vedi questo esempio di conteggio di voci di indice. |
| Numero massimo di campi in un indice composto | 100 |
| Dimensione massima di una voce di indice |
7,5 KiB Per scoprire in che modo Firestore calcola la dimensione di una voce di indice, vai alla pagina Dimensioni delle voci di indice. |
| Somma massima delle dimensioni delle voci di indice di un documento |
8 MiB La dimensione totale corrisponde alla somma di quanto segue per un documento: |
| Dimensione massima di un valore di campo indicizzato |
1500 byte I valori di campo superiori a 1500 byte vengono troncati. Le query che includono valori di campo troncati possono restituire risultati incoerenti. |
Best practice per l'indicizzazione
Per la maggior parte delle app, puoi fare affidamento sull'indicizzazione automatica e sui link dei messaggi di errore per gestire gli indici. Tuttavia, ti consigliamo di aggiungere esenzioni a campo singolo nei seguenti casi:
| Richiesta | Descrizione |
|---|---|
| Campi stringa grandi | Se hai un campo stringa che spesso contiene valori stringa lunghi che non utilizzi per le query, puoi ridurre i costi di archiviazione esenzione il campo dall'indicizzazione. |
| Velocità di scrittura elevate in una raccolta contenente documenti con valori sequenziali | Se indicizzi un campo che aumenta o diminuisce in sequenza tra i documenti di una raccolta, ad esempio un timestamp, la frequenza di scrittura massima nella raccolta è di 500 scritture al secondo. Se non esegui una query in base al campo con valori sequenziali, puoi escludere il campo dall'indicizzazione per bypassare questo limite. In un caso d'uso IoT con un'elevata frequenza di scrittura, ad esempio, una raccolta contenente documenti con un campo timestamp potrebbe avvicinarsi al limite di 500 scritture al secondo. |
| Campi TTL |
Se utilizzi i criteri TTL (time-to-live), tieni presente che il campo TTL deve contenere un timestamp. L'indicizzazione sui campi TTL è abilitata per impostazione predefinita e può influire sulle prestazioni a frequenze di traffico più elevate. Come best practice, aggiungi esenzioni a campo singolo per i campi TTL. |
| Matrice grande o mappa campi | I campi a array o sulla mappa di grandi dimensioni possono avvicinarsi al limite di 40.000 voci di indice per documento. Se non esegui query basate su un array o un campo della mappa di grandi dimensioni, dovresti esentarli dall'indicizzazione. |
Se utilizzi query con operatori di intervallo e disuguaglianza su più campi, consulta le considerazioni sull'indicizzazione da prendere in considerazione per ottimizzare le prestazioni e il costo delle query di Firestore
Per ulteriori informazioni su come risolvere i problemi di indicizzazione (fanout indice, INVALID_ARGUMENT errori), consulta la pagina per la risoluzione dei problemi.