Où

Description

Filtre les documents de l'étape précédente et ne renvoie que ceux pour lesquels la condition renvoie 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();
Go
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

Plusieurs étapes

Plusieurs étapes where(...) peuvent être chaînées et agir comme une expression and(...) pour chaque condition.

Node.js

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

Le filtrage basé sur un or logique de deux conditions 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 profondément imbriquées et des opérateurs logiques. 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 aux USA et que le nom de l'État est suffisamment long. N'importe quelle expression peut être fournie comme condition, mais ne correspondra qu'à celles qui renvoient 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 suivante :

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 de 10 documents (potentiellement aléatoire), car l'étape limit(...) précédente limite les documents qui sont fournis à l'étape where(...). Par conséquent, la règle générale consiste à placer les étapes where(...) le plus tôt possible dans la requête.

Fonctionnalité de type HAVING :

L'étape where(...) peut venir après n'importe quelle étape qui modifie le schéma des documents, comme select(...) ou aggregate(...) et fait référence aux champs produits à partir de ces étapes. Il est important de noter que pour aggregate(...), une clause where(...) suivante qui fait référence aux champs cumulés agit 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 la population totale des villes est supérieure à une certaine taille.