Cloud Firestore Enterprise edition in Native mode is now available! Learn more.

Fonctions logiques

Nom	Description
`AND`	Effectue un AND logique
`OR`	Effectue un OR logique
`XOR`	Effectue un XOR logique
`NOT`	Effectue un NOT logique
`CONDITIONAL`	Branche l'évaluation en fonction d'une expression conditionnelle.
`EQUAL_ANY`	Vérifie si une valeur est égale à l'un des éléments d'un tableau.
`NOT_EQUAL_ANY`	Vérifie si une valeur n'est égale à aucun élément d'un tableau.
`MAXIMUM`	Renvoie la valeur maximale d'un ensemble de valeurs.
`MINIMUM`	Renvoie la valeur minimale d'un ensemble de valeurs.

ET

Syntaxe :

and(x: BOOLEAN...) -> BOOLEAN

Description :

Renvoie le AND logique de deux valeurs booléennes ou plus.

Renvoie NULL si le résultat ne peut pas être obtenu, car l'une des valeurs indiquées est ABSENT ou NULL.

Exemples :

`x`	`y`	`and(x, y)`
`TRUE`	`TRUE`	`TRUE`
`FALSE`	`TRUE`	`FALSE`
`NULL`	`TRUE`	`NULL`
`ABSENT`	`TRUE`	`NULL`
`NULL`	`FALSE`	`FALSE`
`FALSE`	`ABSENT`	`FALSE`

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    and(field("rating").greaterThan(4), field("price").lessThan(10))
      .as("under10Recommendation")
  )
);test.firestore.js

Swift

let result = try await db.pipeline()
  .collection("books")
  .select([
    (Field("rating").greaterThan(4) && Field("price").lessThan(10))
      .as("under10Recommendation")
  ])
  .execute()PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        Expression.and(field("rating").greaterThan(4),
          field("price").lessThan(10))
            .alias("under10Recommendation")
    )
    .execute()DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        Expression.and(
            field("rating").greaterThan(4),
            field("price").lessThan(10)
        ).alias("under10Recommendation")
    )
    .execute();DocSnippets.java

Python

from google.cloud.firestore_v1.pipeline_expressions import Field, And

result = (
    client.pipeline()
    .collection("books")
    .select(
        And(
            Field.of("rating").greater_than(4), Field.of("price").less_than(10)
        ).as_("under10Recommendation")
    )
    .execute()
)firestore_pipelines.py

OU

Syntaxe :

or(x: BOOLEAN...) -> BOOLEAN

Description :

Renvoie le OR logique de deux valeurs booléennes ou plus.

Renvoie NULL si le résultat ne peut pas être obtenu, car l'une des valeurs indiquées est ABSENT ou NULL.

Exemples :

`x`	`y`	`or(x, y)`
`TRUE`	`TRUE`	`TRUE`
`FALSE`	`TRUE`	`TRUE`
`NULL`	`TRUE`	`TRUE`
`ABSENT`	`TRUE`	`TRUE`
`NULL`	`FALSE`	`NULL`
`FALSE`	`ABSENT`	`NULL`

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    or(field("genre").equal("Fantasy"), field("tags").arrayContains("adventure"))
      .as("matchesSearchFilters")
  )
);test.firestore.js

Swift

let result = try await db.pipeline()
  .collection("books")
  .select([
    (Field("genre").equal("Fantasy") || Field("tags").arrayContains("adventure"))
      .as("matchesSearchFilters")
  ])
  .execute()PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        Expression.or(field("genre").equal("Fantasy"),
          field("tags").arrayContains("adventure"))
            .alias("matchesSearchFilters")
    )
    .execute()DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        Expression.or(
            field("genre").equal("Fantasy"),
            field("tags").arrayContains("adventure")
        ).alias("matchesSearchFilters")
    )
    .execute();DocSnippets.java

Python

from google.cloud.firestore_v1.pipeline_expressions import Field, And, Or

result = (
    client.pipeline()
    .collection("books")
    .select(
        Or(
            Field.of("genre").equal("Fantasy"),
            Field.of("tags").array_contains("adventure"),
        ).as_("matchesSearchFilters")
    )
    .execute()
)firestore_pipelines.py

XOR

Syntaxe :

xor(x: BOOLEAN...) -> BOOLEAN

Description :

Renvoie le XOR logique de deux valeurs booléennes ou plus.

Renvoie NULL si l'une des valeurs fournies est ABSENT ou NULL.

Exemples :

`x`	`y`	`xor(x, y)`
`TRUE`	`TRUE`	`FALSE`
`FALSE`	`FALSE`	`FALSE`
`FALSE`	`TRUE`	`TRUE`
`NULL`	`TRUE`	`NULL`
`ABSENT`	`TRUE`	`NULL`
`NULL`	`FALSE`	`NULL`
`FALSE`	`ABSENT`	`NULL`

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    xor(field("tags").arrayContains("magic"), field("tags").arrayContains("nonfiction"))
      .as("matchesSearchFilters")
  )
);test.firestore.js

Swift

let result = try await db.pipeline()
  .collection("books")
  .select([
    (Field("tags").arrayContains("magic") ^ Field("tags").arrayContains("nonfiction"))
      .as("matchesSearchFilters")
  ])
  .execute()PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        Expression.xor(field("tags").arrayContains("magic"),
          field("tags").arrayContains("nonfiction"))
            .alias("matchesSearchFilters")
    )
    .execute()DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        Expression.xor(
            field("tags").arrayContains("magic"),
            field("tags").arrayContains("nonfiction")
        ).alias("matchesSearchFilters")
    )
    .execute();DocSnippets.java

Python

from google.cloud.firestore_v1.pipeline_expressions import Field, Xor

result = (
    client.pipeline()
    .collection("books")
    .select(
        Xor(
            [
                Field.of("tags").array_contains("magic"),
                Field.of("tags").array_contains("nonfiction"),
            ]
        ).as_("matchesSearchFilters")
    )
    .execute()
)firestore_pipelines.py

NOT

Syntaxe :

not(x: BOOLEAN) -> BOOLEAN

Description :

Renvoie la négation logique d'une valeur booléenne.

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("tags").arrayContains("nonfiction").not()
      .as("isFiction")
  )
);test.firestore.js

Swift

let result = try await db.pipeline()
  .collection("books")
  .select([
    (!Field("tags").arrayContains("nonfiction"))
      .as("isFiction")
  ])
  .execute()PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        Expression.not(
            field("tags").arrayContains("nonfiction")
        ).alias("isFiction")
    )
    .execute()DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        Expression.not(
            field("tags").arrayContains("nonfiction")
        ).alias("isFiction")
    )
    .execute();DocSnippets.java

Python

from google.cloud.firestore_v1.pipeline_expressions import Field, Not

result = (
    client.pipeline()
    .collection("books")
    .select(Not(Field.of("tags").array_contains("nonfiction")).as_("isFiction"))
    .execute()
)firestore_pipelines.py

CONDITIONNEL

Syntaxe :

conditional(condition: BOOLEAN, true_case: ANY, false_case: ANY) -> ANY

Description :

Évalue et renvoie true_case si condition renvoie TRUE.

Évalue et renvoie false_case si la condition est résolue sur une valeur FALSE, NULL ou ABSENT.

Exemples :

`condition`	`true_case`	`false_case`	`conditional(condition, true_case, false_case)`
`TRUE`	1L	0L	1L
`FALSE`	1L	0L	0L
`NULL`	1L	0L	0L
`ABSENT`	1L	0L	0L

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("tags").arrayConcat([
      field("pages").greaterThan(100)
        .conditional(constant("longRead"), constant("shortRead"))
    ]).as("extendedTags")
  )
);test.firestore.js

Swift

let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("tags").arrayConcat([
      ConditionalExpression(
        Field("pages").greaterThan(100),
        then: Constant("longRead"),
        else: Constant("shortRead")
      )
    ]).as("extendedTags")
  ])
  .execute()PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        field("tags").arrayConcat(
            Expression.conditional(
                field("pages").greaterThan(100),
                constant("longRead"),
                constant("shortRead")
            )
        ).alias("extendedTags")
    )
    .execute()DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("tags").arrayConcat(
            Expression.conditional(
                field("pages").greaterThan(100),
                constant("longRead"),
                constant("shortRead")
            )
        ).alias("extendedTags")
    )
    .execute();DocSnippets.java

Python

from google.cloud.firestore_v1.pipeline_expressions import (
    Field,
    Constant,
    Conditional,
)

result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("tags")
        .array_concat(
            Conditional(
                Field.of("pages").greater_than(100),
                Constant.of("longRead"),
                Constant.of("shortRead"),
            )
        )
        .as_("extendedTags")
    )
    .execute()
)firestore_pipelines.py

EQUAL_ANY

Syntaxe :

equal_any(value: ANY, search_space: ARRAY) -> BOOLEAN

Description :

Renvoie TRUE si value se trouve dans le tableau search_space.

Exemples :

`value`	`search_space`	`equal_any(value, search_space)`
0L	[1L, 2L, 3L]	`FALSE`
2L	[1L, 2L, 3L]	`TRUE`
`NULL`	[1L, 2L, 3L]	`FALSE`
`NULL`	[1L, `NULL`]	`TRUE`
`ABSENT`	[1L, `NULL`]	`FALSE`
NaN	[1L, NaN, 3L]	`TRUE`

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("genre").equalAny(["Science Fiction", "Psychological Thriller"])
      .as("matchesGenreFilters")
  )
);test.firestore.js

Swift

let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("genre").equalAny(["Science Fiction", "Psychological Thriller"])
      .as("matchesGenreFilters")
  ])
  .execute()PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        field("genre").equalAny(listOf("Science Fiction", "Psychological Thriller"))
            .alias("matchesGenreFilters")
    )
    .execute()DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("genre").equalAny(Arrays.asList("Science Fiction", "Psychological Thriller"))
            .alias("matchesGenreFilters")
    )
    .execute();DocSnippets.java

Python

from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("genre")
        .equal_any(["Science Fiction", "Psychological Thriller"])
        .as_("matchesGenreFilters")
    )
    .execute()
)firestore_pipelines.py

NOT_EQUAL_ANY

Syntaxe :

not_equal_any(value: ANY, search_space: ARRAY) -> BOOLEAN

Description :

Renvoie TRUE si value ne figure pas dans le tableau search_space.

Exemples :

`value`	`search_space`	`not_equal_any(value, search_space)`
0L	[1L, 2L, 3L]	`TRUE`
2L	[1L, 2L, 3L]	`FALSE`
`NULL`	[1L, 2L, 3L]	`TRUE`
`NULL`	[1L, `NULL`]	`FALSE`
`ABSENT`	[1L, `NULL`]	`TRUE`
NaN	[1L, NaN, 3L]	`FALSE`

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("author").notEqualAny(["George Orwell", "F. Scott Fitzgerald"])
      .as("byExcludedAuthors")
  )
);test.firestore.js

Swift

let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("author").notEqualAny(["George Orwell", "F. Scott Fitzgerald"])
      .as("byExcludedAuthors")
  ])
  .execute()PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        field("author").notEqualAny(listOf("George Orwell", "F. Scott Fitzgerald"))
            .alias("byExcludedAuthors")
    )
    .execute()DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("author").notEqualAny(Arrays.asList("George Orwell", "F. Scott Fitzgerald"))
            .alias("byExcludedAuthors")
    )
    .execute();DocSnippets.java

Python

from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("author")
        .not_equal_any(["George Orwell", "F. Scott Fitzgerald"])
        .as_("byExcludedAuthors")
    )
    .execute()
)firestore_pipelines.py

MAXIMUM

Syntaxe :

maximum(x: ANY...) -> ANY
maximum(x: ARRAY) -> ANY

Description :

Renvoie la valeur maximale non-NULL et non-ABSENT dans une série de valeurs x.

S'il n'y a pas de valeurs non NULL et non ABSENT, NULL est renvoyé.

S'il existe plusieurs valeurs équivalentes maximales, l'une d'entre elles peut être renvoyée. L'ordre des types de valeurs suit l'ordre documenté.

Exemples :

`x`	`y`	`maximum(x, y)`
`FALSE`	`TRUE`	`TRUE`
`FALSE`	-10L	-10L
0,0	-5L	0,0
"foo"	"bar"	"foo"
"foo"	["foo"]	["foo"]
`ABSENT`	`ABSENT`	`NULL`
`NULL`	`NULL`	`NULL`

Web

const result = await execute(db.pipeline()
  .collection("books")
  .aggregate(field("price").maximum().as("maximumPrice"))
);test.firestore.js

Swift

let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("rating").logicalMaximum([1]).as("flooredRating")
  ])
  .execute()PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        field("rating").logicalMaximum(1).alias("flooredRating")
    )
    .execute()DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("rating").logicalMaximum(1).alias("flooredRating")
    )
    .execute();DocSnippets.java

Python

from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("rating").logical_maximum(1).as_("flooredRating"))
    .execute()
)firestore_pipelines.py

MINIMUM

Syntaxe :

minimum(x: ANY...) -> ANY
minimum(x: ARRAY) -> ANY

Description :

Renvoie la valeur minimale non-NULL et non-ABSENT dans une série de valeurs x.

S'il n'y a pas de valeurs non NULL et non ABSENT, NULL est renvoyé.

S'il existe plusieurs valeurs équivalentes minimales, l'une d'entre elles peut être renvoyée. L'ordre des types de valeurs suit l'ordre documenté.

Exemples :

`x`	`y`	`minimum(x, y)`
`FALSE`	`TRUE`	`FALSE`
`FALSE`	-10L	`FALSE`
0,0	-5L	-5L
"foo"	"bar"	"bar"
"foo"	["foo"]	"foo"
`ABSENT`	`ABSENT`	`NULL`
`NULL`	`NULL`	`NULL`

Web

const result = await execute(db.pipeline()
  .collection("books")
  .aggregate(field("price").minimum().as("minimumPrice"))
);test.firestore.js

Swift

let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("rating").logicalMinimum([5]).as("cappedRating")
  ])
  .execute()PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        field("rating").logicalMinimum(5).alias("cappedRating")
    )
    .execute()DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("rating").logicalMinimum(5).alias("cappedRating")
    )
    .execute();DocSnippets.java

Python

from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("rating").logical_minimum(5).as_("cappedRating"))
    .execute()
)firestore_pipelines.py

Fonctions logiques Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.