A edição Enterprise do Cloud Firestore com compatibilidade com o MongoDB já está disponível. Saiba mais.

Funções lógicas

Nome	Descrição
`AND`	Executa um AND lógico
`OR`	Executa um OR lógico
`XOR`	Executa um XOR lógico
`NOT`	Executa um NOT lógico
`CONDITIONAL`	Ramifica a avaliação com base em uma expressão condicional.
`EQUAL_ANY`	Verifica se um valor é igual a algum elemento em uma matriz.
`NOT_EQUAL_ANY`	Verifica se um valor não é igual a nenhum elemento em uma matriz.
`MAXIMUM`	Retorna o valor máximo em um conjunto de valores.
`MINIMUM`	Retorna o valor mínimo em um conjunto de valores.

E

Sintaxe:

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

Descrição:

Retorna o AND lógico de dois ou mais valores booleanos.

Retorna NULL se o resultado não puder ser derivado porque um dos valores fornecidos é ABSENT ou NULL.

Exemplos:

`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

Sintaxe:

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

Descrição:

Retorna o OR lógico de dois ou mais valores booleanos.

Retorna NULL se o resultado não puder ser derivado porque um dos valores fornecidos é ABSENT ou NULL.

Exemplos:

`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

Sintaxe:

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

Descrição:

Retorna o XOR lógico de dois ou mais valores booleanos.

Retorna NULL se algum dos valores especificados for ABSENT ou NULL.

Exemplos:

`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

Sintaxe:

not(x: BOOLEAN) -> BOOLEAN

Descrição:

Retorna o NOT lógico de um valor booleano.

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

CONDITIONAL

Sintaxe:

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

Descrição:

Avalia e retorna o true_case se o condition for avaliado como TRUE.

Avalia e retorna o false_case se a condição for resolvida como FALSE, NULL ou um valor ABSENT.

Exemplos:

`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

Sintaxe:

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

Descrição:

Retorna TRUE se o value estiver na matriz search_space.

Exemplos:

`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

Sintaxe:

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

Descrição:

Retorna TRUE se value não estiver na matriz search_space.

Exemplos:

`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

Sintaxe:

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

Descrição:

Retorna o valor máximo não NULL e não ABSENT em uma série de valores x.

Se não houver valores diferentes de NULL e ABSENT, NULL será retornado.

Se houver vários valores equivalentes máximos, qualquer um deles poderá ser retornado. A ordem de tipo de valor segue a ordem documentada.

Exemplos:

`x`	`y`	`maximum(x, y)`
`FALSE`	`TRUE`	`TRUE`
`FALSE`	-10L	-10L
0,0	-5L	0,0
"foo"	"barra"	"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

Sintaxe:

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

Descrição:

Retorna o valor mínimo não NULL e não ABSENT em uma série de valores x.

Se não houver valores diferentes de NULL e ABSENT, NULL será retornado.

Se houver vários valores equivalentes mínimos, qualquer um deles poderá ser retornado. A ordem de tipo de valor segue a ordem documentada.

Exemplos:

`x`	`y`	`minimum(x, y)`
`FALSE`	`TRUE`	`FALSE`
`FALSE`	-10L	`FALSE`
0,0	-5L	-5L
"foo"	"barra"	"barra"
"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

Funções lógicas Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.