Où

Description

Filtre les documents de l'étape précédente et ne renvoie que ceux pour lesquels la condition est évaluée à true.

Exemples

Web

let results;

results = await execute(db.pipeline().collection("books")
  .where(field("rating").equal(5))
  .where(field("published").lessThan(1900))
);

results = await execute(db.pipeline().collection("books")
  .where(and(field("rating").equal(5), field("published").lessThan(1900)))
);
Swift
var results: Pipeline.Snapshot

results = try await db.pipeline().collection("books")
  .where(Field("rating").equal(5))
  .where(Field("published").lessThan(1900))
  .execute()

results = try await db.pipeline().collection("books")
  .where(Field("rating").equal(5) && Field("published").lessThan(1900))
  .execute()

Kotlin

var results: Task<Pipeline.Snapshot>

results = db.pipeline().collection("books")
    .where(field("rating").equal(5))
    .where(field("published").lessThan(1900))
    .execute()

results = db.pipeline().collection("books")
    .where(Expression.and(field("rating").equal(5),
      field("published").lessThan(1900)))
    .execute()

Java

Task<Pipeline.Snapshot> results;

results = db.pipeline().collection("books")
    .where(field("rating").equal(5))
    .where(field("published").lessThan(1900))
    .execute();

results = db.pipeline().collection("books")
    .where(Expression.and(
        field("rating").equal(5),
        field("published").lessThan(1900)
    ))
    .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import And, Field

results = (
    client.pipeline()
    .collection("books")
    .where(Field.of("rating").equal(5))
    .where(Field.of("published").less_than(1900))
    .execute()
)

results = (
    client.pipeline()
    .collection("books")
    .where(And(Field.of("rating").equal(5), Field.of("published").less_than(1900)))
    .execute()
)
Java
Pipeline.Snapshot results1 =
    firestore
        .pipeline()
        .collection("books")
        .where(field("rating").equal(5))
        .where(field("published").lessThan(1900))
        .execute()
        .get();

Pipeline.Snapshot results2 =
    firestore
        .pipeline()
        .collection("books")
        .where(and(field("rating").equal(5), field("published").lessThan(1900)))
        .execute()
        .get();
Accéder
results1, err := client.Pipeline().
	Collection("books").
	Where(firestore.FieldOf("rating").Equal(5)).
	Where(firestore.FieldOf("published").LessThan(1900)).
	Execute(ctx).Results().GetAll()
if err != nil {
	fmt.Fprintf(w, "GetAll failed: %v", err)
	return err
}

results2, err := client.Pipeline().
	Collection("books").
	Where(firestore.And(
		firestore.FieldOf("rating").Equal(5),
		firestore.FieldOf("published").LessThan(1900),
	)).
	Execute(ctx).Results().GetAll()
if err != nil {
	fmt.Fprintf(w, "GetAll failed: %v", err)
	return err
}

Comportement

Filtres enchaînés et filtres imbriqués

Plusieurs étapes where(...) peuvent être enchaînées, ce qui équivaut logiquement à combiner les conditions de filtre dans une seule étape where(...) à l'aide d'une expression and(...). Les deux approches produisent le même plan d'exécution et n'ont aucun impact sur l'exécution ni les performances des requêtes.

Par exemple, en enchaînant plusieurs étapes where(...) :

Node.js

const cities = await db.pipeline()
  .collection("/cities")
  .where(field("location.country").equals("USA"))
  .where(field("population").greaterThan(500000))
  .execute();

revient à utiliser une seule étape where(...) avec un and(...) composé :

Node.js

const cities = await db.pipeline()
  .collection("/cities")
  .where(
    field("location.country").equals("USA")
      .and(field("population").greaterThan(500000)))
  .execute();

Toutefois, le filtrage basé sur un or(...) logique de conditions ne peut pas être réparti sur plusieurs étapes et doit être effectué en une seule étape where(...) :

Node.js

const cities = await db.pipeline()
  .collection("/cities")
  .where(
    field("location.state").equals("NY")
      .or(field("location.state").equals("CA")))
  .execute();

Expressions complexes

La condition de filtre peut contenir des conditions de filtre complexes contenant des expressions et des opérateurs logiques profondément imbriqués. Exemple :

Node.js

const cities = await db.pipeline()
  .collection("/cities")
  .where(
    field("name").like("San%")
    .or(
      field("location.state").charLength().greaterThan(7)
      .and(field("location.country").equals("USA"))))

filtre /cities en fonction d'une expression régulière ou si la ville se trouve dans USA avec un nom d'État suffisamment long. N'importe quelle expression peut être utilisée comme condition, mais elle ne correspondra qu'à celles qui renvoient la valeur true.

Ordre des étapes

L'ordre des étapes est important, car il peut modifier l'ordre d'évaluation des requêtes. Par exemple, la requête :

Node.js

const cities = await db.pipeline()
  .collection("/cities")
  .limit(10)
  .where(field("location.country").equals("USA"))
  .execute();

ne filtrera que location.country pour un ensemble (potentiellement aléatoire) de 10 documents, car l'étape limit(...) précédente limite les documents qui sont fournis à l'étape where(...). Dans cette optique, la règle d'or consiste à placer les étapes where(...) le plus tôt possible dans la requête.

HAVINGFonctionnalité J'aime :

L'étape where(...) peut suivre n'importe quelle étape qui modifie le schéma des documents, comme select(...) ou aggregate(...), et fera référence aux champs produits à partir de ces étapes. Pour aggregate(...), une clause where(...) suivante qui fait référence aux champs cumulés se comporte comme une clause HAVING dans un système SQL typique. Exemple :

Node.js

const cities = await db.pipeline()
  .collection("/cities")
  .aggregate({
    accumulators: [field("population").sum().as("total_population")],
    groups: ["location.state"]
  })
  .where(field("total_population").greaterThan(10000000))

permet de renvoyer les états dont les villes ont une population totale supérieure à une certaine taille.