Présentation des requêtes avec des filtres de plage et d'inégalité sur plusieurs champs

Cloud Firestore permet d'utiliser des filtres de plage et d'inégalité sur plusieurs champs dans une seule requête. Vous pouvez définir des conditions de plage et d'inégalité sur plusieurs champs et simplifier le développement de votre application en déléguant l'implémentation de la logique de post-filtrage à Cloud Firestore.

Filtres de plage et d'inégalité sur plusieurs champs

La requête suivante utilise des filtres de plage sur la population et la densité pour renvoyer toutes les villes dont la population est supérieure à 1 000 000 habitants et dont la densité de population est inférieure à 10 000 habitants par unité de surface.

const q = query(
    collection(db, "cities"),
    where('population', '>', 1000000),
    where('density', '<', 10000),
  );

let query = db.collection("cities")
  .whereField("population", isGreaterThan: 1000000)
  .whereField("density", isLessThan: 10000)

FIRQuery *query =
 [[[[self.db collectionWithPath:@"cities"]
queryWhereField:@"population" isGreaterThan:@1000000]
   queryWhereField:@"density" isLessThan:@10000];

Query query = db.collection("cities")
 .whereGreaterThan("population", 1000000)
 .whereLessThan("density", 10000);

val query = db.collection("cities")
 .whereGreaterThan("population", 1000000)
 .whereLessThan("density", 10000)

   query := client.Collection("cities").
      Where("population", ">", 1000000).
      Where("density", "<", 10000)

db.collection("cities")
  .whereGreaterThan("population", 1000000)
  .whereLessThan("density", 10000);

db.collection("cities")
  .where('population', '>', 1000000),
  .where('density', '<', 10000)

from google.cloud import firestore

db = firestore.Client()
query = db.collection("cities")
.where("population", ">", 1000000)
.where("density", "<", 10000)

$collection = $db->collection('samples/php/cities');
$chainedQuery = $collection
    ->where('population', '>', 1000000)
    ->where('density', '<', 10000);
query_filter_compound_multi_ineq.php

CollectionReference citiesRef = db.Collection("cities");
Query query = citiesRef
    .WhereGreaterThan("Population", 1000000)
    .WhereLessThan("Density", 10000);
QuerySnapshot querySnapshot = await query.GetSnapshotAsync();
foreach (DocumentSnapshot documentSnapshot in querySnapshot)
{
    var name = documentSnapshot.GetValue<string>("Name");
    var population = documentSnapshot.GetValue<int>("Population");
    var density = documentSnapshot.GetValue<int>("Density");
    Console.WriteLine($"City '{name}' returned by query. Population={population}; Density={density}");
}
Program.cs

query = cities_ref.where("population", ">", "1000000")
                  .where("density", "<", 10000)

CollectionReference cities_ref = db->Collection("cities");
Query query = cities_ref.WhereGreaterThan("population", FieldValue::Integer(1000000))
                       .WhereLessThan("density", FieldValue::Integer(10000));

CollectionReference citiesRef = db.Collection("cities");
Query query = citiesRef.WhereGreaterThan("population", 1000000)
                      .WhereLessThan("density", 10000);

final citiesRef = FirebaseFirestore.instance.collection('cities')
final query = citiesRef.where("population", isGreaterThan: 1000000)
                  .where("density", isLessThan: 10000);

Considérations concernant l'indexation

Avant d'exécuter vos requêtes, consultez les informations sur les requêtes et le modèle de données Cloud Firestore.

Dans Cloud Firestore, la clause ORDER BY d'une requête détermine les index pouvant être utilisés pour diffuser la requête. Par exemple, une requête ORDER BY a ASC, b ASC nécessite un index composite sur les champs a ASC, b ASC.

Pour optimiser les performances et les coûts des requêtes Cloud Firestore, optimisez l'ordre des champs dans l'index. Pour ce faire, assurez-vous que votre index est trié de gauche à droite afin que la requête se condense en un ensemble de données qui empêche l'analyse des entrées d'index inutiles.

Supposons que vous souhaitiez effectuer une recherche dans une collection d'employés et trouver des employés des États-Unis dont le salaire est supérieur à 100 000 $et dont le nombre d'années d'expérience est supérieur à 0. D'après votre compréhension du jeu de données, vous savez que la contrainte de salaire est plus sélective que la contrainte d'expérience. L'index idéal qui réduirait le nombre d'analyses d'index serait (salary [...], experience [...]). Par conséquent, la requête rapide et économique consiste à trier salary avant experience et se présente comme suit :

db.collection("employees")
  .whereGreaterThan("salary", 100000)
  .whereGreaterThan("experience", 0)
  .orderBy("salary")
  .orderBy("experience");

db.collection("employees")
  .where("salary", ">", 100000)
  .where("experience", ">", 0)
  .orderBy("salary")
  .orderBy("experience");

db.collection("employees")
  .where("salary", ">", 100000)
  .where("experience", ">", 0)
  .order_by("salary")
  .order_by("experience");

Bonnes pratiques pour optimiser les index

Lorsque vous optimisez des index, tenez compte des bonnes pratiques suivantes.

Classer les champs d'index par égalité, suivi de la plage la plus sélective ou du champ d'inégalité

Cloud Firestore utilise les champs les plus à gauche d'un index composite pour satisfaire aux contraintes d'égalité et à la contrainte de plage ou d'inégalité, le cas échéant, du premier champ de la requête orderBy(). Ces contraintes peuvent réduire le nombre d'entrées d'index analysées par Cloud Firestore. Cloud Firestore utilise les champs restants de l'index pour répondre aux autres contraintes de plage ou d'inégalité de la requête. Ces contraintes ne réduisent pas le nombre d'entrées d'index analysées par Cloud Firestore, mais filtrent les documents sans correspondance afin de réduire le nombre de documents renvoyés aux clients.

Pour en savoir plus sur la création d'index efficaces, consultez la section Propriétés d'index.

Classer les champs par ordre décroissant de sélectivité des contraintes de requête

Pour vous assurer que Cloud Firestore sélectionne l'index optimal pour votre requête, spécifiez une clause orderBy() qui trie les champs par ordre décroissant de sélectivité des contraintes de requête. Une sélectivité plus élevée correspond à un sous-ensemble plus petit de documents, tandis qu'une sélectivité inférieure correspond à un sous-ensemble plus grand de documents. Veillez à sélectionner des champs de plage ou d'inégalité plus sélectifs plus tôt dans l'ordre des index que ceux dont la sélectivité est inférieure.

Pour réduire le nombre de documents que Cloud Firestore analyse et renvoie sur le réseau, vous devez toujours trier les champs par ordre décroissant de sélectivité des contraintes de requête. Si l'ensemble de résultats n'est pas dans l'ordre requis et qu'il est censé être petit, vous pouvez implémenter une logique côté client pour le réorganiser selon vos attentes.

Par exemple, supposons que vous souhaitiez rechercher dans une collection d'employés ceux dont le salaire est supérieur à 100 000 $ aux États-Unis et que vous souhaitiez trier les résultats par année d'expérience de l'employé. Si vous pensez que seul un petit nombre d'employés aura un salaire supérieur à 100 000 $, la méthode la plus efficace pour écrire la requête est la suivante:

db.collection("employees")
  .whereGreaterThan("salary", 100000)
  .orderBy("salary")
  .get()
  .addOnSuccessListener(new OnSuccessListener<QuerySnapshot>() {
        @Override
        public void onSuccess(QuerySnapshot queryDocumentSnapshots) {
          // Order results by `experience`
        }
    });;

const querySnapshot = await db.collection('employees')
                              .where("salary", ">", 100000)
                              .orderBy("salary")
                              .get();

// Order results by `experience`

results = db.collection("employees")
            .where("salary", ">", 100000)
            .order_by("salary")
            .stream()

// Order results by `experience`

Bien que l'ajout d'un tri sur experience à la requête génère le même ensemble de documents et évite de réorganiser les résultats sur les clients, la requête peut lire beaucoup plus d'entrées d'index superflues que la requête précédente. En effet, Cloud Firestore préfère toujours un index dont le préfixe des champs d'index correspond à l'ordre par clause de la requête. Si experience a été ajouté à la clause "order by", Cloud Firestore sélectionnera l'index (experience [...], salary [...]) pour calculer les résultats de la requête. Comme il n'y a pas d'autres contraintes sur experience, Cloud Firestore lit toutes les entrées d'index de la collection employees avant d'appliquer le filtre salary pour trouver l'ensemble de résultats final. Cela signifie que les entrées d'index qui ne satisfont pas le filtre salary sont toujours lues, ce qui augmente la latence et le coût de la requête.

Tarifs

Les requêtes comportant des filtres de plage et d'inégalité sur plusieurs champs sont facturées en fonction des documents lus et des entrées d'index lues.

Pour en savoir plus, consultez la page Tarifs.

Limites

En plus des limites des requêtes, tenez compte des limites suivantes avant d'utiliser des requêtes avec des filtres de plage et d'inégalité sur plusieurs champs :

• Les requêtes avec des filtres de plage ou d'inégalité sur les champs de document et uniquement des contraintes d'égalité sur la clé de document (__name__) ne sont pas acceptées.
• Cloud Firestore limite le nombre de champs de plage ou d'inégalité à 10. Cela permet d'éviter que les requêtes ne deviennent trop coûteuses à exécuter.

Étape suivante

• Découvrez comment optimiser vos requêtes.
• Découvrez comment exécuter des requêtes simples et composées.
• Découvrez comment Cloud Firestore utilise les index.