Panoramica dell'indicizzazione
Gli indici sono un fattore importante per le prestazioni di un database. Come l'indice di un libro che mappa gli argomenti ai numeri di pagina, un indice di database mappa gli elementi di un database alle relative posizioni. Quando esegui una query su un database, il database può utilizzare un indice per identificare rapidamente le posizioni degli elementi richiesti.
Questa pagina descrive i due tipi di indici utilizzati da Firestore: indici a campo singolo e indici composti.
Definizione e struttura dell'indice
Un indice è definito in un elenco di campi di un determinato documento, con una corrispondente modalità di indice per ogni campo.
Un indice contiene una voce per ogni campo denominato nella definizione dell'indice. L' indice include tutti i documenti che sono i potenziali risultati delle query basate sull' indice. Un documento viene incluso nell'indice solo se ha un valore indicizzato impostato per ogni campo utilizzato nell'indice. Se la definizione dell'indice fa riferimento a un campo per il quale non è stato impostato alcun valore nel documento, il documento non verrà visualizzato nell'indice. In questo caso, il documento non verrà mai restituito come risultato di alcuna query basata sull'indice.
L'indice composto è 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 con la crescita del database. Firestore garantisce elevate prestazioni delle query utilizzando gli indici per tutte le query. Di conseguenza, le prestazioni delle query dipendono dalle dimensioni del set di risultati e non dal numero di elementi nel database.
Meno gestione degli indici, più sviluppo di app
Firestore include funzionalità che riducono il tempo necessario per la gestione degli indici. Gli indici richiesti per le query più di base vengono creati automaticamente. Mentre utilizzi e testi la tua app, Firestore ti aiuta a identificare e creare indici aggiuntivi necessari per la tua app.
Tipi di indice
Firestore utilizza due tipi di indici: a campo singolo e composti. Oltre al numero di campi indicizzati, gli indici a campo singolo e quelli composti differiscono per il modo in cui vengono gestiti.
Indici a campo singolo
Un indice a campo singolo archivia una mappatura ordinata di tutti i documenti di una raccolta che contengono un campo specifico. Ogni voce di un indice a campo singolo registra il valore di un documento per un campo specifico e la posizione del documento nel database. Firestore utilizza questi indici per eseguire molte query di base. Gestisci gli indici a campo singolo configurando le impostazioni di indicizzazione automatica e le esenzioni dell'indice del database.
Indicizzazione automatica
Per impostazione predefinita, Firestore gestisce automaticamente gli indici a un solo campo per ogni campo di un documento e per ogni sottocampo 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 a livello di raccolta, uno in modalità crescente e uno in modalità decrescente.
Per ogni campo mappa, Firestore crea quanto segue:
- Un indice crescente a livello di raccolta per ogni sottocampo non array e non mappa.
- Un indice decrescente a livello di raccolta per ogni sottocampo non array e non mappa.
- Un indice array-contains a livello di raccolta 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 contiene array a livello di raccolta.
Gli indici a campo singolo con ambito del gruppo di raccolte non vengono gestiti per impostazione predefinita.
Esenzioni dell'indice a campo singolo
Puoi esentare un campo dalle impostazioni di indicizzazione automatica creando un'esenzione per un 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 dall'indice a livello di raccolta a tutti
i campi di un gruppo di raccolte. Ad esempio, per il gruppo di raccolte comments, imposta il percorso del campo su * per trovare una corrispondenza in tutti i campi del gruppo di raccolte comments e disattiva l'indicizzazione di tutti i campi nel gruppo di raccolte. Puoi quindi aggiungere esenzioni per indicizzare solo i campi richiesti per le query. La riduzione del numero di campi indicizzati riduce i costi di archiviazione e può migliorare le prestazioni di scrittura.
Se crei un'esenzione dell'indice a campo singolo per un campo mappa, i campi secondari della mappa erediteranno queste impostazioni. Tuttavia, puoi definire esenzioni per gli indici a campo singolo per sottocampi specifici. Se elimini un'esenzione per un sottocampo, il sottocampo erediterà le impostazioni di esenzione del campo principale, se esistenti, o le impostazioni a livello di database se non esistono esenzioni principali.
Per creare e gestire le esenzioni dell'indice a campo singolo, consulta Gestire gli indici.
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 gli indici composti per supportare le query non già supportate dagli indici a campo singolo.
Firestore non crea automaticamente indici composti come avviene per gli indici a un campo a causa del numero elevato di possibili combinazioni di campi. Firestore, invece, ti aiuta a identificare e creare gli indici composti richiesti durante la creazione dell'app.
Ogni volta che provi a eseguire una query non supportata da un indice, Firestore restituisce un messaggio di errore con un link che puoi seguire per creare l'indice mancante.
Puoi anche definire e gestire manualmente gli indici compositi utilizzando la console o l'interfaccia a riga di comando di Firebase. Per scoprire di più sulla creazione e sulla gestione degli indici compositi, consulta Gestire gli indici.
Modalità di indicizzazione e ambiti di query
Gli indici a campo singolo e composti vengono configurati in modo diverso, ma entrambi richiedono la configurazione delle modalità di indice e degli ambiti di query per gli indici.
Modalità di indicizzazione
Quando definisci un indice, selezioni una modalità di indice per ogni campo indicizzato. La modalità di indice di ogni campo supporta clausole di query specifiche per quel campo. Puoi scegliere tra le seguenti modalità di indice:
| Modalità di indice | Descrizione |
|---|---|
| In ordine crescente | Supporta le clausole di query <, <=, ==, >=, >, !=, in e not-in nel campo e l'ordinamento dei risultati in ordine crescente in base al valore di questo campo. |
| In ordine decrescente | Supporta le clausole di query <, <=, ==, >=, >, !=, in e not-in nel campo e supporta l'ordinamento dei risultati in ordine decrescente in base al valore di questo campo. |
| Array‑contains | Supporta le clausole di query array-contains e array-contains-any nel campo. |
| Vector | Supporta le clausole di query FindNearest nel campo. |
Ambiti di query
Ogni indice è limitato a una raccolta o a un gruppo di raccolte. Questo è noto come ambito di query dell'indice:
- Ambito della raccolta
- Per impostazione predefinita, Firestore crea indici con ambito della raccolta. Questi indici supportano le query che restituiscono risultati da una singola raccolta.
- Ambito del gruppo di raccolte
- Un gruppo di raccolte include tutte le raccolte 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 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 (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 di campo 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 | name, __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.
Proprietà dell'indice
Un indice che consente di eseguire la query in modo più efficiente è definito dalle seguenti proprietà:
- Campi utilizzati nei filtri di uguaglianza
- Campi utilizzati negli ordini di ordinamento
- Campi utilizzati nei filtri di intervallo e di disuguaglianza (non ancora inclusi negli ordini di ordinamento)
- Campi utilizzati nelle aggregazioni (che non sono già inclusi negli ordini di ordinamento e nei filtri di intervallo e disuguaglianza)
Firestore calcola i risultati delle query come segue:
- 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 inizia la scansione. La posizione iniziale è preceduta dai filtri di uguaglianza della query e termina con i filtri di intervallo e di disuguaglianza nel primo campo
orderBy. - Avvia la scansione dell'indice, restituendo ogni documento che soddisfa tutti i filtri, finché il processo di scansione non esegue una delle seguenti operazioni:
- Rileva un documento che non soddisfa le condizioni del filtro e conferma che nessun documento successivo soddisferà mai completamente le condizioni del filtro.
- Raggiunge la fine dell'indice.
- Raccoglie il numero massimo di risultati richiesti dalla query.
Esempio di indicizzazione
Creando automaticamente indici a un campo, Firestore consente alla tua applicazione di supportare rapidamente le query di database più semplici.
Gli indici a campo singolo ti consentono di eseguire query semplici in base ai valori di campo
e ai comparatori <, <=, ==, >=, > e in. Per i campi array, ti consentono di eseguire query array-contains e array-contains-any.
Per fare un esempio, esamina i seguenti esempi dal punto di vista della creazione dell'indice. Il seguente snippet crea alcuni documenti city in una raccolta cities e imposta i campi name, state,
country, capital, population e tags per ogni 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"] });
Se si assumono le impostazioni di indicizzazione automatica predefinite, Firestore aggiorna un indice a campo singolo crescente per ogni campo non array, un indice a campo singolo decrescente per ogni campo non array e un indice a campo singolo contenente array per il campo array. Ogni riga della tabella seguente rappresenta una voce in un indice a un campo:
| Raccolta | Campo indicizzato | Ambito di query |
|---|---|---|
| cities | Nome | Raccolta |
| cities | Stato | Raccolta |
| cities | paese | Raccolta |
| cities | Capitale di | Raccolta |
| cities | popolazione | Raccolta |
| cities | Nome | Raccolta |
| cities | Stato | Raccolta |
| cities | paese | Raccolta |
| cities | Capitale di | Raccolta |
| cities | popolazione | Raccolta |
| cities | array-contains regioni |
Raccolta |
Query supportate dagli indici a campo singolo
Utilizzando questi indici a campo singolo creati automaticamente, puoi eseguire query semplici come la seguente:
Web
const stateQuery = citiesRef.where("state", "==", "CA"); const populationQuery = citiesRef.where("population", "<", 100000); const nameQuery = citiesRef.where("name", ">=", "San Francisco");
Puoi anche creare query di uguaglianza composta (==) e in:
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 in base a un campo diverso, devi creare un
indice composito per quella query.
L'indice array-contains ti consente di eseguire query sul campo dell'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 dagli indici composti
Firestore utilizza gli indici composti per supportare le query composte non ancora supportate dagli indici a campo singolo. Ad esempio, avresti bisogno di 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 riportato 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 ordine di 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 con un ordinamento decrescente,
è necessario un indice composito aggiuntivo in ordine 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à | country, population | Raccolta |
Per evitare la perdita di prestazioni causata dall'unione di indici, ti consigliamo di creare un indice composito 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, (o ) maiuscolo | Raccolta |
Query supportate dagli indici dei gruppo di raccolte
Per dimostrare un indice con ambito del gruppo di raccolte, aggiungi una
landmarks sottoraccolta 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 della 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 | (o ) categoria | Raccolta |
Web
citiesRef.doc("SF").collection("landmarks").where("category", "==", "park")
citiesRef.doc("SF").collection("landmarks").where("category", "in", ["park", "museum"])Ad esempio, se ti interessa eseguire query sui punti di riferimento di tutte le città,
esegui questa query sul gruppo di raccolte costituito da tutte le raccolte landmarks. Devi anche attivare un landmarks indice a campo singolo con
ambito del gruppo di raccolte:
| Raccolta | Campi indicizzati | Ambito di query |
|---|---|---|
| punti di riferimento | (o ) categoria | Gruppo di raccolte |
Con questo indice attivato, 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 sul gruppo di raccolte che restituisce risultati filtrati o ordinati, devi attivare un indice composito o a campo singolo corrispondente con ambito del gruppo di raccolte. Tuttavia, le query sui gruppi di raccolte che non filtrano o ordinano i risultati non richiedono definizioni di indici aggiuntive.
Ad esempio, puoi eseguire la seguente query sul gruppo di raccolte senza attivare un indice aggiuntivo:
Web
db.collectionGroup("landmarks").get()Voci dell'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 concorrono al raggiungimento del limite di voci di indice.
L'esempio seguente mostra 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
- city_name ASC
- city_name DESC
- temperatures.summer ASC
- temperatures.summer DESC
- temperatures.winter ASC
- temperatures.winter DESC
- L'array contiene quartieri (ASC e DESC)
Indici composti
- city_name ASC, ARRAY di quartieri
- city_name DESC, neighborhoods ARRAY
Voci dell'indice
Questa configurazione dell'indicizzazione genera le seguenti voci dell'indice per il documento:
| Indice | Dati indicizzati |
|---|---|
| Voci dell'indice a campo singolo | |
| city_name ASC | city_name: "San Francisco" |
| city_name DESC | city_name: "San Francisco" |
| temperatures.summer ASC | temperatures.summer: 67 |
| temperatures.summer DESC | temperatures.summer: 67 |
| temperatures.winter ASC | temperatures.winter: 55 |
| temperatures.winter DESC | temperatures.winter: 55 |
| L'array quartieri contiene ASC | neighborhoods: "Mission" |
| L'array neighborhoods contiene DESC | neighborhoods: "Mission" |
| L'array quartieri contiene ASC | neighborhoods: "Downtown" |
| L'array neighborhoods contiene DESC | neighborhoods: "Downtown" |
| L'array quartieri contiene ASC | neighborhoods: "Marina" |
| L'array neighborhoods contiene DESC | neighborhoods: "Marina" |
| Voci dell'indice composito | |
| city_name ASC, ARRAY di quartieri | city_name: "San Francisco", neighborhoods: "Mission" |
| city_name ASC, ARRAY di quartieri | city_name: "San Francisco", neighborhoods: "Downtown" |
| city_name ASC, ARRAY di quartieri | city_name: "San Francisco", neighborhoods: "Marina" |
| city_name DESC, neighborhoods ARRAY | city_name: "San Francisco", neighborhoods: "Mission" |
| city_name DESC, neighborhoods ARRAY | city_name: "San Francisco", neighborhoods: "Downtown" |
| city_name DESC, neighborhoods ARRAY | city_name: "San Francisco", neighborhoods: "Marina" |
Indici e prezzi
Gli indici contribuiscono ai costi di archiviazione della tua applicazione. Per ulteriori informazioni su come calcolare le dimensioni dello spazio di archiviazione per gli indici, consulta Dimensioni delle voci di indice.
Utilizzare l'unione degli indici
Sebbene Firestore utilizzi 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 i filtri di uguaglianza semplici per creare gli indici composti necessari per query di uguaglianza più grandi.
Puoi ridurre i costi di indicizzazione identificando le situazioni in cui puoi utilizzare l'unione di indici. Ad esempio, in una raccolta restaurants per un'app di valutazione dei ristoranti:
ristoranti
burgerthyme
name : "Burger Thyme"
category : "burgers"
city : "San Francisco"
editors_pick : true
star_rating : 4
Questa app utilizza query come la seguente. L'app utilizza combinazioni di clausole di uguaglianza per category, city e editors_pick, ordina sempre in ordine crescente per 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")Puoi creare un indice per ogni query:
| Raccolta | Campi indicizzati | Ambito di query |
|---|---|---|
| ristoranti | category, star_rating | Raccolta |
| ristoranti | city, star_rating | Raccolta |
| ristoranti | category, city, star_rating | Raccolta |
| ristoranti | category, city, editors_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 | category, star_rating | Raccolta |
| ristoranti | city, star_rating | Raccolta |
| ristoranti | editors_pick, star_rating | Raccolta |
Questo insieme di indici non è solo più piccolo, ma supporta anche un'altra query:
Web
db.collection("restaurants").where("editors_pick", "==", true)
.orderBy("star_rating")Limiti di indicizzazione
Ai seguenti limiti si applicano gli indici. Per ulteriori informazioni su quote e limiti, consulta Quote e limiti.
Questa pagina indica 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'indice a campo singolo e un criterio TTL nello stesso campo vengono conteggiati come una configurazione di campo ai fini del raggiungimento del 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 utilizzare l'indicizzazione automatica e i link ai messaggi di errore per gestire gli indici. Tuttavia, ti consigliamo di aggiungere eccezioni per un singolo campo nei seguenti casi:
| Richiesta | Descrizione |
|---|---|
| Campi di stringhe di grandi dimensioni | Se hai un campo di stringhe che spesso contiene valori di stringhe lunghe che non utilizzi per le query, puoi ridurre i costi di archiviazione esentando il campo dall'indicizzazione. |
| Frequenze di scrittura elevate in una raccolta contenente documenti con valori sequenziali | Se indicizzi un campo che aumenta o diminuisce in modo sequenziale tra i documenti di una raccolta, ad esempio un timestamp, la frequenza di scrittura massima per la raccolta è di 500 scritture al secondo. Se non esegui query in base al campo con valori sequenziali, puoi esentare il campo dall'indicizzazione per aggirare questo limite. In un caso d'uso IoT con una frequenza di scrittura elevata, ad esempio, una raccolta contenente documenti con un campo timestamp potrebbe avvicinarsi al limite di 500 scritture al secondo. |
| Campi TTL |
Se utilizzi le policy di durata (TTL), tieni presente che il campo TTL deve essere un timestamp. L'indicizzazione nei campi TTL è attivata per impostazione predefinita e può influire sul rendimento a tassi di traffico più elevati. Come best practice, aggiungi esenzioni a campo singolo per i campi TTL. |
| Array o campi mappa di grandi dimensioni | I campi di mappe o array di grandi dimensioni possono avvicinarsi al limite di 40.000 voci dell'indice per documento. Se non esegui query in base a un array o a un campo mappa di grandi dimensioni, devi esentarli dall'indicizzazione. |
Se utilizzi query con operatori di intervallo e di disuguaglianza su più campi, consulta le considerazioni sull'indicizzazione da tenere presenti per ottimizzare le prestazioni e il costo delle query Firestore.
Per ulteriori informazioni su come risolvere i problemi di indicizzazione (fanout dell'indice, errori INVALID_ARGUMENT), consulta la pagina sulla risoluzione dei problemi.