Cloud Firestore supporta l'utilizzo di filtri per intervallo e disuguaglianza su più campi in una singola query. Puoi avere condizioni di intervallo e di disuguaglianza su più campi e semplificare lo sviluppo delle applicazioni delegando l'implementazione della logica di post-filtro a Cloud Firestore.
Filtri di intervallo e disuguaglianza su più campi
La seguente query utilizza filtri per intervallo su popolazione e densità per restituire tutte le città in cui la popolazione è superiore a 1.000.000 di persone e la densità di popolazione è inferiore a 10.000 persone per unità di area.
Versione web 9 modulare
const q = query(
collection(db, "cities"),
where('population', '>', 1000000),
where('density', '<', 10000),
);
Swift
let query = db.collection("cities")
.whereField("population", isGreaterThan: 1000000)
.whereField("density", isLessThan: 10000)
Objective-C
FIRQuery *query =
[[[[self.db collectionWithPath:@"cities"]
queryWhereField:@"population" isGreaterThan:@1000000]
queryWhereField:@"density" isLessThan:@10000];
Java Android
Query query = db.collection("cities")
.whereGreaterThan("population", 1000000)
.whereLessThan("density", 10000);
Kotlin+KTX Android
val query = db.collection("cities")
.whereGreaterThan("population", 1000000)
.whereLessThan("density", 10000)
Vai
query := client.Collection("cities").
Where("population", ">", 1000000).
Where("density", "<", 10000)
Java
db.collection("cities")
.whereGreaterThan("population", 1000000)
.whereLessThan("density", 10000);
Node.js
db.collection("cities")
.where('population', '>', 1000000),
.where('density', '<', 10000)
Python
from google.cloud import firestore
db = firestore.Client()
query = db.collection("cities")
.where("population", ">", 1000000)
.where("density", "<", 10000)
PHP
C#
Ruby
query = cities_ref.where("population", ">", "1000000")
.where("density", "<", 10000)
C++
CollectionReference cities_ref = db->Collection("cities");
Query query = cities_ref.WhereGreaterThan("population", FieldValue::Integer(1000000))
.WhereLessThan("density", FieldValue::Integer(10000));
Unity
CollectionReference citiesRef = db.Collection("cities");
Query query = citiesRef.WhereGreaterThan("population", 1000000)
.WhereLessThan("density", 10000);
Dart
final citiesRef = FirebaseFirestore.instance.collection('cities')
final query = citiesRef.where("population", isGreaterThan: 1000000)
.where("density", isLessThan: 10000);
Considerazioni sull'indicizzazione
Prima di eseguire le query, leggi informazioni sulle query e sul modello di dati Cloud Firestore.
In Cloud Firestore, la clausola ORDER BY
di una query determina quali indici
possono essere utilizzati per eseguire la query. Ad esempio, una query ORDER BY a ASC, b ASC
richiede un indice composto sui campi a ASC, b ASC
.
Per ottimizzare le prestazioni e i costi delle query Cloud Firestore, ottimizza l'ordine dei campi nell'indice. A questo scopo, assicurati che l'indice sia ordinato da sinistra a destra in modo che la query venga distillata in un set di dati che impedisca la scansione di voci di indice non necessarie.
Supponiamo che tu voglia cercare in un gruppo di dipendenti e trovare dipendenti negli Stati Uniti con uno stipendio superiore a 100.000 $e con anni di esperienza superiore a 0. In base alla tua conoscenza del set di dati, sai che il vincolo di salario è più selettivo del vincolo di esperienza. L'indice ideale che ridurrebbe il numero di scansioni dell'indice sarebbe (salary [...], experience [...])
. Pertanto, la query rapida e con un buon rapporto costi/benefici ordinerà salary
prima di experience
e avrà il seguente aspetto:
Java
db.collection("employees")
.whereGreaterThan("salary", 100000)
.whereGreaterThan("experience", 0)
.orderBy("salary")
.orderBy("experience");
Node.js
db.collection("employees")
.where("salary", ">", 100000)
.where("experience", ">", 0)
.orderBy("salary")
.orderBy("experience");
Python
db.collection("employees")
.where("salary", ">", 100000)
.where("experience", ">", 0)
.order_by("salary")
.order_by("experience");
Best practice per l'ottimizzazione degli indici
Quando ottimizzi gli indici, tieni presente le seguenti best practice.
Ordina i campi dell'indice per le equazioni seguite dal campo dell'intervallo o dell'inequità più selettivo
Cloud Firestore utilizza i campi più a sinistra di un indice composto per soddisfare i vincoli di uguaglianza e l'eventuale vincolo di intervallo o di disuguaglianza nel primo campo della query orderBy()
. Questi vincoli possono ridurre il numero di voci dell'indice esaminate da Cloud Firestore. Cloud Firestore utilizza i campi rimanenti
dell'indice per soddisfare altri vincoli di intervallo o disuguaglianza della query. Questi vincoli non riducono il numero di voci dell'indice analizzate da Cloud Firestore, ma escludono i documenti non corrispondenti in modo da ridurre il numero di documenti restituiti ai client.
Per saperne di più sulla creazione di indici efficienti, consulta le proprietà dell'indice.
Ordina i campi in ordine decrescente di selettività del vincolo di query
Per assicurarti che Cloud Firestore selezioni l'indice ottimale per la query, specifica una clausola orderBy()
che ordini i campi in ordine decrescente di selettività del vincolo di query. Una maggiore selettività corrisponde a un sottoinsieme più piccolo di
documenti, mentre una selettività inferiore corrisponde a un sottoinsieme più grande di documenti. Assicurati di selezionare i campi di intervallo o di disuguaglianza con una maggiore selettività all'inizio dell'ordinamento dell'indice rispetto ai campi con una selettività inferiore.
Per ridurre al minimo il numero di documenti che Cloud Firestore scansiona e restituisce sulla rete, devi sempre ordinare i campi in ordine decrescente di selettivorietà dei vincoli di query. Se il set di risultati non è nell'ordine richiesto e si prevede che sia piccolo, puoi implementare la logica lato client per riordinarlo in base alle tue aspettative di ordinamento.
Ad esempio, supponiamo che tu voglia cercare tra una raccolta di dipendenti per trovare quelli degli Stati Uniti il cui stipendio è superiore a 100.000 $e ordinare i risultati in base all'anno di esperienza del dipendente. Se prevedi che solo un numero ridotto di dipendenti avrà stipendi superiori a 100.000 $, il modo più efficiente per scrivere la query è il seguente:
Java
db.collection("employees")
.whereGreaterThan("salary", 100000)
.orderBy("salary")
.get()
.addOnSuccessListener(new OnSuccessListener<QuerySnapshot>() {
@Override
public void onSuccess(QuerySnapshot queryDocumentSnapshots) {
// Order results by `experience`
}
});;
Node.js
const querySnapshot = await db.collection('employees')
.where("salary", ">", 100000)
.orderBy("salary")
.get();
// Order results by `experience`
Python
results = db.collection("employees")
.where("salary", ">", 100000)
.order_by("salary")
.stream()
// Order results by `experience`
Mentre l'aggiunta di un ordinamento su experience
alla query restituirà lo stesso insieme di documenti e impedirà il riordinamento dei risultati sui client, la query potrebbe leggere molte più voci di indice estranee rispetto alla query precedente. Questo perché
Cloud Firestore preferisce sempre un indice il cui prefisso dei campi dell'indice corrisponde alla
clausola order by della query. Se experience
è stato aggiunto alla clausola order by,
Cloud Firestore selezionerà l'indice (experience [...], salary [...])
per calcolare i risultati della query. Poiché non esistono altri vincoli su experience
, Cloud Firestore leggerà tutte le voci di indice della raccolta employees
prima di applicare il filtro salary
per trovare il set di risultati finale. Ciò significa che le voci di indice che non soddisfano il filtro salary
vengono comunque lette, aumentando così la latenza e il costo della query.
Prezzi
Le query con filtri di intervallo e di diseguaglianza su più campi vengono fatturate in base ai documenti letti e alle voci dell'indice lette.
Per informazioni dettagliate, consulta la pagina Prezzi.
Limitazioni
Oltre alle limitazioni delle query, tieni presente le seguenti limitazioni prima di utilizzare query con filtri di intervallo e di disuguaglianza su più campi:
- Le query con filtri di intervallo o di disuguaglianza sui campi del documento e solo vincoli di uguaglianza sulla chiave del documento
(__name__)
non sono supportate. - Cloud Firestore limita il numero di campi di intervallo o di disuguaglianza a 10. Ciò serve a evitare che le query diventino troppo costose da eseguire.
Passaggi successivi
- Scopri di più sull'ottimizzazione delle query.
- Scopri di più sull'esecuzione di query semplici e composte.
- Scopri come Cloud Firestore utilizza gli indici.