Wszystkie funkcje

Zbiorcze

Wszystkie funkcje agregacji mogą być używane jako wyrażenia najwyższego poziomu na etapie aggregate(...).

Nazwa Opis
COUNT Zwraca liczbę dokumentów.
COUNT_IF Zwraca liczbę dokumentów, w których wyrażenie przyjmuje wartość TRUE.
COUNT_DISTINCT Zwraca liczbę unikalnych wartości innych niż NULL.
SUM Zwraca sumę wszystkich wartości NUMERIC.
AVERAGE Zwraca średnią wszystkich wartości NUMERIC
MINIMUM Zwraca minimalną wartość inną niż NULL
MAXIMUM Zwraca maksymalną wartość inną niż NULL
FIRST Zwraca wartość expression pierwszego dokumentu.
LAST Zwraca wartość expression ostatniego dokumentu.
ARRAY_AGG Zwraca tablicę wszystkich wartości wejściowych.
ARRAY_AGG_DISTINCT Zwraca tablicę wszystkich niepowtarzalnych wartości wejściowych.

COUNT

Składnia:

count() -> INT64
count(expression: ANY) -> INT64

Opis:

Zwraca liczbę dokumentów z poprzedniego etapu, w których expression ma wartość inną niż NULL. Jeśli nie podasz expression, zwróci łączną liczbę dokumentów z poprzedniego etapu.

Node.js
// Total number of books in the collection
const countOfAll = await db.pipeline()
  .collection("books")
  .aggregate(countAll().as("count"))
  .execute();

// Number of books with nonnull `ratings` field
const countField = await db.pipeline()
  .collection("books")
  .aggregate(field("ratings").count().as("count"))
  .execute();
test.firestore.js

Web

// Total number of books in the collection
const countOfAll = await execute(db.pipeline()
  .collection("books")
  .aggregate(countAll().as("count"))
);

// Number of books with nonnull `ratings` field
const countField = await execute(db.pipeline()
  .collection("books")
  .aggregate(field("ratings").count().as("count"))
);
test.firestore.js
Swift
// Total number of books in the collection
let countAll = try await db.pipeline()
  .collection("books")
  .aggregate([CountAll().as("count")])
  .execute()

// Number of books with nonnull `ratings` field
let countField = try await db.pipeline()
  .collection("books")
  .aggregate([Field("ratings").count().as("count")])
  .execute()
PipelineSnippets.swift

Kotlin

// Total number of books in the collection
val countAll = db.pipeline()
    .collection("books")
    .aggregate(AggregateFunction.countAll().alias("count"))
    .execute()

// Number of books with nonnull `ratings` field
val countField = db.pipeline()
    .collection("books")
    .aggregate(AggregateFunction.count("ratings").alias("count"))
    .execute()
DocSnippets.kt

Java

// Total number of books in the collection
Task<Pipeline.Snapshot> countAll = db.pipeline()
    .collection("books")
    .aggregate(AggregateFunction.countAll().alias("count"))
    .execute();

// Number of books with nonnull `ratings` field
Task<Pipeline.Snapshot> countField = db.pipeline()
    .collection("books")
    .aggregate(AggregateFunction.count("ratings").alias("count"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Count

# Total number of books in the collection
count_all = (
    client.pipeline().collection("books").aggregate(Count().as_("count")).execute()
)

# Number of books with nonnull `ratings` field
count_field = (
    client.pipeline()
    .collection("books")
    .aggregate(Count("ratings").as_("count"))
    .execute()
)
firestore_pipelines.py
Java
// Total number of books in the collection
Pipeline.Snapshot countAll =
    firestore.pipeline().collection("books").aggregate(countAll().as("count")).execute().get();

// Number of books with nonnull `ratings` field
Pipeline.Snapshot countField =
    firestore
        .pipeline()
        .collection("books")
        .aggregate(count("ratings").as("count"))
        .execute()
        .get();
PipelineSnippets.java

LICZ.JEŻELI

Składnia:

count_if(expression: BOOLEAN) -> INT64

Opis:

Zwraca liczbę dokumentów z poprzedniego etapu, w których expression przyjmuje wartość TRUE.

Node.js
const result = await db.pipeline()
  .collection("books")
  .aggregate(
    field("rating").greaterThan(4).countIf().as("filteredCount")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .aggregate(
    field("rating").greaterThan(4).countIf().as("filteredCount")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .aggregate([
    AggregateFunction("count_if", [Field("rating").greaterThan(4)]).as("filteredCount")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .aggregate(
        AggregateFunction.countIf(field("rating").greaterThan(4)).alias("filteredCount")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .aggregate(
        AggregateFunction.countIf(field("rating").greaterThan(4)).alias("filteredCount")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .aggregate(Field.of("rating").greater_than(4).count_if().as_("filteredCount"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .aggregate(countIf(field("rating").greaterThan(4)).as("filteredCount"))
        .execute()
        .get();
PipelineSnippets.java

COUNT_DISTINCT

Składnia:

count_distinct(expression: ANY) -> INT64

Opis:

Zwraca liczbę unikalnych wartości innych niż NULL i ABSENT w expression.

Node.js
const result = await db.pipeline()
  .collection("books")
  .aggregate(field("author").countDistinct().as("unique_authors"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .aggregate(field("author").countDistinct().as("unique_authors"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .aggregate([AggregateFunction("count_distinct", [Field("author")]).as("unique_authors")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .aggregate(AggregateFunction.countDistinct("author").alias("unique_authors"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .aggregate(AggregateFunction.countDistinct("author").alias("unique_authors"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .aggregate(Field.of("author").count_distinct().as_("unique_authors"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .aggregate(countDistinct("author").as("unique_authors"))
        .execute()
        .get();
PipelineSnippets.java

SUMA

Składnia:

sum(expression: ANY) -> NUMBER

Opis:

Zwraca sumę wszystkich wartości liczbowych, ignorując wartości nieliczbowe. Zwraca wartość NaN, jeśli któraś z wartości to NaN.

Typ danych wyjściowych będzie taki sam jak typ danych wejściowych o największym zakresie, z wyjątkiem tych przypadków:

  • Jeśli znaku INTEGER nie można przedstawić jako INTEGER, zostanie on przekonwertowany na DOUBLE.
Node.js
const result = await db.pipeline()
  .collection("cities")
  .aggregate(field("population").sum().as("totalPopulation"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("cities")
  .aggregate(field("population").sum().as("totalPopulation"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("cities")
  .aggregate([Field("population").sum().as("totalPopulation")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("cities")
    .aggregate(AggregateFunction.sum("population").alias("totalPopulation"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("cities")
    .aggregate(AggregateFunction.sum("population").alias("totalPopulation"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("cities")
    .aggregate(Field.of("population").sum().as_("totalPopulation"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("cities")
        .aggregate(sum("population").as("totalPopulation"))
        .execute()
        .get();
PipelineSnippets.java

ŚREDNIA

Składnia:

average(expression: ANY) -> FLOAT64

Opis:

Zwraca średnią wszystkich wartości liczbowych, ignorując wartości nieliczbowe. Zwraca wartość NaN, jeśli któraś z wartości to NaN, lub NULL, jeśli nie ma wartości liczbowych do agregacji.

Typ danych wyjściowych będzie taki sam jak typ danych wejściowych, z wyjątkiem tych przypadków:

  • Jeśli znaku INTEGER nie można przedstawić jako INTEGER, zostanie on przekonwertowany na DOUBLE.
Node.js
const result = await db.pipeline()
  .collection("cities")
  .aggregate(field("population").average().as("averagePopulation"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("cities")
  .aggregate(field("population").average().as("averagePopulation"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("cities")
  .aggregate([Field("population").average().as("averagePopulation")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("cities")
    .aggregate(AggregateFunction.average("population").alias("averagePopulation"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("cities")
    .aggregate(AggregateFunction.average("population").alias("averagePopulation"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("cities")
    .aggregate(Field.of("population").average().as_("averagePopulation"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("cities")
        .aggregate(average("population").as("averagePopulation"))
        .execute()
        .get();
PipelineSnippets.java

MINIMUM

Składnia:

minimum(expression: ANY) -> ANY

Opis:

Zwraca minimalną wartość expression, która nie jest wartością NULL ani wartością pustą, po obliczeniu dla każdego dokumentu.

Jeśli nie ma wartości innych niż NULL i nieobecnych, zwracana jest wartość NULL. Dotyczy to również sytuacji, w których nie są brane pod uwagę żadne dokumenty.

Jeśli istnieje kilka minimalnych wartości równoważnych, można zwrócić dowolną z nich. Kolejność typów wartości jest zgodna z udokumentowaną kolejnością.

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

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")
  .aggregate([Field("price").minimum().as("minimumPrice")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .aggregate(AggregateFunction.minimum("price").alias("minimumPrice"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .aggregate(AggregateFunction.minimum("price").alias("minimumPrice"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .aggregate(Field.of("price").minimum().as_("minimumPrice"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .aggregate(minimum("price").as("minimumPrice"))
        .execute()
        .get();
PipelineSnippets.java

MAKSYMALNA

Składnia:

maximum(expression: ANY) -> ANY

Opis:

Zwraca maksymalną wartość inną niż NULL i nieobecną w przypadku expression po obliczeniu dla każdego dokumentu.

Jeśli nie ma wartości innych niż NULL i nieobecnych, zwracana jest wartość NULL. Dotyczy to również sytuacji, w których nie są brane pod uwagę żadne dokumenty.

Jeśli istnieje kilka maksymalnych wartości równoważnych, można zwrócić dowolną z nich. Kolejność typów wartości jest zgodna z udokumentowaną kolejnością.

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

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")
  .aggregate([Field("price").maximum().as("maximumPrice")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .aggregate(AggregateFunction.maximum("price").alias("maximumPrice"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .aggregate(AggregateFunction.maximum("price").alias("maximumPrice"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .aggregate(Field.of("price").maximum().as_("maximumPrice"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .aggregate(maximum("price").as("maximumPrice"))
        .execute()
        .get();
PipelineSnippets.java

FIRST

Składnia:

first(expression: ANY) -> ANY

Opis:

Zwraca wartość expression dla pierwszego zwróconego dokumentu.

OSTATNI

Składnia:

last(expression: ANY) -> ANY

Opis:

Zwraca wartość expression w przypadku ostatniego zwróconego dokumentu.

ARRAY_AGG

Składnia:

array_agg(expression: ANY) -> ARRAY<ANY>

Opis:

Zwraca tablicę zawierającą wszystkie wartości expression po obliczeniu dla każdego dokumentu.

Jeśli wyrażenie przyjmuje wartość nieobecną, jest ona konwertowana na NULL.

Kolejność elementów w tablicy wyjściowej nie jest stała i nie należy na niej polegać.

ARRAY_AGG_DISTINCT

Składnia:

array_agg_distinct(expression: ANY) -> ARRAY<ANY>

Opis:

Zwraca tablicę zawierającą wszystkie unikalne wartości expression po obliczeniu dla każdego dokumentu.

Jeśli wyrażenie przyjmuje wartość nieobecną, jest ona konwertowana na NULL.

Kolejność elementów w tablicy wyjściowej nie jest stała i nie należy na niej polegać.

Funkcje arytmetyczne

Wszystkie funkcje arytmetyczne w Cloud Firestore działają w ten sposób:

  • Zwraca wartość NULL, jeśli którykolwiek z parametrów wejściowych ma wartość NULL.
  • Zwraca wartość NaN, jeśli którykolwiek z argumentów ma wartość NaN.
  • Generuje błąd, jeśli wystąpi przepełnienie lub niedopełnienie.

Dodatkowo, gdy funkcja arytmetyczna przyjmuje wiele argumentów liczbowych różnych typów (np. add(5.0, 6)), Cloud Firestore niejawnie konwertuje argumenty na najszerszy typ wejściowy. Jeśli podane są tylko dane wejściowe INT32, typ zwracany to INT64.

Nazwa Opis
ABS Zwraca wartość bezwzględną liczby number.
ADD Zwraca wartość x + y
SUBTRACT Zwraca wartość x - y
MULTIPLY Zwraca wartość x * y
DIVIDE Zwraca wartość x / y
MOD Zwraca resztę z dzielenia x / y
CEIL Zwraca zaokrąglenie w górę liczby number.
FLOOR Zwraca wartość zaokrągloną w dół do najbliższej liczby całkowitej z number
ROUND Zaokrągla liczbę number do places miejsc po przecinku.
TRUNC Skraca liczbę number do places miejsc po przecinku.
POW Zwraca wartość base^exponent
SQRT Zwraca pierwiastek kwadratowy z number.
EXP Zwraca liczbę Eulera podniesioną do potęgi exponent
LN Zwraca logarytm naturalny z a number
LOG Zwraca logarytm liczby number
LOG10 Zwraca logarytm liczby number o podstawie 10.
RAND Zwraca pseudolosową liczbę zmiennoprzecinkową.

ABS

Składnia:

abs[N <: INT32 | INT64 | FLOAT64](number: N) -> N

Opis:

Zwraca wartość bezwzględną liczby number.

  • Zwraca błąd, gdy funkcja spowoduje przepełnienie wartości INT32 lub INT64.

Przykłady:

liczba abs(number)
10 10
-10 10
10L 10L
-0,0 0,0
10.5 10.5
-10,5 10.5
-231 [error]
-263 [error]

DODAJ

Składnia:

add[N <: INT32 | INT64 | FLOAT64](x: N, y: N) -> N

Opis:

Zwraca wartość x + y.

Przykłady:

x y add(x, y)
20 3 23
10,0 1 11.0
22,5 2,0 24,5
INT64.MAX 1 [error]
INT64.MIN -1 [error]
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("soldBooks").add(field("unsoldBooks")).as("totalBooks"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("soldBooks").add(field("unsoldBooks")).as("totalBooks"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("soldBooks").add(Field("unsoldBooks")).as("totalBooks")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(Expression.add(field("soldBooks"), field("unsoldBooks")).alias("totalBooks"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(Expression.add(field("soldBooks"), field("unsoldBooks")).alias("totalBooks"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("soldBooks").add(Field.of("unsoldBooks")).as_("totalBooks"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(add(field("soldBooks"), field("unsoldBooks")).as("totalBooks"))
        .execute()
        .get();
PipelineSnippets.java

ODEJMOWANIE

Składnia:

subtract[N <: INT32 | INT64 | FLOAT64](x: N, y: N) -> N

Opis:

Zwraca wartość x - y.

Przykłady:

x y subtract(x, y)
20 3 17
10,0 1 9.0
22,5 2,0 20,5
INT64.MAX -1 [error]
INT64.MIN 1 [error]
Node.js
const storeCredit = 7;
const result = await db.pipeline()
  .collection("books")
  .select(field("price").subtract(constant(storeCredit)).as("totalCost"))
  .execute();
test.firestore.js

Web

const storeCredit = 7;
const result = await execute(db.pipeline()
  .collection("books")
  .select(field("price").subtract(constant(storeCredit)).as("totalCost"))
);
test.firestore.js
Swift
let storeCredit = 7
let result = try await db.pipeline()
  .collection("books")
  .select([Field("price").subtract(Constant(storeCredit)).as("totalCost")])
  .execute()
PipelineSnippets.swift

Kotlin

val storeCredit = 7
val result = db.pipeline()
    .collection("books")
    .select(Expression.subtract(field("price"), storeCredit).alias("totalCost"))
    .execute()
DocSnippets.kt

Java

int storeCredit = 7;
Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(Expression.subtract(field("price"), storeCredit).alias("totalCost"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

store_credit = 7
result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("price").subtract(store_credit).as_("totalCost"))
    .execute()
)
firestore_pipelines.py
Java
int storeCredit = 7;
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(subtract(field("price"), storeCredit).as("totalCost"))
        .execute()
        .get();
PipelineSnippets.java

MULTIPLY

Składnia:

multiply[N <: INT32 | INT64 | FLOAT64](x: N, y: N) -> N

Opis:

Zwraca wartość x * y.

Przykłady:

x y multiply(x, y)
20 3 60
10,0 1 10,0
22,5 2,0 45,0
INT64.MAX 2 [error]
INT64.MIN 2 [error]
FLOAT64.MAX FLOAT64.MAX +inf
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("price").multiply(field("soldBooks")).as("revenue"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("price").multiply(field("soldBooks")).as("revenue"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("price").multiply(Field("soldBooks")).as("revenue")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(Expression.multiply(field("price"), field("soldBooks")).alias("revenue"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(Expression.multiply(field("price"), field("soldBooks")).alias("revenue"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("price").multiply(Field.of("soldBooks")).as_("revenue"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(multiply(field("price"), field("soldBooks")).as("revenue"))
        .execute()
        .get();
PipelineSnippets.java

DIVIDE

Składnia:

divide[N <: INT32 | INT64 | FLOAT64](x: N, y: N) -> N

Opis:

Zwraca wartość x / y. Dzielenie całkowite jest obcinane.

Przykłady:

x y divide(x, y)
20 3 6
10,0 3 3,333...
22,5 2 11.25
10 0 [error]
1,0 0,0 +inf
-1,0 0,0 -inf
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("ratings").divide(field("soldBooks")).as("reviewRate"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("ratings").divide(field("soldBooks")).as("reviewRate"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("ratings").divide(Field("soldBooks")).as("reviewRate")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(Expression.divide(field("ratings"), field("soldBooks")).alias("reviewRate"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(Expression.divide(field("ratings"), field("soldBooks")).alias("reviewRate"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("ratings").divide(Field.of("soldBooks")).as_("reviewRate"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(divide(field("ratings"), field("soldBooks")).as("reviewRate"))
        .execute()
        .get();
PipelineSnippets.java

MOD

Składnia:

mod[N <: INT32 | INT64 | FLOAT64](x: N, y: N) -> N

Opis:

Zwraca resztę z dzielenia x / y.

  • Zwraca błąd error, gdy y ma wartość zero w przypadku typów całkowitych (INT64).
  • Zwraca NaN, gdy y ma wartość zero w przypadku typów zmiennoprzecinkowych (FLOAT64).

Przykłady:

x y mod(x, y)
20 3 2
-10 3 -1
10 -3 1
-10 -3 -1
10 1 0
22,5 2 0,5
22,5 0,0 NaN
25 0 [error]
Node.js
const displayCapacity = 1000;
const result = await db.pipeline()
  .collection("books")
  .select(field("unsoldBooks").mod(constant(displayCapacity)).as("warehousedBooks"))
  .execute();
test.firestore.js

Web

const displayCapacity = 1000;
const result = await execute(db.pipeline()
  .collection("books")
  .select(field("unsoldBooks").mod(constant(displayCapacity)).as("warehousedBooks"))
);
test.firestore.js
Swift
let displayCapacity = 1000
let result = try await db.pipeline()
  .collection("books")
  .select([Field("unsoldBooks").mod(Constant(displayCapacity)).as("warehousedBooks")])
  .execute()
PipelineSnippets.swift

Kotlin

val displayCapacity = 1000
val result = db.pipeline()
    .collection("books")
    .select(Expression.mod(field("unsoldBooks"), displayCapacity).alias("warehousedBooks"))
    .execute()
DocSnippets.kt

Java

int displayCapacity = 1000;
Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(Expression.mod(field("unsoldBooks"), displayCapacity).alias("warehousedBooks"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

display_capacity = 1000
result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("unsoldBooks").mod(display_capacity).as_("warehousedBooks"))
    .execute()
)
firestore_pipelines.py
Java
int displayCapacity = 1000;
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(mod(field("unsoldBooks"), displayCapacity).as("warehousedBooks"))
        .execute()
        .get();
PipelineSnippets.java

CEIL

Składnia:

ceil[N <: INT32 | INT64 | FLOAT64](number: N) -> N

Opis:

Zwraca najmniejszą liczbę całkowitą, która nie jest mniejsza niż number.

Przykłady:

liczba ceil(number)
20 20
10 10
0 0
24L 24L
-0,4 -0,0
0,4 1,0
22,5 23,0
+inf +inf
-inf -inf
Node.js
const booksPerShelf = 100;
const result = await db.pipeline()
  .collection("books")
  .select(
    field("unsoldBooks").divide(constant(booksPerShelf)).ceil().as("requiredShelves")
  )
  .execute();
test.firestore.js

Web

const booksPerShelf = 100;
const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("unsoldBooks").divide(constant(booksPerShelf)).ceil().as("requiredShelves")
  )
);
test.firestore.js
Swift
let booksPerShelf = 100
let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("unsoldBooks").divide(Constant(booksPerShelf)).ceil().as("requiredShelves")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val booksPerShelf = 100
val result = db.pipeline()
    .collection("books")
    .select(
        Expression.divide(field("unsoldBooks"), booksPerShelf).ceil().alias("requiredShelves")
    )
    .execute()
DocSnippets.kt

Java

int booksPerShelf = 100;
Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        Expression.divide(field("unsoldBooks"), booksPerShelf).ceil().alias("requiredShelves")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

books_per_shelf = 100
result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("unsoldBooks")
        .divide(books_per_shelf)
        .ceil()
        .as_("requiredShelves")
    )
    .execute()
)
firestore_pipelines.py
Java
int booksPerShelf = 100;
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(ceil(divide(field("unsoldBooks"), booksPerShelf)).as("requiredShelves"))
        .execute()
        .get();
PipelineSnippets.java

PIĘTRO

Składnia:

floor[N <: INT32 | INT64 | FLOAT64](number: N) -> N

Opis:

Zwraca największą liczbę całkowitą, która nie jest większa niż number.

Przykłady:

liczba floor(number)
20 20
10 10
0 0
2147483648 2147483648
-0,4 -1,0
0,4 0,0
22,5 22,0
+inf +inf
-inf -inf
Node.js
const result = await db.pipeline()
  .collection("books")
  .addFields(
    field("wordCount").divide(field("pages")).floor().as("wordsPerPage")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .addFields(
    field("wordCount").divide(field("pages")).floor().as("wordsPerPage")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .addFields([
    Field("wordCount").divide(Field("pages")).floor().as("wordsPerPage")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .addFields(
        Expression.divide(field("wordCount"), field("pages")).floor().alias("wordsPerPage")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .addFields(
        Expression.divide(field("wordCount"), field("pages")).floor().alias("wordsPerPage")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .add_fields(
        Field.of("wordCount").divide(Field.of("pages")).floor().as_("wordsPerPage")
    )
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .addFields(floor(divide(field("wordCount"), field("pages"))).as("wordsPerPage"))
        .execute()
        .get();
PipelineSnippets.java

ZAOKR

Składnia:

round[N <: INT32 | INT64 | FLOAT64 | DECIMAL128](number: N) -> N
round[N <: INT32 | INT64 | FLOAT64 | DECIMAL128](number: N, places: INT64) -> N

Opis:

Zaokrągla places cyfr z liczby number. Zaokrągla cyfry po prawej stronie przecinka dziesiętnego, jeśli places jest dodatnie, a po lewej stronie przecinka dziesiętnego, jeśli jest ujemne.

  • Jeśli podano tylko wartość number, zaokrągla do najbliższej liczby całkowitej.
  • Zaokrągla w przypadku wartości pośrednich.
  • Jeśli zaokrąglanie z ujemną wartością places spowoduje przepełnienie, zostanie zgłoszony błąd error.

Przykłady:

liczba miejsca round(number, places)
15,5 0 16,0
-15,5 0 -16,0
15 1 15
15 0 15
15 -1 20
15 -2 0
15.48924 1 15,5
231-1 -1 [error]
263-1L -1 [error]
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("soldBooks").multiply(field("price")).round().as("partialRevenue"))
  .aggregate(field("partialRevenue").sum().as("totalRevenue"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("soldBooks").multiply(field("price")).round().as("partialRevenue"))
  .aggregate(field("partialRevenue").sum().as("totalRevenue"))
  );
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("soldBooks").multiply(Field("price")).round().as("partialRevenue")])
  .aggregate([Field("partialRevenue").sum().as("totalRevenue")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(Expression.multiply(field("soldBooks"), field("price")).round().alias("partialRevenue"))
    .aggregate(AggregateFunction.sum("partialRevenue").alias("totalRevenue"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(Expression.multiply(field("soldBooks"), field("price")).round().alias("partialRevenue"))
    .aggregate(AggregateFunction.sum("partialRevenue").alias("totalRevenue"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("soldBooks")
        .multiply(Field.of("price"))
        .round()
        .as_("partialRevenue")
    )
    .aggregate(Field.of("partialRevenue").sum().as_("totalRevenue"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(round(multiply(field("soldBooks"), field("price"))).as("partialRevenue"))
        .aggregate(sum("partialRevenue").as("totalRevenue"))
        .execute()
        .get();
PipelineSnippets.java

TRUNC

Składnia:

trunc[N <: Number](number: N) -> N
trunc[N <: Number](number:  N, places: INT64) -> N

Opis:

Obcina liczbę number do określonej liczby places miejsc po przecinku. Obcina cyfry po prawej stronie przecinka dziesiętnego, jeśli argument places jest dodatni, a po lewej stronie, jeśli jest ujemny.

  • Jeśli podana jest tylko wartość number, zaokrągla do najbliższej liczby całkowitej w kierunku zera.
  • Jeśli obcięcie wyników spowoduje przepełnienie, zostanie zgłoszony błąd error.

Przykłady:

liczba miejsca trunc(number, places)
15,5 0 15,0
-15,5 0 -15,0
15 1 15
15 0 15
15 -1 10
15 -2 0
15.48924 1 15,4
-15.48924 2 -15,48

POW

Składnia:

pow(base: FLOAT64, exponent: FLOAT64) -> FLOAT64

Opis:

Zwraca wartość base podniesioną do potęgi exponent.

  • Zwraca błąd, jeśli argumenty base <= 0 i exponent mają wartość ujemną.

  • Dla dowolnego exponent wartość pow(1, exponent) wynosi 1.

  • Dla dowolnego base wartość pow(base, 0) wynosi 1.

Przykłady:

podstawa, podstawa logarytmu naturalnego pow(base, exponent)
2 3 8.0
2 -3 0.125
+inf 0 1,0
1 +inf 1,0
-1 0,5 [error]
0 -1 [error]
Node.js
const googleplex = { latitude: 37.4221, longitude: 122.0853 };
const result = await db.pipeline()
  .collection("cities")
  .addFields(
    field("lat").subtract(constant(googleplex.latitude))
      .multiply(111 /* km per degree */)
      .pow(2)
      .as("latitudeDifference"),
    field("lng").subtract(constant(googleplex.longitude))
      .multiply(111 /* km per degree */)
      .pow(2)
      .as("longitudeDifference")
  )
  .select(
    field("latitudeDifference").add(field("longitudeDifference")).sqrt()
      // Inaccurate for large distances or close to poles
      .as("approximateDistanceToGoogle")
  )
  .execute();
test.firestore.js

Web

const googleplex = { latitude: 37.4221, longitude: 122.0853 };
const result = await execute(db.pipeline()
  .collection("cities")
  .addFields(
    field("lat").subtract(constant(googleplex.latitude))
      .multiply(111 /* km per degree */)
      .pow(2)
      .as("latitudeDifference"),
    field("lng").subtract(constant(googleplex.longitude))
      .multiply(111 /* km per degree */)
      .pow(2)
      .as("longitudeDifference")
  )
  .select(
    field("latitudeDifference").add(field("longitudeDifference")).sqrt()
      // Inaccurate for large distances or close to poles
      .as("approximateDistanceToGoogle")
  )
);
test.firestore.js
Swift
let googleplex = CLLocation(latitude: 37.4221, longitude: 122.0853)
let result = try await db.pipeline()
  .collection("cities")
  .addFields([
    Field("lat").subtract(Constant(googleplex.coordinate.latitude))
      .multiply(111 /* km per degree */)
      .pow(2)
      .as("latitudeDifference"),
    Field("lng").subtract(Constant(googleplex.coordinate.latitude))
      .multiply(111 /* km per degree */)
      .pow(2)
      .as("longitudeDifference")
  ])
  .select([
    Field("latitudeDifference").add(Field("longitudeDifference")).sqrt()
      // Inaccurate for large distances or close to poles
      .as("approximateDistanceToGoogle")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val googleplex = GeoPoint(37.4221, -122.0853)
val result = db.pipeline()
    .collection("cities")
    .addFields(
        field("lat").subtract(googleplex.latitude)
            .multiply(111 /* km per degree */)
            .pow(2)
            .alias("latitudeDifference"),
        field("lng").subtract(googleplex.longitude)
            .multiply(111 /* km per degree */)
            .pow(2)
            .alias("longitudeDifference")
    )
    .select(
        field("latitudeDifference").add(field("longitudeDifference")).sqrt()
            // Inaccurate for large distances or close to poles
            .alias("approximateDistanceToGoogle")
    )
    .execute()
DocSnippets.kt

Java

GeoPoint googleplex = new GeoPoint(37.4221, -122.0853);
Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("cities")
    .addFields(
        field("lat").subtract(googleplex.getLatitude())
            .multiply(111 /* km per degree */)
            .pow(2)
            .alias("latitudeDifference"),
        field("lng").subtract(googleplex.getLongitude())
            .multiply(111 /* km per degree */)
            .pow(2)
            .alias("longitudeDifference")
    )
    .select(
        field("latitudeDifference").add(field("longitudeDifference")).sqrt()
            // Inaccurate for large distances or close to poles
            .alias("approximateDistanceToGoogle")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

googleplexLat = 37.4221
googleplexLng = -122.0853
result = (
    client.pipeline()
    .collection("cities")
    .add_fields(
        Field.of("lat")
        .subtract(googleplexLat)
        .multiply(111)  # km per degree
        .pow(2)
        .as_("latitudeDifference"),
        Field.of("lng")
        .subtract(googleplexLng)
        .multiply(111)  # km per degree
        .pow(2)
        .as_("longitudeDifference"),
    )
    .select(
        Field.of("latitudeDifference")
        .add(Field.of("longitudeDifference"))
        .sqrt()
        # Inaccurate for large distances or close to poles
        .as_("approximateDistanceToGoogle")
    )
    .execute()
)
firestore_pipelines.py
Java
double googleplexLat = 37.4221;
double googleplexLng = -122.0853;
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("cities")
        .addFields(
            pow(multiply(subtract(field("lat"), googleplexLat), 111), 2)
                .as("latitudeDifference"),
            pow(multiply(subtract(field("lng"), googleplexLng), 111), 2)
                .as("longitudeDifference"))
        .select(
            sqrt(add(field("latitudeDifference"), field("longitudeDifference")))
                // Inaccurate for large distances or close to poles
                .as("approximateDistanceToGoogle"))
        .execute()
        .get();
PipelineSnippets.java

PIERWIASTEK

Składnia:

sqrt[N <: FLOAT64 | DECIMAL128](number: N) -> N

Opis:

Zwraca pierwiastek kwadratowy z number.

  • Zwraca błąd error, jeśli wartość number jest ujemna.

Przykłady:

liczba sqrt(number)
25 5,0
12,002 3,464...
0,0 0,0
NaN NaN
+inf +inf
-inf [error]
x < 0 [error]
Node.js
const googleplex = { latitude: 37.4221, longitude: 122.0853 };
const result = await db.pipeline()
  .collection("cities")
  .addFields(
    field("lat").subtract(constant(googleplex.latitude))
      .multiply(111 /* km per degree */)
      .pow(2)
      .as("latitudeDifference"),
    field("lng").subtract(constant(googleplex.longitude))
      .multiply(111 /* km per degree */)
      .pow(2)
      .as("longitudeDifference")
  )
  .select(
    field("latitudeDifference").add(field("longitudeDifference")).sqrt()
      // Inaccurate for large distances or close to poles
      .as("approximateDistanceToGoogle")
  )
  .execute();
test.firestore.js

Web

const googleplex = { latitude: 37.4221, longitude: 122.0853 };
const result = await execute(db.pipeline()
  .collection("cities")
  .addFields(
    field("lat").subtract(constant(googleplex.latitude))
      .multiply(111 /* km per degree */)
      .pow(2)
      .as("latitudeDifference"),
    field("lng").subtract(constant(googleplex.longitude))
      .multiply(111 /* km per degree */)
      .pow(2)
      .as("longitudeDifference")
  )
  .select(
    field("latitudeDifference").add(field("longitudeDifference")).sqrt()
      // Inaccurate for large distances or close to poles
      .as("approximateDistanceToGoogle")
  )
);
test.firestore.js
Swift
let googleplex = CLLocation(latitude: 37.4221, longitude: 122.0853)
let result = try await db.pipeline()
  .collection("cities")
  .addFields([
    Field("lat").subtract(Constant(googleplex.coordinate.latitude))
      .multiply(111 /* km per degree */)
      .pow(2)
      .as("latitudeDifference"),
    Field("lng").subtract(Constant(googleplex.coordinate.latitude))
      .multiply(111 /* km per degree */)
      .pow(2)
      .as("longitudeDifference")
  ])
  .select([
    Field("latitudeDifference").add(Field("longitudeDifference")).sqrt()
      // Inaccurate for large distances or close to poles
      .as("approximateDistanceToGoogle")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val googleplex = GeoPoint(37.4221, -122.0853)
val result = db.pipeline()
    .collection("cities")
    .addFields(
        field("lat").subtract(googleplex.latitude)
            .multiply(111 /* km per degree */)
            .pow(2)
            .alias("latitudeDifference"),
        field("lng").subtract(googleplex.longitude)
            .multiply(111 /* km per degree */)
            .pow(2)
            .alias("longitudeDifference")
    )
    .select(
        field("latitudeDifference").add(field("longitudeDifference")).sqrt()
            // Inaccurate for large distances or close to poles
            .alias("approximateDistanceToGoogle")
    )
    .execute()
DocSnippets.kt

Java

GeoPoint googleplex = new GeoPoint(37.4221, -122.0853);
Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("cities")
    .addFields(
        field("lat").subtract(googleplex.getLatitude())
            .multiply(111 /* km per degree */)
            .pow(2)
            .alias("latitudeDifference"),
        field("lng").subtract(googleplex.getLongitude())
            .multiply(111 /* km per degree */)
            .pow(2)
            .alias("longitudeDifference")
    )
    .select(
        field("latitudeDifference").add(field("longitudeDifference")).sqrt()
            // Inaccurate for large distances or close to poles
            .alias("approximateDistanceToGoogle")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

googleplexLat = 37.4221
googleplexLng = -122.0853
result = (
    client.pipeline()
    .collection("cities")
    .add_fields(
        Field.of("lat")
        .subtract(googleplexLat)
        .multiply(111)  # km per degree
        .pow(2)
        .as_("latitudeDifference"),
        Field.of("lng")
        .subtract(googleplexLng)
        .multiply(111)  # km per degree
        .pow(2)
        .as_("longitudeDifference"),
    )
    .select(
        Field.of("latitudeDifference")
        .add(Field.of("longitudeDifference"))
        .sqrt()
        # Inaccurate for large distances or close to poles
        .as_("approximateDistanceToGoogle")
    )
    .execute()
)
firestore_pipelines.py
Java
double googleplexLat = 37.4221;
double googleplexLng = -122.0853;
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("cities")
        .addFields(
            pow(multiply(subtract(field("lat"), googleplexLat), 111), 2)
                .as("latitudeDifference"),
            pow(multiply(subtract(field("lng"), googleplexLng), 111), 2)
                .as("longitudeDifference"))
        .select(
            sqrt(add(field("latitudeDifference"), field("longitudeDifference")))
                // Inaccurate for large distances or close to poles
                .as("approximateDistanceToGoogle"))
        .execute()
        .get();
PipelineSnippets.java

EXP

Składnia:

exp(exponent: FLOAT64) -> FLOAT64

Opis:

Zwraca wartość liczby Eulera podniesionej do potęgi exponent, zwanej też naturalną funkcją wykładniczą.

Przykłady:

podstawa logarytmu naturalnego exp(exponent)
0,0 1,0
10 e^10 (FLOAT64)
+inf +inf
-inf 0
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("rating").exp().as("expRating"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("rating").exp().as("expRating"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("rating").exp().as("expRating")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(field("rating").exp().alias("expRating"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("rating").exp().alias("expRating"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("rating").exp().as_("expRating"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(exp(field("rating")).as("expRating"))
        .execute()
        .get();
PipelineSnippets.java

LN

Składnia:

ln(number: FLOAT64) -> FLOAT64

Opis:

Zwraca logarytm naturalny z number. Ta funkcja jest odpowiednikiem funkcji log(number).

Przykłady:

liczba ln(number)
1 0,0
2L 0,693...
1,0 0,0
e (FLOAT64) 1,0
-inf NaN
+inf +inf
x <= 0 [error]
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("rating").ln().as("lnRating"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("rating").ln().as("lnRating"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("rating").ln().as("lnRating")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(field("rating").ln().alias("lnRating"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("rating").ln().alias("lnRating"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("rating").ln().as_("lnRating"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(ln(field("rating")).as("lnRating"))
        .execute()
        .get();
PipelineSnippets.java

LOG

Składnia:

log(number: FLOAT64, base: FLOAT64) -> FLOAT64
log(number: FLOAT64) -> FLOAT64

Opis:

Zwraca logarytm liczby number o podstawie base.

  • Jeśli podany jest tylko argument number, zwraca logarytm liczby number o podstawie base (synonim funkcji ln(number)).

Przykłady:

liczba podstawa, log(number, base)
100 10 2,0
-inf Numeric NaN
Numeric. +inf NaN
number <= 0 Numeric [error]
Numeric base <= 0 [error]
Numeric 1,0 [error]

LOG10

Składnia:

log10(x: FLOAT64) -> FLOAT64

Opis:

Zwraca logarytm liczby number o podstawie 10.

Przykłady:

liczba log10(number)
100 2,0
-inf NaN
+inf +inf
x <= 0 [error]

RAND

Składnia:

rand() -> FLOAT64

Opis:

Zwraca pseudolosową liczbę zmiennoprzecinkową wybraną równomiernie z przedziału od 0.0 (włącznie) do 1.0 (wyłącznie).

Funkcje tablicowe

Nazwa Opis
ARRAY Zwraca element ARRAY zawierający po jednym elemencie dla każdego argumentu wejściowego.
ARRAY_CONCAT Łączy wiele tablic w jedną ARRAY.
ARRAY_CONTAINS Zwraca TRUE, jeśli dany ARRAY zawiera określoną wartość.
ARRAY_CONTAINS_ALL Zwraca TRUE, jeśli wszystkie wartości znajdują się w ARRAY.
ARRAY_CONTAINS_ANY Zwraca wartość TRUE, jeśli którakolwiek z wartości występuje w ARRAY
ARRAY_FILTER Odfiltrowuje elementy z ARRAY, które nie spełniają predykatu.
ARRAY_FIRST Zwraca pierwszy element w ARRAY
ARRAY_FIRST_N Zwraca pierwsze n elementów w ARRAY
ARRAY_GET Zwraca element o podanym indeksie w ARRAY
ARRAY_INDEX_OF Zwraca indeks pierwszego wystąpienia wartości w ARRAY
ARRAY_INDEX_OF_ALL Zwraca wszystkie indeksy wartości w ARRAY
ARRAY_LENGTH Zwraca liczbę elementów w ARRAY
ARRAY_LAST Zwraca ostatni element w ARRAY
ARRAY_LAST_N Zwraca ostatnie n elementów w ARRAY
ARRAY_REVERSE Odwraca kolejność elementów w ARRAY.
ARRAY_SLICE Zwraca wycinek ARRAY.
ARRAY_TRANSFORM Przekształca elementy w ARRAY, stosując wyrażenie do każdego elementu.
MAXIMUM Zwraca maksymalną wartość w kolumnie ARRAY
MAXIMUM_N Zwraca n największych wartości w ARRAY
MINIMUM Zwraca minimalną wartość w ARRAY
MINIMUM_N Zwraca n najmniejszych wartości w ARRAY
SUM Zwraca sumę wszystkich wartości NUMERIC w ARRAY.
JOIN Tworzy konkatenację elementów w ARRAY jako wartość STRING.

ARRAY

Składnia:

array(values: ANY...) -> ARRAY

Opis:

Tworzy tablicę z podanych elementów.

  • Jeśli argument nie istnieje, w wynikowej tablicy jest zastępowany wartością NULL.

Przykłady:

wartości array(values)
() []
(1, 2, 3) [1, 2, 3]
("a", 1, true) ["a", 1, true]
(1, null) [1, null]
(1, [2, 3]) [1, [2, 3]]

ARRAY_CONCAT

Składnia:

array_concat(arrays: ARRAY...) -> ARRAY

Opis:

Łączy co najmniej 2 tablice w jedną ARRAY.

Przykłady:

tablice, array_concat(arrays)
([1, 2], [3, 4]) [1, 2, 3, 4]
(["a", "b"], ["c"]) ["a", "b", "c"]
([1], [2], [3]) [1, 2, 3]
([], [1, 2]) [1, 2]
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("genre").arrayConcat([field("subGenre")]).as("allGenres"))
  .execute();
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("genre").arrayConcat([Field("subGenre")]).as("allGenres")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(field("genre").arrayConcat(field("subGenre")).alias("allGenres"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("genre").arrayConcat(field("subGenre")).alias("allGenres"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("genre").array_concat(Field.of("subGenre")).as_("allGenres"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(arrayConcat(field("genre"), field("subGenre")).as("allGenres"))
        .execute()
        .get();
PipelineSnippets.java

ARRAY_CONTAINS

Składnia:

array_contains(array: ARRAY, value: ANY) -> BOOLEAN

Opis:

Zwraca TRUE, jeśli w array znajduje się value, a w przeciwnym razie zwraca FALSE.

Przykłady:

tablica wartość array_contains(array, value)
[1, 2, 3] 2 prawda
[[1, 2], [3]] [1, 2] prawda
[1, null] null prawda
„abc” DOWOLNA błąd
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("genre").arrayContains(constant("mystery")).as("isMystery"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("genre").arrayContains(constant("mystery")).as("isMystery"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("genre").arrayContains(Constant("mystery")).as("isMystery")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(field("genre").arrayContains("mystery").alias("isMystery"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("genre").arrayContains("mystery").alias("isMystery"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("genre").array_contains("mystery").as_("isMystery"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(arrayContains(field("genre"), "mystery").as("isMystery"))
        .execute()
        .get();
PipelineSnippets.java

ARRAY_CONTAINS_ALL

Składnia:

array_contains_all(array: ARRAY, search_values: ARRAY) -> BOOLEAN

Opis:

Zwraca wartość TRUE, jeśli wszystkie elementy search_values znajdują się w elemencie array, a w przeciwnym razie zwraca wartość FALSE.

Przykłady:

tablica szukane_wartości array_contains_all(array, search_values)
[1, 2, 3] [1, 2] prawda
[1, 2, 3] [1, 4] fałsz
[1, null] [wartość nieokreślona] prawda
[NaN] [NaN] prawda
[] [] prawda
[1, 2, 3] [] prawda
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(
    field("genre")
      .arrayContainsAll([constant("fantasy"), constant("adventure")])
      .as("isFantasyAdventure")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("genre")
      .arrayContainsAll([constant("fantasy"), constant("adventure")])
      .as("isFantasyAdventure")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("genre")
      .arrayContainsAll([Constant("fantasy"), Constant("adventure")])
      .as("isFantasyAdventure")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        field("genre")
            .arrayContainsAll(listOf("fantasy", "adventure"))
            .alias("isFantasyAdventure")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("genre")
            .arrayContainsAll(Arrays.asList("fantasy", "adventure"))
            .alias("isFantasyAdventure")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("genre")
        .array_contains_all(["fantasy", "adventure"])
        .as_("isFantasyAdventure")
    )
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            arrayContainsAll(field("genre"), Arrays.asList("fantasy", "adventure"))
                .as("isFantasyAdventure"))
        .execute()
        .get();
PipelineSnippets.java

ARRAY_CONTAINS_ANY

Składnia:

array_contains_any(array: ARRAY, search_values: ARRAY) -> BOOLEAN

Opis:

Zwraca wartość TRUE, jeśli w elemencie array znajdzie się którykolwiek z elementów search_values, a w przeciwnym razie zwraca wartość FALSE.

Przykłady:

tablica szukane_wartości array_contains_any(array, search_values)
[1, 2, 3] [4, 1] prawda
[1, 2, 3] [4, 5] fałsz
[1, 2, null] [wartość nieokreślona] prawda
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(
    field("genre")
      .arrayContainsAny([constant("fantasy"), constant("nonfiction")])
      .as("isMysteryOrFantasy")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("genre")
      .arrayContainsAny([constant("fantasy"), constant("nonfiction")])
      .as("isMysteryOrFantasy")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("genre")
      .arrayContainsAny([Constant("fantasy"), Constant("nonfiction")])
      .as("isMysteryOrFantasy")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        field("genre")
            .arrayContainsAny(listOf("fantasy", "nonfiction"))
            .alias("isMysteryOrFantasy")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("genre")
            .arrayContainsAny(Arrays.asList("fantasy", "nonfiction"))
            .alias("isMysteryOrFantasy")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("genre")
        .array_contains_any(["fantasy", "nonfiction"])
        .as_("isMysteryOrFantasy")
    )
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            arrayContainsAny(field("genre"), Arrays.asList("fantasy", "nonfiction"))
                .as("isMysteryOrFantasy"))
        .execute()
        .get();
PipelineSnippets.java

ARRAY_FILTER

Składnia:

array_filter(array: ARRAY, predicate: (ANY) -> BOOLEAN) -> ARRAY

Opis:

Filtruje array za pomocą wyrażenia predicate i zwraca nową tablicę zawierającą tylko elementy spełniające predykat.

  • Dla każdego elementu w array obliczana jest wartość predicate. Jeśli zwróci wartość true, element zostanie uwzględniony w wyniku. W przeciwnym razie (jeśli zwróci wartość false lub null) zostanie pominięty.
  • Jeśli predicate zwraca wartość nieboolowską lub niepustą, funkcja zwraca błąd.

Przykłady:

tablica orzeczenie, array_filter(array, predicate)
[1, 2, 3] x -> x > 1 [2, 3]
[1, null, 3] x -> x > 1 [3]
["a", "b", "c"] x -> x != "b" ["a", "c"]
[] x -> true []

ARRAY_GET

Składnia:

array_get(array: ARRAY, index: INT64) -> ANY

Opis:

Zwraca element na pozycji index (liczonej od zera) w array.

  • Jeśli index jest ujemne, elementy są dostępne od końca tablicy, gdzie -1 jest ostatnim elementem.
  • Jeśli argument array nie jest typu ARRAY ani nie jest wartością null, zwraca błąd.
  • Jeśli index jest poza zakresem, funkcja zwraca wartość pustą.
  • Jeśli argument index nie jest typu INT64, funkcja zwraca błąd.

Przykłady:

tablica indeks array_get(array, index)
[1, 2, 3] 0 1
[1, 2, 3] -1 3
[1, 2, 3] 3 nieobecny
[1, 2, 3] -4 nieobecny
„abc” 0 błąd
null 0 null
Array „a” błąd
Array 2,0 błąd

ARRAY_LENGTH

Składnia:

array_length(array: ARRAY) -> INT64

Opis:

Zwraca liczbę elementów w array.

Przykłady:

tablica array_length(array)
[1, 2, 3] 3
[] 0
[1, 1, 1] 3
[1, null] 2
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("genre").arrayLength().as("genreCount"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("genre").arrayLength().as("genreCount"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("genre").arrayLength().as("genreCount")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(field("genre").arrayLength().alias("genreCount"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("genre").arrayLength().alias("genreCount"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("genre").array_length().as_("genreCount"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(arrayLength(field("genre")).as("genreCount"))
        .execute()
        .get();
PipelineSnippets.java

ARRAY_REVERSE

Składnia:

array_reverse(array: ARRAY) -> ARRAY

Opis:

Odwraca podany array.

Przykłady:

tablica array_reverse(array)
[1, 2, 3] [3, 2, 1]
["a", "b"] ["b", "a"]
[1, 2, 2, 3] [3, 2, 2, 1]
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(arrayReverse(field("genre")).as("reversedGenres"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("genre").arrayReverse().as("reversedGenres"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("genre").arrayReverse().as("reversedGenres")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(field("genre").arrayReverse().alias("reversedGenres"))
    .execute()
DocSnippets.kt
 
    
Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("genre").arrayReverse().alias("reversedGenres"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("genre").array_reverse().as_("reversedGenres"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(arrayReverse(field("genre")).as("reversedGenres"))
        .execute()
        .get();
PipelineSnippets.java

ARRAY_FIRST

Składnia:

array_first(array: ARRAY) -> ANY

Opis:

Zwraca pierwszy element w array. Jest to odpowiednik array_get(array, 0).

  • Jeśli argument array jest pusty, zwraca wartość nieobecną.

Przykłady:

tablica array_first(array)
[1, 2, 3] 1
[] nieobecny

ARRAY_FIRST_N

Składnia:

array_first_n(array: ARRAY, n: INT64) -> ARRAY

Opis:

Zwraca pierwsze n elementów z array. Jest to odpowiednik array_slice(array, 0, n).

  • Jeśli argument n ma wartość ujemną, funkcja zwraca błąd.

Przykłady:

tablica n array_first_n(array, n)
[1, 2, 3, 4, 5] 3 [1, 2, 3]
[1, 2] 3 [1, 2]
[1, 2, 3] 0 []

ARRAY_INDEX_OF

Składnia:

array_index_of(array: ARRAY, value: ANY) -> INT64

Opis:

Zwraca indeks (liczony od zera) pierwszego wystąpienia znaku value w ciągu array. Zwraca wartość -1, jeśli nie znaleziono wartości value.

Przykłady:

tablica wartość array_index_of(array, value)
[1, 2, 3, 2] 2 1
[1, 2, 3] 4 -1
[1, null, 3] null 1

ARRAY_INDEX_OF_ALL

Składnia:

array_index_of_all(array: ARRAY, value: ANY) -> ARRAY<INT64>

Opis:

Zwraca tablicę zawierającą indeksy wszystkich wystąpień value w ciągu array (indeksowanie od zera). Zwraca wartość [], jeśli nie znaleziono wartości value.

Przykłady:

tablica wartość array_index_of_all(array, value)
[1, 2, 3, 2] 2 [1, 3]
[1, 2, 3] 4 []
[1, null, 3, null] null [1, 3]

ARRAY_LAST

Składnia:

array_last(array: ARRAY) -> ANY

Opis:

Zwraca ostatni element w array. Jest to odpowiednik array_get(array, -1).

  • Jeśli argument array jest pusty, zwraca wartość nieobecną.

Przykłady:

tablica array_last(array)
[1, 2, 3] 3
[] nieobecny

ARRAY_LAST_N

Składnia:

array_last_n(array: ARRAY, n: INT64) -> ARRAY

Opis:

Zwraca ostatnie n elementów z array.

  • Jeśli argument n ma wartość ujemną, funkcja zwraca błąd.

Przykłady:

tablica n array_last_n(array, n)
[1, 2, 3, 4, 5] 3 [3, 4, 5]
[1, 2] 3 [1, 2]
[1, 2, 3] 0 []

ARRAY_SLICE

Składnia:

array_slice(array: ARRAY, offset: INT64, length: INT64) -> ARRAY

Opis:

Zwraca podzbiór array zaczynający się od indeksu offset (liczonego od zera) i zawierający length elementów.

  • Jeśli wartość offset jest ujemna, oznacza to pozycję początkową od końca tablicy, przy czym -1 jest ostatnim elementem.
  • Jeśli length jest większa niż liczba elementów pozostałych w tablicy po offset, wynik rozciąga się do końca tablicy.
  • length musi być nieujemna, w przeciwnym razie funkcja zwraca błąd.

Przykłady:

tablica odliczyć długość array_slice(array, offset, length)
[1, 2, 3, 4, 5] 1 3 [2, 3, 4]
[1, 2, 3, 4, 5] -2 2 [4, 5]
[1, 2, 3] 1 5 [2, 3]
[1, 2, 3] 3 2 []

ARRAY_TRANSFORM

Składnia:

array_transform(array: ARRAY, expression: (ANY) -> ANY) -> ARRAY
array_transform(array: ARRAY, expression: (ANY, INT64) -> ANY) -> ARRAY

Opis:

Przekształca array, stosując expression do każdego elementu, i zwraca nową tablicę z przekształconymi elementami. Tablica wyjściowa zawsze będzie miała taki sam rozmiar jak tablica wejściowa.

  • expression może być funkcją jednoargumentową element -> result lub funkcją dwuargumentową (element, index) -> result.
  • Jeśli funkcja expression jest jednoargumentowa, jest wywoływana z każdym elementem funkcji array.
  • Jeśli expression jest funkcją binarną, jest wywoływana z każdym elementem array i odpowiadającym mu indeksem liczonym od zera.

Przykłady:

tablica wyrażenie array_transform(array, expression)
[1, 2, 3] x -> x * 2 [2, 4, 6]
[1, 2, 3] x -> x + 1 [2, 3, 4]
[10, 20] (x, i) -> x + i [10, 21]
[] x -> 1 []

MAKSYMALNA

Składnia:

maximum(array: ARRAY) -> ANY

Opis:

Zwraca maksymalną wartość w array.

  • Wartości NULL są ignorowane podczas porównywania.
  • Jeśli array jest pusta lub zawiera tylko wartości NULL, zwraca NULL.

Przykłady:

tablica maximum(array)
[1, 5, 2] 5
[1, null, 5] 5
["a", "c", "b"] „c”
[null, null] null
[] null

MAXIMUM_N

Składnia:

maximum_n(array: ARRAY, n: INT64) -> ARRAY

Opis:

Zwraca tablicę n największych wartości w array w kolejności malejącej.

  • Wartości NULL są ignorowane.
  • Jeśli argument n ma wartość ujemną, funkcja zwraca błąd.

Przykłady:

tablica n maximum_n(array, n)
[1, 5, 2, 4, 3] 3 [5, 4, 3]
[1, null, 5] 3 [5, 1]

MINIMUM

Składnia:

minimum(array: ARRAY) -> ANY

Opis:

Zwraca minimalną wartość w kolumnie array.

  • Wartości NULL są ignorowane podczas porównywania.
  • Jeśli array jest pusta lub zawiera tylko wartości NULL, zwraca NULL.

Przykłady:

tablica minimum(array)
[1, 5, 2] 1
[5, null, 1] 1
["a", "c", "b"] „a”
[null, null] null
[] null

MINIMUM_N

Składnia:

minimum_n(array: ARRAY, n: INT64) -> ARRAY

Opis:

Zwraca tablicę n najmniejszych wartości w zakresie array w kolejności rosnącej.

  • Wartości NULL są ignorowane.
  • Jeśli argument n ma wartość ujemną, funkcja zwraca błąd.

Przykłady:

tablica n minimum_n(array, n)
[1, 5, 2, 4, 3] 3 [1, 2, 3]
[5, null, 1] 3 [1, 5]

SUMA

Składnia:

sum(array: ARRAY) -> INT64 | FLOAT64

Opis:

Zwraca sumę wszystkich wartości NUMERIC w ARRAY.

  • Wartości nienumeryczne w tablicy są ignorowane.
  • Jeśli jakakolwiek wartość liczbowa w tablicy to NaN, funkcja zwraca NaN.
  • Typ zwracany jest określany przez najszerszy typ liczbowy w tablicy: INT64 < FLOAT64.
  • Jeśli przed zsumowaniem jakiejkolwiek wartości zmiennoprzecinkowej wystąpi przepełnienie 64-bitowej liczby całkowitej, zwracany jest błąd. Jeśli zsumowane zostaną wartości zmiennoprzecinkowe, przepełnienie spowoduje uzyskanie wartości +/- nieskończoność.
  • Jeśli tablica nie zawiera żadnych wartości liczbowych, funkcja zwraca NULL.

Przykłady:

tablica sum(array)
[1, 2, 3] 6L
[1L, 2L, 3L] 6L
[2000000000, 2000000000] 4000000000L
[10, 20.5] 30,5
[1, "a", 2] 3L
[INT64.MAX_VALUE, 1] błąd
[INT64.MAX_VALUE, 1, -1.0] błąd
[INT64.MAX_VALUE, 1.0] 9,223372036854776e+18

Join

Składnia:

join[T <: STRING | BYTES](array: ARRAY<T>, delimiter: T) -> STRING
join[T <: STRING | BYTES](array: ARRAY<T>, delimiter: T, null_text: T) -> STRING

Opis:

Zwraca połączenie elementów w array jako STRING. Wartość array może być typu STRING lub BYTES.

  • Wszystkie elementy w array, delimiter i null_text muszą być tego samego typu. Muszą to być elementy STRING lub BYTES.
  • Jeśli podano parametr null_text, wszystkie wartości NULL w parametrze array zostaną zastąpione wartością null_text.
  • Jeśli nie podano właściwości null_text, wartości NULL w array są pomijane w wyniku.

Przykłady:

Gdy nie podano wartości null_text:

tablica separator join(array, delimiter)
["a", "b", "c"] „,” "a,b,c"
["a", null, "c"] „,” "a,c"
[b'a', b'b', b'c'] b',' b'a,b,c'
["a", b'c'] „,” błąd
["a", "c"] b',' błąd
[b'a', b'c'] „,” błąd

Gdy podano wartość null_text:

tablica separator null_text join(array, delimiter, null_text)
["a", null, "c"] „,” „MISSING” „a,MISSING,c”
[b'a', null, b'c'] b',' b'NULL' b'a,NULL,c'
[null, "b", null] „,” „MISSING” „MISSING,b,MISSING”
[b'a', null, null] b',' b'NULL' b'a,NULL,NULL'
["a", null] „,” b'N' błąd
[b'a', null] b',' „N” błąd

Funkcje porównania

Nazwa Opis
EQUAL Porównanie równości
GREATER_THAN Porównanie „większe niż”
GREATER_THAN_OR_EQUAL Porównanie „większe lub równe”
LESS_THAN Porównanie „mniejsze niż”
LESS_THAN_OR_EQUAL Porównanie „mniejsze lub równe”
NOT_EQUAL Porównanie „nie równa się”
CMP Ogólne porównanie

EQUAL

Składnia:

equal(x: ANY, y: ANY) -> BOOLEAN

Przykłady:

x y equal(x, y)
1L 1L TRUE
1,0 1L TRUE
-1,0 1L FALSE
NaN NaN TRUE
NULL NULL TRUE
NULL ABSENT FALSE

Opis:

Zwraca TRUE, jeśli x i y są równe, a w przeciwnym razie zwraca FALSE.

Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("rating").equal(5).as("hasPerfectRating"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("rating").equal(5).as("hasPerfectRating"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("rating").equal(5).as("hasPerfectRating")])
  .execute()
PipelineSnippets.swift

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("rating").equal(5).alias("hasPerfectRating"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("rating").equal(5).as_("hasPerfectRating"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(equal(field("rating"), 5).as("hasPerfectRating"))
        .execute()
        .get();
PipelineSnippets.java

GREATER_THAN

Składnia:

greater_than(x: ANY, y: ANY) -> BOOLEAN

Opis:

Zwraca wartość TRUE, jeśli wartość x jest większa niż y, a w przeciwnym razie zwraca wartość FALSE.

Jeśli wartości x i y nie są porównywalne, zwraca wartość FALSE.

Przykłady:

x y greater_than(x, y)
1L 0,0 TRUE
1L 1L FALSE
1L 2L FALSE
„foo” 0L FALSE
0L „foo” FALSE
NaN 0L FALSE
0L NaN FALSE
NULL NULL FALSE
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("rating").greaterThan(4).as("hasHighRating"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("rating").greaterThan(4).as("hasHighRating"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("rating").greaterThan(4).as("hasHighRating")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(field("rating").greaterThan(4).alias("hasHighRating"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("rating").greaterThan(4).alias("hasHighRating"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("rating").greater_than(4).as_("hasHighRating"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(greaterThan(field("rating"), 4).as("hasHighRating"))
        .execute()
        .get();
PipelineSnippets.java

GREATER_THAN_OR_EQUAL

Składnia:

greater_than_or_equal(x: ANY, y: ANY) -> BOOLEAN

Opis:

Zwraca TRUE, jeśli x jest większe lub równe y, a w przeciwnym razie zwraca FALSE.

Jeśli wartości x i y nie są porównywalne, zwraca wartość FALSE.

Przykłady:

x y greater_than_or_equal(x, y)
1L 0,0 TRUE
1L 1L TRUE
1L 2L FALSE
„foo” 0L FALSE
0L „foo” FALSE
NaN 0L FALSE
0L NaN FALSE
NULL NULL TRUE
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("published").greaterThanOrEqual(1900).as("publishedIn20thCentury"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("published").greaterThanOrEqual(1900).as("publishedIn20thCentury"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("published").greaterThanOrEqual(1900).as("publishedIn20thCentury")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(field("published").greaterThanOrEqual(1900).alias("publishedIn20thCentury"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("published").greaterThanOrEqual(1900).alias("publishedIn20thCentury"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("published")
        .greater_than_or_equal(1900)
        .as_("publishedIn20thCentury")
    )
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(greaterThanOrEqual(field("published"), 1900).as("publishedIn20thCentury"))
        .execute()
        .get();
PipelineSnippets.java

MNIEJ_NIŻ

Składnia:

less_than(x: ANY, y: ANY) -> BOOLEAN

Opis:

Zwraca TRUE, jeśli x jest mniejsze niż y, a w przeciwnym razie zwraca FALSE.

Jeśli wartości x i y nie są porównywalne, zwraca wartość FALSE.

Przykłady:

x y less_than(x, y)
1L 0,0 FALSE
1L 1L FALSE
1L 2L TRUE
„foo” 0L FALSE
0L „foo” FALSE
NaN 0L FALSE
0L NaN FALSE
NULL NULL FALSE
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("published").lessThan(1923).as("isPublicDomainProbably"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("published").lessThan(1923).as("isPublicDomainProbably"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("published").lessThan(1923).as("isPublicDomainProbably")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(field("published").lessThan(1923).alias("isPublicDomainProbably"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("published").lessThan(1923).alias("isPublicDomainProbably"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("published").less_than(1923).as_("isPublicDomainProbably"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(lessThan(field("published"), 1923).as("isPublicDomainProbably"))
        .execute()
        .get();
PipelineSnippets.java

LESS_THAN_OR_EQUAL

Składnia:

less_than_or_equal(x: ANY, y: ANY) -> BOOLEAN

Opis:

Zwraca TRUE, jeśli x jest mniejsze lub równe y, a w przeciwnym razie zwraca FALSE.

Jeśli wartości x i y nie są porównywalne, zwraca wartość FALSE.

Przykłady:

x y less_than(x, y)
1L 0,0 FALSE
1L 1L TRUE
1L 2L TRUE
„foo” 0L FALSE
0L „foo” FALSE
NaN 0L FALSE
0L NaN FALSE
NULL NULL TRUE
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("rating").lessThanOrEqual(2).as("hasBadRating"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("rating").lessThanOrEqual(2).as("hasBadRating"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("rating").lessThanOrEqual(2).as("hasBadRating")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(field("rating").lessThanOrEqual(2).alias("hasBadRating"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("rating").lessThanOrEqual(2).alias("hasBadRating"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("rating").less_than_or_equal(2).as_("hasBadRating"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(lessThanOrEqual(field("rating"), 2).as("hasBadRating"))
        .execute()
        .get();
PipelineSnippets.java

NOT_EQUAL

Składnia:

not_equal(x: ANY, y: ANY) -> BOOLEAN

Opis:

Zwraca TRUE, jeśli x jest różne od y, a w przeciwnym razie zwraca FALSE.

Przykłady:

x y not_equal(x, y)
1L 1L FALSE
1,0 1L FALSE
-1,0 1L TRUE
NaN 0L TRUE
NaN NaN FALSE
NULL NULL FALSE
NULL ABSENT TRUE
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("title").notEqual("1984").as("not1984"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("title").notEqual("1984").as("not1984"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("title").notEqual("1984").as("not1984")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(field("title").notEqual("1984").alias("not1984"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("title").notEqual("1984").alias("not1984"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("title").not_equal("1984").as_("not1984"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(notEqual(field("title"), "1984").as("not1984"))
        .execute()
        .get();
PipelineSnippets.java

PC

Składnia:

cmp(x: ANY, y: ANY) -> Int64

Opis:

Porównuje dokumenty x i y i zwraca:

  • 1L, jeśli x jest większe niż y.
  • -1L, jeśli x jest mniejsze niż y.
  • 0L w przeciwnym razie.

W przeciwieństwie do innych funkcji porównania funkcja cmp(...) działa w różnych typach, zgodnie z tym samym porządkiem, który jest używany na etapie sort(...). Informacje o kolejności wartości w poszczególnych typach znajdziesz w sekcji Kolejność typów wartości.

Przykłady:

x y cmp(x, y)
1L 1L 0L
1,0 1L 0L
-1,0 1L -1L
42.5D „foo” -1L
NULL NULL 0L
NULL ABSENT 0L

Funkcje debugowania

Nazwa Opis
EXISTS Zwraca TRUE, jeśli wartość nie jest wartością pustą.
IS_ABSENT Zwraca TRUE, jeśli wartość jest nieobecna.
IF_ABSENT Zastępuje wartość wyrażeniem, jeśli jest ona nieobecna.
IS_ERROR Wyłapuje i sprawdza, czy wyrażenie bazowe zgłosiło błąd.
IF_ERROR Zastępuje wartość wyrażeniem, jeśli wystąpił błąd.
ERROR Kończy ocenę i zwraca błąd z określonym komunikatem.

ISTNIEJE

Składnia:

exists(value: ANY) -> BOOLEAN

Opis:

Zwraca TRUE, jeśli value nie jest wartością nieobecną.

Przykłady:

value exists(value)
0L TRUE
„foo” TRUE
NULL TRUE
ABSENT FALSE
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("rating").exists().as("hasRating"))
  .execute();
test.firestore.js

Web

Przykład:

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("rating").exists().as("hasRating"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("rating").exists().as("hasRating")])
  .execute()
PipelineSnippets.swift

Kotlin

Przykład:

val result = db.pipeline()
    .collection("books")
    .select(field("rating").exists().alias("hasRating"))
    .execute()
DocSnippets.kt

Java

Przykład:

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("rating").exists().alias("hasRating"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("rating").exists().as_("hasRating"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(exists(field("rating")).as("hasRating"))
        .execute()
        .get();
PipelineSnippets.java

IS_ABSENT

Składnia:

is_absent(value: ANY) -> BOOLEAN

Opis:

Zwraca TRUE, jeśli value jest wartością nieobecną, a w przeciwnym razie zwraca FALSE. Wartości nieobecne to wartości, których brakuje w danych wejściowych, np. brakujące pole dokumentu.

Przykłady:

value is_absent(value)
0L FALSE
„foo” FALSE
NULL FALSE
ABSENT TRUE

IF_ABSENT

Składnia:

if_absent(value: ANY, replacement: ANY) -> ANY

Opis:

Jeśli value jest wartością nieobecną, funkcja ocenia i zwraca wartość replacement. W przeciwnym razie zwraca wartość value.

Przykłady:

value replacement if_absent(value, replacement)
5L 0L 5L
NULL 0L NULL
ABSENT 0L 0L

IS_ERROR

Składnia:

is_error(try: ANY) -> BOOLEAN

Opis:

Zwraca TRUE, jeśli podczas oceny elementu try wystąpi błąd. W przeciwnym razie zwraca wartość FALSE.

IF_ERROR

Składnia:

if_error(try: ANY, catch: ANY) -> ANY

Opis:

Jeśli podczas oceny wyrażenia try wystąpi błąd, funkcja ocenia i zwraca wyrażenie replacement. W przeciwnym razie zwraca rozwiązaną wartość elementu try.

BŁĄD

Składnia:

error(message: STRING) -> ANY

Opis:

Obliczenie funkcji error powoduje zakończenie potoku z błędem. Podany message jest uwzględniony w błędzie.

Przykłady:

cond res switch_on(cond, res, error("no condition matched"))
TRUE 1L 1L
FALSE 1L ERROR ("no condition matched")

Funkcje odwołania

Typ REFERENCE działa jako „wskaźnik” do innych dokumentów w bazie danych (lub nawet w innych bazach danych). Te funkcje umożliwiają manipulowanie tym typem podczas wykonywania zapytania.

Nazwa Opis
COLLECTION_ID Zwraca identyfikator kolekcji końcowej w podanym odwołaniu.
DOCUMENT_ID Zwraca identyfikator dokumentu w danym odwołaniu.
PARENT Zwraca odwołanie do elementu nadrzędnego
REFERENCE_SLICE Zwraca podzbiór segmentów z podanego odniesienia.

COLLECTION_ID

Składnia:

collection_id(ref: REFERENCE) -> STRING

Opis:

Zwraca identyfikator kolekcji liści podanego elementu REFERENCE.

Przykłady:

ref collection_id(ref)
users/user1 "users"
users/user1/posts/post1 "posts"

DOCUMENT_ID

Składnia:

document_id(ref: REFERENCE) -> ANY

Opis:

Zwraca identyfikator dokumentu podanego REFERENCE.

Przykłady:

ref document_id(ref)
users/user1 "user1"
users/user1/posts/post1 "post1"

PARENT

Składnia:

parent(ref: REFERENCE) -> REFERENCE

Opis:

Zwraca element nadrzędny REFERENCE danego odwołania lub NULL, jeśli odwołanie jest już odwołaniem głównym.

Przykłady:

ref parent(ref)
/ NULL
users/user1 /
users/user1/posts/post1 users/user1

REFERENCE_SLICE

Składnia:

reference_slice(ref: REFERENCE, offset: INT, length: INT) -> REFERENCE

Opis:

REFERENCE to lista (collection_id, document_id) krotek, która umożliwia wyświetlanie tej listy, podobnie jak array_slice(...).

Zwraca nowy obiekt REFERENCE, który jest podzbiorem segmentów danego obiektu ref.

  • offset: indeks początkowy (od 0) wycinka. Jeśli jest ujemna, jest to przesunięcie od końca odniesienia.
  • length: liczba segmentów do uwzględnienia w wycinku.

Przykłady:

ref offset length reference_slice(ref, offset, length)
a/1/b/2/c/3 1L 2L b/2/c/3
a/1/b/2/c/3 0L 2L a/1/b/2
a/1/b/2/c/3 -2L 2L c/3

Funkcje logiczne

Nazwa Opis
AND Wykonuje operację logiczną AND
OR Wykonuje operację logiczną LUB
XOR Wykonuje logiczną operację XOR
NOT Wykonuje operację logiczną NOT
NOR Wykonuje logiczną operację NOR
CONDITIONAL Ocena gałęzi na podstawie wyrażenia warunkowego.
IF_NULL Zwraca pierwszą wartość inną niż null
SWITCH_ON Ocena gałęzi na podstawie serii warunków
EQUAL_ANY Sprawdza, czy wartość jest równa któremukolwiek elementowi w tablicy.
NOT_EQUAL_ANY Sprawdza, czy wartość nie jest równa żadnemu elementowi w tablicy.
MAXIMUM Zwraca maksymalną wartość w zbiorze wartości.
MINIMUM Zwraca minimalną wartość w zbiorze wartości.

ORAZ

Składnia:

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

Opis:

Zwraca logiczną sumę iloczynów co najmniej 2 wartości logicznych.

Zwraca NULL, jeśli nie można uzyskać wyniku, ponieważ któraś z podanych wartości to ABSENT lub NULL.

Przykłady:

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

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
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            and(greaterThan(field("rating"), 4), lessThan(field("price"), 10))
                .as("under10Recommendation"))
        .execute()
        .get();
PipelineSnippets.java

LUB

Składnia:

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

Opis:

Zwraca logiczną sumę co najmniej 2 wartości logicznych.

Zwraca NULL, jeśli nie można uzyskać wyniku, ponieważ któraś z podanych wartości to ABSENT lub NULL.

Przykłady:

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

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
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            or(equal(field("genre"), "Fantasy"), arrayContains(field("tags"), "adventure"))
                .as("matchesSearchFilters"))
        .execute()
        .get();
PipelineSnippets.java

XOR

Składnia:

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

Opis:

Zwraca logiczną operację XOR dwóch lub większej liczby wartości logicznych.

Zwraca wartość NULL, jeśli któraś z podanych wartości to ABSENT lub NULL.

Przykłady:

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
Node.js
const result = await execute(db.pipeline()
  .collection("books")
  .select(
    xor(field("tags").arrayContains("magic"), field("tags").arrayContains("nonfiction"))
      .as("matchesSearchFilters")
  )
);
test.firestore.js

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
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            xor(
                    arrayContains(field("tags"), "magic"),
                    arrayContains(field("tags"), "nonfiction"))
                .as("matchesSearchFilters"))
        .execute()
        .get();
PipelineSnippets.java

NOR

Składnia:

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

Opis:

Zwraca logiczną operację NOR dla co najmniej 2 wartości logicznych.

Zwraca NULL, jeśli nie można uzyskać wyniku, ponieważ któraś z podanych wartości to ABSENT lub NULL.

Przykłady:

x y nor(x, y)
TRUE TRUE FALSE
FALSE TRUE FALSE
FALSE FALSE TRUE
NULL TRUE FALSE
ABSENT TRUE FALSE
NULL FALSE NULL
FALSE ABSENT NULL

NOT

Składnia:

not(x: BOOLEAN) -> BOOLEAN

Opis:

Zwraca logiczną wartość przeciwną do wartości logicznej.

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

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
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(not(arrayContains(field("tags"), "nonfiction")).as("isFiction"))
        .execute()
        .get();
PipelineSnippets.java

WARUNKOWE

Składnia:

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

Opis:

Oblicza i zwraca wartość true_case, jeśli condition ma wartość TRUE.

Analizuje i zwraca wartość false_case, jeśli warunek przyjmuje wartość FALSE, NULL lub ABSENT.

Przykłady:

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
Node.js
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

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
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            arrayConcat(
                    field("tags"),
                    conditional(
                        greaterThan(field("pages"), 100),
                        constant("longRead"),
                        constant("shortRead")))
                .as("extendedTags"))
        .execute()
        .get();
PipelineSnippets.java

IF_NULL

Składnia:

if_null(expr: ANY, replacement: ANY) -> ANY

Opis:

Zwraca expr, jeśli nie jest to NULL. W przeciwnym razie oblicza i zwraca replacement. Wyrażenie replacement nie jest obliczane, jeśli używane jest wyrażenie expr.

Przykłady:

expr replacement if_null(expr, replacement)
1L 2L 1L
NULL 2L 2L
ABSENT 2L ABSENT

SWITCH_ON

Składnia:

switch_on(cond1: BOOLEAN, res1: ANY, cond2: BOOLEAN, res2: ANY, ..., [default: ANY]) -> ANY

Opis:

Sprawdza serię warunków i zwraca wynik powiązany z pierwszym warunkiem TRUE. Jeśli żaden warunek nie przyjmuje wartości TRUE, zwracana jest wartość default, o ile została podana. Jeśli nie podano wartości default, a żaden inny warunek nie zwrócił wartości TRUE, zostanie zgłoszony błąd.

Aby podać wartość default, przekaż ją jako ostatni argument, tak aby liczba argumentów była nieparzysta.

Przykłady:

x switch_on(eq(x, 1L), "one", eq(x, 2L), "two", "other")
1L „one”
2L „dwa”
3L „inne”

EQUAL_ANY

Składnia:

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

Opis:

Zwraca TRUE, jeśli value znajduje się w tablicy search_space.

Przykłady:

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
Node.js
const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("genre").equalAny(["Science Fiction", "Psychological Thriller"])
      .as("matchesGenreFilters")
  )
);
test.firestore.js

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
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            equalAny(field("genre"), Arrays.asList("Science Fiction", "Psychological Thriller"))
                .as("matchesGenreFilters"))
        .execute()
        .get();
PipelineSnippets.java

NOT_EQUAL_ANY

Składnia:

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

Opis:

Zwraca wartość TRUE, jeśli value nie występuje w tablicy search_space.

Przykłady:

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
Node.js
const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("author").notEqualAny(["George Orwell", "F. Scott Fitzgerald"])
      .as("byExcludedAuthors")
  )
);
test.firestore.js

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
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            notEqualAny(field("author"), Arrays.asList("George Orwell", "F. Scott Fitzgerald"))
                .as("byExcludedAuthors"))
        .execute()
        .get();
PipelineSnippets.java

MAKSYMALNA

Składnia:

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

Opis:

Zwraca maksymalną wartość inną niż NULL i ABSENT w serii wartości x.

Jeśli nie ma wartości innych niż NULL i ABSENT, zwracana jest wartość NULL.

Jeśli istnieje kilka maksymalnych wartości równoważnych, można zwrócić dowolną z nich. Kolejność typów wartości jest zgodna z udokumentowaną kolejnością.

Przykłady:

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
Node.js
const result = await execute(db.pipeline()
  .collection("books")
  .aggregate(field("price").maximum().as("maximumPrice"))
);
test.firestore.js

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
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(logicalMaximum(field("rating"), 1).as("flooredRating"))
        .execute()
        .get();
PipelineSnippets.java

MINIMUM

Składnia:

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

Opis:

Zwraca minimalną wartość inną niż NULL i ABSENT w serii wartości x.

Jeśli nie ma wartości innych niż NULL i ABSENT, zwracana jest wartość NULL.

Jeśli istnieje kilka minimalnych wartości równoważnych, można zwrócić dowolną z nich. Kolejność typów wartości jest zgodna z udokumentowaną kolejnością.

Przykłady:

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
Node.js
const result = await execute(db.pipeline()
  .collection("books")
  .aggregate(field("price").minimum().as("minimumPrice"))
);
test.firestore.js

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
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(logicalMinimum(field("rating"), 5).as("cappedRating"))
        .execute()
        .get();
PipelineSnippets.java

Funkcje mapy

Nazwa Opis
MAP Tworzy wartość mapy z serii par klucz-wartość.
MAP_GET Zwraca wartość na mapie na podstawie określonego klucza.
MAP_SET Zwraca kopię mapy z serią zaktualizowanych kluczy.
MAP_REMOVE Zwraca kopię mapy z usuniętą serią kluczy.
MAP_MERGE Łączy serię map.
CURRENT_CONTEXT Zwraca bieżący kontekst jako mapę.
MAP_KEYS Zwraca tablicę wszystkich kluczy na mapie.
MAP_VALUES Zwraca tablicę wszystkich wartości w mapie.
MAP_ENTRIES Zwraca tablicę par klucz-wartość z mapy.

MAP

Składnia:

map(key: STRING, value: ANY, ...) -> MAP

Opis:

Tworzy mapę z serii par klucz-wartość.

MAP_GET

Składnia:

map_get(map: ANY, key: STRING) -> ANY

Opis:

Zwraca wartość w mapie na podstawie określonego klucza. Zwraca wartość ABSENT, jeśli element key nie istnieje na mapie lub jeśli argument map nie jest elementem MAP.

Node.js
const result = await db.pipeline()
  .collection("books")
  .select(
    field("awards").mapGet("pulitzer").as("hasPulitzerAward")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("awards").mapGet("pulitzer").as("hasPulitzerAward")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("awards").mapGet("pulitzer").as("hasPulitzerAward")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        field("awards").mapGet("pulitzer").alias("hasPulitzerAward")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("awards").mapGet("pulitzer").alias("hasPulitzerAward")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("awards").map_get("pulitzer").as_("hasPulitzerAward"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(mapGet(field("awards"), "pulitzer").as("hasPulitzerAward"))
        .execute()
        .get();
PipelineSnippets.java

MAP_SET

Składnia:

map_set(map: MAP, key: STRING, value: ANY, ...) -> MAP

Opis:

Zwraca kopię wartości map, której zawartość została zaktualizowana przez serię par klucz-wartość.

Jeśli podana wartość jest nieobecna, powiązany klucz zostanie usunięty z mapy.

Jeśli argument map nie jest wartością MAP, zwraca wartość pustą.

MAP_REMOVE

Składnia:

map_remove(map: MAP, key: STRING...) -> MAP

Opis:

Zwraca kopię wartości map z usuniętymi kluczami.

MAP_MERGE

Składnia:

map_merge(maps: MAP...) -> MAP

Scala zawartość co najmniej 2 map. Jeśli kilka map ma sprzeczne wartości, używana jest ostatnia wartość.

CURRENT_CONTEXT

Składnia:

current_context() -> MAP

Zwraca mapę zawierającą wszystkie dostępne pola w bieżącym punkcie wykonania.

MAP_KEYS

Składnia:

map_keys(map: MAP) -> ARRAY<STRING>

Opis:

Zwraca tablicę zawierającą wszystkie klucze wartości map.

MAP_VALUES

Składnia:

map_values(map: MAP) -> ARRAY<ANY>

Opis:

Zwraca tablicę zawierającą wszystkie wartości map.

MAP_ENTRIES

Składnia:

map_entries(map: MAP) -> ARRAY<MAP>

Opis:

Zwraca tablicę zawierającą wszystkie pary klucz-wartość w map.

Każda para klucz-wartość będzie miała postać mapy z 2 wpisami: k i v.

Przykłady:

map map_entries(map)
{} []
{"foo" : 2L} [{"k": "foo", "v" : 2L}]
{"foo" : "bar", "bar" : "foo"} [{"k": "foo", "v" : "bar" }, {"k" : "bar", "v": "foo"}]

Funkcje ciągów znaków

Nazwa Opis
BYTE_LENGTH Zwraca liczbę BYTES w wartości STRING lub BYTES.
CHAR_LENGTH Zwraca liczbę znaków Unicode w STRINGwartości.
STARTS_WITH Zwraca wartość TRUE, jeśli STRING zaczyna się od danego prefiksu.
ENDS_WITH Zwraca TRUE, jeśli STRING kończy się danym przyrostkiem.
LIKE Zwraca TRUE, jeśli STRING pasuje do wzorca
REGEX_CONTAINS Zwraca TRUE, jeśli wartość jest częściowo lub w pełni zgodna z wyrażeniem regularnym.
REGEX_MATCH Zwraca TRUE, jeśli jakakolwiek część wartości pasuje do wyrażenia regularnego.
STRING_CONCAT Łączy wiele STRING w STRING
STRING_CONTAINS Zwraca wartość TRUE, jeśli wartość zawiera znak STRING
STRING_INDEX_OF Zwraca indeks pierwszego wystąpienia wartości STRING lub BYTES (liczony od zera).
TO_UPPER Przekształca wartość STRING lub BYTES na wielkie litery.
TO_LOWER Konwertuje wartość STRING lub BYTES na małe litery.
SUBSTRING Pobiera podciąg wartości STRING lub BYTES.
STRING_REVERSE Odwraca wartość STRING lub BYTES.
STRING_REPEAT Powtarza wartość STRING lub BYTES określoną liczbę razy.
STRING_REPLACE_ALL Zastępuje wszystkie wystąpienia wartości STRING lub BYTES.
STRING_REPLACE_ONE Zastępuje pierwsze wystąpienie wartości STRING lub BYTES.
TRIM Usuwa znaki z początku i końca wartości STRING lub BYTES.
LTRIM Usuwa znaki z początku wartości STRING lub BYTES.
RTRIM Usuwa końcowe znaki z wartości STRING lub BYTES.
SPLIT Dzieli wartość STRING lub BYTES na tablicę.

BYTE_LENGTH

Składnia:

byte_length[T <: STRING | BYTES](value: T) -> INT64

Opis:

Zwraca liczbę znaków BYTES w wartości STRING lub BYTES.

Przykłady:

wartość byte_length(value)
„abc” 3
„xyzabc” 6
b"abc" 3
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(
    field("title").byteLength().as("titleByteLength")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("title").byteLength().as("titleByteLength")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("title").byteLength().as("titleByteLength")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        field("title").byteLength().alias("titleByteLength")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("title").byteLength().alias("titleByteLength")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("title").byte_length().as_("titleByteLength"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(byteLength(field("title")).as("titleByteLength"))
        .execute()
        .get();
PipelineSnippets.java

CHAR_LENGTH

Składnia:

char_length(value: STRING) -> INT64

Opis:

Zwraca liczbę punktów kodowych Unicode w STRING.

Przykłady:

wartość char_length(value)
„abc” 3
„Witaj” 5
„świat” 5
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(
    field("title").charLength().as("titleCharLength")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("title").charLength().as("titleCharLength")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("title").charLength().as("titleCharLength")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        field("title").charLength().alias("titleCharLength")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("title").charLength().alias("titleCharLength")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("title").char_length().as_("titleCharLength"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(charLength(field("title")).as("titleCharLength"))
        .execute()
        .get();
PipelineSnippets.java

STARTS_WITH

Składnia:

starts_with(value: STRING, prefix: STRING) -> BOOLEAN

Opis:

Zwraca wartość TRUE, jeśli value zaczyna się od prefix.

Przykłady:

wartość prefiks starts_with(value, prefix)
„abc” „a” prawda
„abc” „b” fałsz
„abc” "" prawda
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(
    field("title").startsWith("The")
      .as("needsSpecialAlphabeticalSort")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("title").startsWith("The")
      .as("needsSpecialAlphabeticalSort")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("title").startsWith("The")
      .as("needsSpecialAlphabeticalSort")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        field("title").startsWith("The")
            .alias("needsSpecialAlphabeticalSort")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("title").startsWith("The")
            .alias("needsSpecialAlphabeticalSort")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("title").starts_with("The").as_("needsSpecialAlphabeticalSort")
    )
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(startsWith(field("title"), "The").as("needsSpecialAlphabeticalSort"))
        .execute()
        .get();
PipelineSnippets.java

ENDS_WITH

Składnia:

ends_with(value: STRING, postfix: STRING) -> BOOLEAN

Opis:

Zwraca wartość TRUE, jeśli ciąg value kończy się ciągiem postfix.

Przykłady:

wartość przyrostek, ends_with(value, postfix)
„abc” „c” prawda
„abc” „b” fałsz
„abc” "" prawda
Node.js
const result = await db.pipeline()
  .collection("inventory/devices/laptops")
  .select(
    field("name").endsWith("16 inch")
      .as("16InLaptops")
  )
  .execute();
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("inventory/devices/laptops")
  .select([
    Field("name").endsWith("16 inch")
      .as("16InLaptops")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("inventory/devices/laptops")
    .select(
        field("name").endsWith("16 inch")
            .alias("16InLaptops")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("inventory/devices/laptops")
    .select(
        field("name").endsWith("16 inch")
            .alias("16InLaptops")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("inventory/devices/laptops")
    .select(Field.of("name").ends_with("16 inch").as_("16InLaptops"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("inventory/devices/laptops")
        .select(endsWith(field("name"), "16 inch").as("16InLaptops"))
        .execute()
        .get();
PipelineSnippets.java

PODOBA MI SIĘ

Składnia:

like(value: STRING, pattern: STRING) -> BOOLEAN

Opis:

Zwraca TRUE, jeśli value pasuje do pattern.

Przykłady:

wartość wzór like(value, pattern)
„Firestore” „Fire%” prawda
„Firestore” „%store” prawda
„Datastore” „Data_tore” prawda
„100%” „100%” prawda
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(
    field("genre").like("%Fiction")
      .as("anyFiction")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("genre").like("%Fiction")
      .as("anyFiction")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("genre").like("%Fiction")
      .as("anyFiction")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        field("genre").like("%Fiction")
            .alias("anyFiction")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("genre").like("%Fiction")
            .alias("anyFiction")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("genre").like("%Fiction").as_("anyFiction"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(like(field("genre"), "%Fiction").as("anyFiction"))
        .execute()
        .get();
PipelineSnippets.java

REGEX_CONTAINS

Składnia:

regex_contains(value: STRING, pattern: STRING) -> BOOLEAN

Opis:

Zwraca wartość TRUE, jeśli część ciągu value pasuje do wzorca pattern. Jeśli pattern nie jest prawidłowym wyrażeniem regularnym, funkcja zwraca wartość error.

Wyrażenia regularne są zgodne ze składnią biblioteki re2.

Przykłady:

wartość wzór regex_contains(value, pattern)
„Firestore” Ogień prawda
„Firestore” „store$” prawda
„Firestore” „dane” fałsz
Node.js
const result = await db.pipeline()
  .collection("documents")
  .select(
    field("title").regexContains("Firestore (Enterprise|Standard)")
      .as("isFirestoreRelated")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("documents")
  .select(
    field("title").regexContains("Firestore (Enterprise|Standard)")
      .as("isFirestoreRelated")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("documents")
  .select([
    Field("title").regexContains("Firestore (Enterprise|Standard)")
      .as("isFirestoreRelated")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("documents")
    .select(
        field("title").regexContains("Firestore (Enterprise|Standard)")
            .alias("isFirestoreRelated")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("title").regexContains("Firestore (Enterprise|Standard)")
            .alias("isFirestoreRelated")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("documents")
    .select(
        Field.of("title")
        .regex_contains("Firestore (Enterprise|Standard)")
        .as_("isFirestoreRelated")
    )
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(
            regexContains(field("title"), "Firestore (Enterprise|Standard)")
                .as("isFirestoreRelated"))
        .execute()
        .get();
PipelineSnippets.java

REGEX_MATCH

Składnia:

regex_match(value: STRING, pattern: STRING) -> BOOLEAN

Opis:

Zwraca wartość TRUE, jeśli value w pełni pasuje do pattern. Jeśli pattern nie jest prawidłowym wyrażeniem regularnym, funkcja zwraca wartość error.

Wyrażenia regularne są zgodne ze składnią biblioteki re2.

Przykłady:

wartość wzór regex_match(value, pattern)
„Firestore” „F.*store” prawda
„Firestore” Ogień fałsz
„Firestore” "^F.*e$" prawda
Node.js
const result = await db.pipeline()
  .collection("documents")
  .select(
    field("title").regexMatch("Firestore (Enterprise|Standard)")
      .as("isFirestoreExactly")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("documents")
  .select(
    field("title").regexMatch("Firestore (Enterprise|Standard)")
      .as("isFirestoreExactly")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("documents")
  .select([
    Field("title").regexMatch("Firestore (Enterprise|Standard)")
      .as("isFirestoreExactly")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("documents")
    .select(
        field("title").regexMatch("Firestore (Enterprise|Standard)")
            .alias("isFirestoreExactly")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("title").regexMatch("Firestore (Enterprise|Standard)")
            .alias("isFirestoreExactly")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("documents")
    .select(
        Field.of("title")
        .regex_match("Firestore (Enterprise|Standard)")
        .as_("isFirestoreExactly")
    )
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(
            regexMatch(field("title"), "Firestore (Enterprise|Standard)")
                .as("isFirestoreExactly"))
        .execute()
        .get();
PipelineSnippets.java

STRING_CONCAT

Składnia:

string_concat(values: STRING...) -> STRING

Opis:

Łączy co najmniej 2 wartości STRING w jeden wynik.

Przykłady:

argumenty string_concat(values...)
() błąd
("a") „a”
("abc", "def") „abcdef”
("a", "", "c") „ac”
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(
    field("title").stringConcat(" by ", field("author"))
      .as("fullyQualifiedTitle")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("title").stringConcat(" by ", field("author"))
      .as("fullyQualifiedTitle")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("title").concat([" by ", Field("author")])
      .as("fullyQualifiedTitle")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        field("title").concat(" by ", field("author"))
            .alias("fullyQualifiedTitle")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("title").concat(" by ", field("author"))
            .alias("fullyQualifiedTitle")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("title")
        .concat(" by ", Field.of("author"))
        .as_("fullyQualifiedTitle")
    )
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(stringConcat(field("title"), " by ", field("author")).as("fullyQualifiedTitle"))
        .execute()
        .get();
PipelineSnippets.java

STRING_CONTAINS

Składnia:

string_contains(value: STRING, substring: STRING) -> BOOLEAN

Opis:

Sprawdza, czy argument value zawiera ciąg tekstowy substring.

Przykłady:

wartość podłańcuch string_contains(value, substring)
„abc” „b” prawda
„abc” „d” fałsz
„abc” "" prawda
„a.c” "." prawda
„☃☃☃” „☃” prawda
Node.js
const result = await db.pipeline()
  .collection("articles")
  .select(
    field("body").stringContains("Firestore")
      .as("isFirestoreRelated")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("articles")
  .select(
    field("body").stringContains("Firestore")
      .as("isFirestoreRelated")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("articles")
  .select([
    Field("body").stringContains("Firestore")
      .as("isFirestoreRelated")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("articles")
    .select(
        field("body").stringContains("Firestore")
            .alias("isFirestoreRelated")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("articles")
    .select(
        field("body").stringContains("Firestore")
            .alias("isFirestoreRelated")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("articles")
    .select(Field.of("body").string_contains("Firestore").as_("isFirestoreRelated"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("articles")
        .select(stringContains(field("body"), "Firestore").as("isFirestoreRelated"))
        .execute()
        .get();
PipelineSnippets.java

STRING_INDEX_OF

Składnia:

string_index_of[T <: STRING | BYTES](value: T, search: T) -> INT64

Opis:

Zwraca indeks (liczony od zera) pierwszego wystąpienia znaku search w ciągu value.

  • Zwraca wartość -1, jeśli nie znaleziono wartości search.
  • Jeśli value jest wartością STRING, wynik jest mierzony w punktach kodowych Unicode. Jeśli jest to wartość BYTES, jest mierzona w bajtach.
  • Jeśli argument search jest pustą wartością STRING lub BYTES, wynikiem jest 0.

Przykłady:

wartość szukaj string_index_of(value, search)
„hello world” „o” 4
„hello world” „l” 2
„hello world” „z” -1
„banana” „na” 2
„abc” "" 0
b"abc" b"b" 1
"é" "é" 0
b"é" b"é" 0

TO_UPPER

Składnia:

to_upper[T <: STRING | BYTES](value: T) -> T

Opis:

Przekształca wartość STRING lub BYTES na wielkie litery.

Jeśli bajt lub znak nie odpowiada małej literze alfabetu UTF-8, jest przekazywany bez zmian.

Przykłady:

wartość to_upper(value)
„abc” „ABC”
„AbC” „ABC”
b"abc" b"ABC"
b"a1c" b"A1C"
Node.js
const result = await db.pipeline()
  .collection("authors")
  .select(
    field("name").toUpper()
      .as("uppercaseName")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("authors")
  .select(
    field("name").toUpper()
      .as("uppercaseName")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("authors")
  .select([
    Field("name").toUpper()
      .as("uppercaseName")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("authors")
    .select(
        field("name").toUpper()
            .alias("uppercaseName")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("authors")
    .select(
        field("name").toUpper()
            .alias("uppercaseName")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("authors")
    .select(Field.of("name").to_upper().as_("uppercaseName"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("authors")
        .select(toUpper(field("name")).as("uppercaseName"))
        .execute()
        .get();
PipelineSnippets.java

TO_LOWER

Składnia:

to_lower[T <: STRING | BYTES](value: T) -> T

Opis:

Konwertuje wartość STRING lub BYTES na małe litery.

Jeśli bajt lub znak nie odpowiada wielkiej literze alfabetu UTF-8, jest przekazywany bez zmian.

Przykłady:

wartość to_lower(value)
„ABC” „abc”
„AbC” „abc”
"A1C" "a1c"
b"ABC" b"abc"
Node.js
const result = await db.pipeline()
  .collection("authors")
  .select(
    field("genre").toLower().equal("fantasy")
      .as("isFantasy")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("authors")
  .select(
    field("genre").toLower().equal("fantasy")
      .as("isFantasy")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("authors")
  .select([
    Field("genre").toLower().equal("fantasy")
      .as("isFantasy")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("authors")
    .select(
        field("genre").toLower().equal("fantasy")
            .alias("isFantasy")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("authors")
    .select(
        field("genre").toLower().equal("fantasy")
            .alias("isFantasy")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("authors")
    .select(Field.of("genre").to_lower().equal("fantasy").as_("isFantasy"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("authors")
        .select(equal(toLower(field("genre")), "fantasy").as("isFantasy"))
        .execute()
        .get();
PipelineSnippets.java

SUBSTRING

Składnia:

substring[T <: STRING | BYTES](input: T, position: INT64) -> T
substring[T <: STRING | BYTES](input: T, position: INT64, length: INT64) -> T

Opis:

Zwraca podłańcuch ciągu input zaczynający się od pozycji position (indeks liczony od zera) i zawierający maksymalnie length elementów. Jeśli nie podano argumentu length, zwraca podciąg od position do końca argumentu input.

  • Jeśli input jest wartością STRING, position i length są mierzone w punktach kodowych Unicode. Jeśli jest to wartość BYTES, jest mierzona w bajtach.

  • Jeśli argument position jest większy niż długość argumentu input, zwracany jest pusty podciąg. Jeśli position + length jest większe niż długość input, podciąg jest obcinany do końca input.

  • Jeśli position jest ujemne, pozycja jest pobierana od końca danych wejściowych. Jeśli ujemna wartość position jest większa niż rozmiar danych wejściowych, pozycja jest ustawiana na zero. Wartość parametru length musi być nieujemna.

Przykłady:

Gdy nie podano wartości length:

wprowadzanie danych position substring(input, position)
„abc” 0 „abc”
„abc” 1 „bc”
„abc” 3 ""
„abc” -1 „c”
b"abc" 1 b"bc"

Gdy podano wartość length:

wprowadzanie danych position długość substring(input, position, length)
„abc” 0 1 „a”
„abc” 1 2 „bc”
„abc” -1 1 „c”
b"abc" 0 1 b"a"
Node.js
const result = await db.pipeline()
  .collection("books")
  .where(field("title").startsWith("The "))
  .select(
    field("title").substring(4)
      .as("titleWithoutLeadingThe")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .where(field("title").startsWith("The "))
  .select(
    field("title").substring(4)
      .as("titleWithoutLeadingThe")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .where(Field("title").startsWith("The "))
  .select([
    Field("title").substring(position: 4)
      .as("titleWithoutLeadingThe")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .where(field("title").startsWith("The "))
    .select(
        field("title")
          .substring(constant(4),
            field("title").charLength().subtract(4))
            .alias("titleWithoutLeadingThe")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .where(field("title").startsWith("The "))
    .select(
        field("title").substring(
          constant(4),
            field("title").charLength().subtract(4))
            .alias("titleWithoutLeadingThe")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .where(Field.of("title").starts_with("The "))
    .select(Field.of("title").substring(4).as_("titleWithoutLeadingThe"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .where(startsWith(field("title"), "The "))
        .select(
            substring(field("title"), constant(4), field("title").charLength())
                .as("titleWithoutLeadingThe"))
        .execute()
        .get();
PipelineSnippets.java

STRING_REVERSE

Składnia:

string_reverse[T <: STRING | BYTES](input: T) -> T

Opis:

Zwraca podane dane wejściowe w odwrotnej kolejności.

Znaki są rozdzielane przez punkty kodowe Unicode, gdy dane wejściowe są wartością STRING, a przez bajty, gdy dane wejściowe są wartością BYTES.

Przykłady:

wprowadzanie danych string_reverse(input)
„abc” „cba”
"a🌹b" „b🌹a”
„Witaj” „olleh”
b"abc" b"cba"
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(
    field("name").reverse().as("reversedName")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("name").reverse().as("reversedName")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("name").reverse().as("reversedName")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        field("name").reverse().alias("reversedName")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("name").reverse().alias("reversedName")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("name").string_reverse().as_("reversedName"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(reverse(field("name")).as("reversedName"))
        .execute()
        .get();
PipelineSnippets.java

STRING_REPEAT

Składnia:

string_repeat[T <: STRING | BYTES](input: T, repetitions: INT64) -> T

Opis:

Zwraca wartość input powtórzoną repetitions razy.

  • repetitions musi być nieujemną liczbą całkowitą.
  • Jeśli repetitions to 0, zwraca pustą wartość tego samego typu co input.
  • Jeśli wynik przekracza maksymalny dozwolony rozmiar (1 MB), zwracany jest błąd.

Przykłady:

wprowadzanie danych powtórzenia, string_repeat(input, repetitions)
„foo” 3 „foofoofoo”
„foo” 0 ""
"a " 3 "a a a "
b"ab" 2 b"abab"
„é🦆” 2 „é🦆é🦆”

STRING_REPLACE_ALL

Składnia:

string_replace_all[T <: STRING | BYTES](input: T, find: T, replacement: T) -> T

Opis:

Zamienia wszystkie niepokrywające się wystąpienia ciągu find w ciągu input na ciąg replacement.

  • W dopasowaniach rozróżniana jest wielkość liter.
  • Jeśli pole find jest puste, nie zostaną wprowadzone żadne zamiany.

Przykłady:

wprowadzanie danych znajdź wymiany string_replace_all(input, find, replacement)
„foobarfoo” „foo” „baz” „bazbarbaz”
„ababab” „aba” „c” „cbab”
„foobar” „o” "" „fbar”
„é🦆🌎🦆” „🦆” „a” „éa🌎a”
b"abc" b"b" b"d" b"adc"

STRING_REPLACE_ONE

Składnia:

string_replace_one[T <: STRING | BYTES](input: T, find: T, replacement: T) -> T

Opis:

Zastępuje pierwsze wystąpienie ciągu find w ciągu input ciągiem replacement.

  • W dopasowaniach rozróżniana jest wielkość liter.
  • Jeśli pole find jest puste, nie zostaną wprowadzone żadne zamiany.

Przykłady:

wprowadzanie danych znajdź wymiany string_replace_one(input, find, replacement)
„foobarfoo” „foo” „baz” „bazbarfoo”
"é" "é" „a” „a”
b"foobar" b"o" b"z" b"fzoobar"

TRIM

Składnia:

trim[T <: STRING | BYTES](input: T, values_to_trim: T) -> T
trim[T <: STRING | BYTES](input: T) -> T

Opis:

Usuwa określony zestaw znaków BYTES lub CHARS z początku i końca podanego ciągu input.

  • Jeśli nie podano żadnych znaków values_to_trim, usuwa znaki odstępu.

Przykłady:

Gdy nie podano wartości values_to_trim:

wprowadzanie danych trim(input)
" foo " „foo”
b" foo " b"foo"
„foo” „foo”
"" ""
" " ""
"\t foo \n" „foo”
b"\t foo \n" b"foo"
"\r\f\v foo \r\f\v" „foo”
b"\r\f\v foo \r\f\v" b"foo"

Gdy podano wartość values_to_trim:

wprowadzanie danych wartości_do_przycięcia trim(input, values_to_trim)
„abcbfooaacb” „abc” „foo”
„abcdaabadbac” „abc” "daabad"
b"C1C2C3" b"C1" b"C2C3"
b"C1C2" „foo” błąd
„foo” b"C1" błąd

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("name").trim().as("whitespaceTrimmedName")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("name").trim(" \n\t").as("whitespaceTrimmedName")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        field("name").trim().alias("whitespaceTrimmedName")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("name").trim().alias("whitespaceTrimmedName")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("name").trim().as_("whitespaceTrimmedName"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(trim(field("name")).as("whitespaceTrimmedName"))
        .execute()
        .get();
PipelineSnippets.java

LTRIM

Składnia:

ltrim[T <: STRING | BYTES](value: T, to_trim: T) -> T
ltrim[T <: STRING | BYTES](value: T) -> T

Opis:

Usuwa określony zestaw znaków BYTES lub CHARS z początku podanego ciągu value.

  • Jeśli wartość to_trim nie zostanie podana, usuwa początkowe znaki odstępu.

Przykłady:

Gdy nie podano wartości to_trim:

wartość ltrim(value)
" foo " "foo "
„foo” „foo”

Gdy podano wartość to_trim:

wartość to_trim ltrim(value, to_trim)
„aaabc” „a” „bc”
„abacaba” „ba” „caba”
"é" "é" ""

RTRIM

Składnia:

rtrim[T <: STRING | BYTES](value: T, to_trim: T) -> T
rtrim[T <: STRING | BYTES](value: T) -> T

Opis:

Usuwa określony zestaw znaków BYTES lub CHARS z końca podanego tekstu value.

  • Jeśli nie podasz wartości to_trim, zostaną usunięte znaki odstępu na końcu.

Przykłady:

Gdy nie podano wartości to_trim:

wartość rtrim(value)
" foo " " foo"
„foo” „foo”

Gdy podano wartość to_trim:

wartość to_trim rtrim(value, to_trim)
„abccc” „c” „ab”
„abacaba” „ba” „abac”
"é" "é" ""

SPLIT

Składnia:

split(input: STRING) -> ARRAY<STRING>
split[T <: STRING | BYTES](input: T, delimiter: T) -> ARRAY<T>

Opis:

Dzieli wartość STRING lub BYTES za pomocą ogranicznika.

  • W przypadku typu STRING domyślnym separatorem jest przecinek ,. Separator jest traktowany jako pojedynczy ciąg znaków.

  • W przypadku BYTES musisz określić ogranicznik.

  • Podział za pomocą pustego ogranicznika tworzy tablicę punktów kodowych Unicode dla wartości STRING i tablicę wartości BYTES dla wartości BYTES.

  • Podział pustego STRING zwraca ARRAY z jednym pustym STRING.

Przykłady:

Gdy nie podano wartości delimiter:

wprowadzanie danych split(input)
„foo,bar,foo” ["foo", "bar", "foo"]
„foo” ["foo"]
",foo," ["", "foo", ""]
"" [""]
b"C120C2C4" błąd

Gdy podano wartość delimiter:

wprowadzanie danych separator split(input, delimiter)
„foo bar foo” " " ["foo", "bar", "foo"]
„foo bar foo” „z” ["foo bar foo"]
„abc” "" ["a", "b", "c"]
b"C1,C2,C4" b"," [b"C1", b"C2", b"C4"]
b"ABC" b"" [b"A", b"B", b"C"]
„foo” b"C1" błąd

Funkcje sygnatury czasowej

Nazwa Opis
CURRENT_TIMESTAMP Generuje TIMESTAMP odpowiadającą czasowi żądania.
TIMESTAMP_TRUNC Obcina wartość TIMESTAMP do określonego poziomu szczegółowości.
UNIX_MICROS_TO_TIMESTAMP Przekształca liczbę mikrosekund od 1970-01-01 00:00:00 UTC na TIMESTAMP.
UNIX_MILLIS_TO_TIMESTAMP Przekształca liczbę milisekund od 1970-01-01 00:00:00 UTC na TIMESTAMP.
UNIX_SECONDS_TO_TIMESTAMP Przekształca liczbę sekund od 1970-01-01 00:00:00 UTC na TIMESTAMP.
TIMESTAMP_ADD Dodaje przedział czasu do TIMESTAMP
TIMESTAMP_SUB Odejmuje przedział czasu od TIMESTAMP
TIMESTAMP_TO_UNIX_MICROS Przekształca wartość TIMESTAMP na liczbę mikrosekund od 1970-01-01 00:00:00 UTC.
TIMESTAMP_TO_UNIX_MILLIS Przekształca wartość TIMESTAMP na liczbę milisekund od 1970-01-01 00:00:00 UTC.
TIMESTAMP_TO_UNIX_SECONDS Przekształca wartość TIMESTAMP na liczbę sekund od 1970-01-01 00:00:00 UTC
TIMESTAMP_DIFF Zwraca liczbę całkowitą określonych interwałów unit między dwiema datami TIMESTAMP.
TIMESTAMP_EXTRACT Wyodrębnia z TIMESTAMP określony part (np. rok, miesiąc, dzień).

CURRENT_TIMESTAMP

Składnia:

current_timestamp() -> TIMESTAMP

Opis:

Pobiera sygnaturę czasową na początku czasu żądania input (interpretowaną jako liczba mikrosekund od 1970-01-01 00:00:00 UTC).

Jest ona stała w ramach zapytania i zawsze będzie zwracać tę samą wartość, jeśli zostanie wywołana wiele razy.

TIMESTAMP_TRUNC

Składnia:

timestamp_trunc(timestamp: TIMESTAMP, granularity: STRING[, timezone: STRING]) -> TIMESTAMP

Opis:

Obcina sygnaturę czasową do określonego stopnia szczegółowości.

Argument granularity musi być ciągiem znaków i mieć jedną z tych wartości:

  • microsecond
  • millisecond
  • second
  • minute
  • hour
  • day
  • week
  • week([weekday])
  • month
  • quarter
  • year
  • isoyear

Jeśli podany jest argument timezone, obcięcie będzie oparte na granicach kalendarza danej strefy czasowej (np. obcięcie do dnia spowoduje obcięcie do północy w danej strefie czasowej). Obcinanie będzie uwzględniać czas letni.

Jeśli nie podasz wartości timezone, obcinanie będzie się odbywać na podstawie granic kalendarza UTC.

Argument timezone powinien być ciągiem znaków reprezentującym strefę czasową z bazy danych tz, np. America/New_York. Możesz też użyć niestandardowego przesunięcia czasowego, określając przesunięcie od GMT.

Przykłady:

timestamp granularity timezone timestamp_trunc(timestamp, granularity, timezone)
2000-01-01 10:20:30:123456 UTC „drugi” Nie podano 2001-01-01 10:20:30 UTC
1997-05-31 04:30:30 UTC "day" Nie podano 1997-05-31 00:00:00 UTC
1997-05-31 04:30:30 UTC "day" „America/Los_Angeles” 1997-05-30 07:00:00 UTC
2001-03-16 04:00:00 UTC „week(friday) Nie podano 2001-03-16 00:00:00 UTC
2001-03-23 04:00:00 UTC „week(friday) „America/Los_Angeles” 2001-03-23 17:00:00 UTC
2026-01-24 20:00:00 UTC „miesiąc” „GMT+06:32:43” 2026-01-01T06:32:43 UTC

UNIX_MICROS_TO_TIMESTAMP

Składnia:

unix_micros_to_timestamp(input: INT64) -> TIMESTAMP

Opis:

Konwertuje wartość input (interpretowaną jako liczbę mikrosekund od 1970-01-01 00:00:00 UTC) na wartość TIMESTAMP. Zwraca błąd error, jeśli nie można przekonwertować wartości input na prawidłową wartość TIMESTAMP.

Przykłady:

input unix_micros_to_timestamp(input)
0L 1970-01-01 00:00:00 UTC
400123456L 1970-01-01 00:06:40.123456 UTC
-1000000L 1969-12-31 23:59:59 UTC
Node.js
const result = await db.pipeline()
  .collection("documents")
  .select(
    field("createdAtMicros").unixMicrosToTimestamp().as("createdAtString")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("documents")
  .select(
    field("createdAtMicros").unixMicrosToTimestamp().as("createdAtString")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("documents")
  .select([
    Field("createdAtMicros").unixMicrosToTimestamp().as("createdAtString")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("documents")
    .select(
        field("createdAtMicros").unixMicrosToTimestamp().alias("createdAtString")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("createdAtMicros").unixMicrosToTimestamp().alias("createdAtString")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("documents")
    .select(
        Field.of("createdAtMicros")
        .unix_micros_to_timestamp()
        .as_("createdAtString")
    )
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(unixMicrosToTimestamp(field("createdAtMicros")).as("createdAtString"))
        .execute()
        .get();
PipelineSnippets.java

UNIX_MILLIS_TO_TIMESTAMP

Składnia:

unix_millis_to_timestamp(input: INT64) -> TIMESTAMP

Opis:

Przekształca wartość input (interpretowaną jako liczbę milisekund od 1970-01-01 00:00:00 UTC) w wartość TIMESTAMP. Zwraca błąd error, jeśli nie można przekonwertować wartości input na prawidłową wartość TIMESTAMP.

Przykłady:

input unix_millis_to_timestamp(input)
0L 1970-01-01 00:00:00 UTC
4000123L 1970-01-01 01:06:40.123 UTC
-1000000L 1969-12-31 23:43:20 UTC
Node.js
const result = await db.pipeline()
  .collection("documents")
  .select(
    field("createdAtMillis").unixMillisToTimestamp().as("createdAtString")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("documents")
  .select(
    field("createdAtMillis").unixMillisToTimestamp().as("createdAtString")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("documents")
  .select([
    Field("createdAtMillis").unixMillisToTimestamp().as("createdAtString")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("documents")
    .select(
        field("createdAtMillis").unixMillisToTimestamp().alias("createdAtString")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("createdAtMillis").unixMillisToTimestamp().alias("createdAtString")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("documents")
    .select(
        Field.of("createdAtMillis")
        .unix_millis_to_timestamp()
        .as_("createdAtString")
    )
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(unixMillisToTimestamp(field("createdAtMillis")).as("createdAtString"))
        .execute()
        .get();
PipelineSnippets.java

UNIX_SECONDS_TO_TIMESTAMP

Składnia:

unix_seconds_to_timestamp(input: INT64) -> TIMESTAMP

Opis:

Konwertuje wartość input (interpretowaną jako liczbę sekund od 1970-01-01 00:00:00 UTC) na wartość TIMESTAMP. Zwraca błąd error, jeśli nie można przekonwertować wartości input na prawidłową wartość TIMESTAMP.

Przykłady:

input unix_seconds_to_timestamp(input)
0L 1970-01-01 00:00:00 UTC
60L 1970-01-01 00:01:00 UTC
-300L 1969-12-31 23:55:00 UTC
Node.js
const result = await db.pipeline()
  .collection("documents")
  .select(
    field("createdAtSeconds").unixSecondsToTimestamp().as("createdAtString")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("documents")
  .select(
    field("createdAtSeconds").unixSecondsToTimestamp().as("createdAtString")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("documents")
  .select([
    Field("createdAtSeconds").unixSecondsToTimestamp().as("createdAtString")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("documents")
    .select(
        field("createdAtSeconds").unixSecondsToTimestamp().alias("createdAtString")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("createdAtSeconds").unixSecondsToTimestamp().alias("createdAtString")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("documents")
    .select(
        Field.of("createdAtSeconds")
        .unix_seconds_to_timestamp()
        .as_("createdAtString")
    )
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(unixSecondsToTimestamp(field("createdAtSeconds")).as("createdAtString"))
        .execute()
        .get();
PipelineSnippets.java

TIMESTAMP_ADD

Składnia:

timestamp_add(timestamp: TIMESTAMP, unit: STRING, amount: INT64) -> TIMESTAMP

Opis:

Dodaje amount unit z timestamp. Argument amount może być ujemny. W takim przypadku jest on równoważny funkcji TIMESTAMP_SUB.

Argument unit musi być ciągiem znaków i mieć jedną z tych wartości:

  • microsecond
  • millisecond
  • second
  • minute
  • hour
  • day

Zwraca błąd, jeśli wynikowa sygnatura czasowa nie mieści się w zakresie TIMESTAMP.

Przykłady:

timestamp unit amount timestamp_add(timestamp, unit, amount)
2025-02-20 00:00:00 UTC „minuta” 2L 2025-02-20 00:02:00 UTC
2025-02-20 00:00:00 UTC „godzina” -4L 2025-02-19 20:00:00 UTC
2025-02-20 00:00:00 UTC "day" 5L 2025-02-25 00:00:00 UTC
Node.js
const result = await db.pipeline()
  .collection("documents")
  .select(
    field("createdAt").timestampAdd("day", 3653).as("expiresAt")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("documents")
  .select(
    field("createdAt").timestampAdd("day", 3653).as("expiresAt")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("documents")
  .select([
    Field("createdAt").timestampAdd(3653, .day).as("expiresAt")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("documents")
    .select(
        field("createdAt")
          .timestampAdd("day", 3653)
          .alias("expiresAt")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("createdAt").timestampAdd("day", 3653).alias("expiresAt")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("documents")
    .select(Field.of("createdAt").timestamp_add("day", 3653).as_("expiresAt"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(timestampAdd(field("createdAt"), "day", 3653).as("expiresAt"))
        .execute()
        .get();
PipelineSnippets.java

TIMESTAMP_SUB

Składnia:

timestamp_sub(timestamp: TIMESTAMP, unit: STRING, amount: INT64) -> TIMESTAMP

Opis:

Odejmuje od wartości timestamp wartość amount równą unit. Argument amount może być ujemny. W takim przypadku jest on równoważny funkcji TIMESTAMP_ADD.

Argument unit musi być ciągiem znaków i mieć jedną z tych wartości:

  • microsecond
  • millisecond
  • second
  • minute
  • hour
  • day

Zwraca błąd, jeśli wynikowa sygnatura czasowa nie mieści się w zakresie TIMESTAMP.

Przykłady:

timestamp unit amount timestamp_sub(timestamp, unit, amount)
2026-07-04 00:00:00 UTC „minuta” 40L 2026-07-03 23:20:00 UTC
2026-07-04 00:00:00 UTC „godzina” -24L 2026-07-05 00:00:00 UTC
2026-07-04 00:00:00 UTC "day" 3L 2026-07-01 00:00:00 UTC
Node.js
const result = await db.pipeline()
  .collection("documents")
  .select(
    field("expiresAt").timestampSubtract("day", 14).as("sendWarningTimestamp")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("documents")
  .select(
    field("expiresAt").timestampSubtract("day", 14).as("sendWarningTimestamp")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("documents")
  .select([
    Field("expiresAt").timestampSubtract(14, .day).as("sendWarningTimestamp")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("documents")
    .select(
        field("expiresAt")
          .timestampSubtract("day", 14)
          .alias("sendWarningTimestamp")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("expiresAt").timestampSubtract("day", 14).alias("sendWarningTimestamp")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("documents")
    .select(
        Field.of("expiresAt")
        .timestamp_subtract("day", 14)
        .as_("sendWarningTimestamp")
    )
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(timestampSubtract(field("expiresAt"), "day", 14).as("sendWarningTimestamp"))
        .execute()
        .get();
PipelineSnippets.java

TIMESTAMP_TO_UNIX_MICROS

Składnia:

timestamp_to_unix_micros(input: TIMESTAMP) -> INT64

Opis:

Konwertuje input na liczbę mikrosekund od 1970-01-01 00:00:00 UTC. Obcina wyższe poziomy precyzji, zaokrąglając w dół do początku mikrosekundy.

Przykłady:

input timestamp_to_unix_micros(input)
1970-01-01 00:00:00 UTC 0L
1970-01-01 00:06:40.123456 UTC 400123456L
1969-12-31 23:59:59 UTC -1000000L
Node.js
const result = await db.pipeline()
  .collection("documents")
  .select(
    field("dateString").timestampToUnixMicros().as("unixMicros")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("documents")
  .select(
    field("dateString").timestampToUnixMicros().as("unixMicros")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("documents")
  .select([
    Field("dateString").timestampToUnixMicros().as("unixMicros")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("documents")
    .select(
        field("dateString").timestampToUnixMicros().alias("unixMicros")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("dateString").timestampToUnixMicros().alias("unixMicros")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("documents")
    .select(Field.of("dateString").timestamp_to_unix_micros().as_("unixMicros"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(timestampToUnixMicros(field("dateString")).as("unixMicros"))
        .execute()
        .get();
PipelineSnippets.java

TIMESTAMP_TO_UNIX_MILLIS

Składnia:

timestamp_to_unix_millis(input: TIMESTAMP) -> INT64

Opis:

Przekształca wartość input na liczbę milisekund od 1970-01-01 00:00:00 UTC. Obcina wyższe poziomy precyzji, zaokrąglając w dół do początku milisekundy.

Przykłady:

input timestamp_to_unix_millis(input)
1970-01-01 00:00:00 UTC 0L
1970-01-01 01:06:40.123 UTC 4000123L
1969-12-31 23:43:20 -1000000L
Node.js
const result = await db.pipeline()
  .collection("documents")
  .select(
    field("dateString").timestampToUnixMillis().as("unixMillis")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("documents")
  .select(
    field("dateString").timestampToUnixMillis().as("unixMillis")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("documents")
  .select([
    Field("dateString").timestampToUnixMillis().as("unixMillis")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("documents")
    .select(
        field("dateString").timestampToUnixMillis().alias("unixMillis")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("dateString").timestampToUnixMillis().alias("unixMillis")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("documents")
    .select(Field.of("dateString").timestamp_to_unix_millis().as_("unixMillis"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(timestampToUnixMillis(field("dateString")).as("unixMillis"))
        .execute()
        .get();
PipelineSnippets.java

TIMESTAMP_TO_UNIX_SECONDS

Składnia:

timestamp_to_unix_seconds(input: TIMESTAMP) -> INT64

Opis:

Przekształca wartość input w liczbę sekund od 1970-01-01 00:00:00 UTC. Obcina wyższe poziomy precyzji, zaokrąglając w dół do początku sekundy.

Przykłady:

input timestamp_to_unix_seconds(input)
1970-01-01 00:00:00 UTC 0L
1970-01-01 00:01:00 UTC 60L
1969-12-31 23:55:00 UTC -300L
Node.js
const result = await db.pipeline()
  .collection("documents")
  .select(
    field("dateString").timestampToUnixSeconds().as("unixSeconds")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("documents")
  .select(
    field("dateString").timestampToUnixSeconds().as("unixSeconds")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("documents")
  .select([
    Field("dateString").timestampToUnixSeconds().as("unixSeconds")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("documents")
    .select(
        field("dateString").timestampToUnixSeconds().alias("unixSeconds")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("dateString").timestampToUnixSeconds().alias("unixSeconds")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("documents")
    .select(Field.of("dateString").timestamp_to_unix_seconds().as_("unixSeconds"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(timestampToUnixSeconds(field("dateString")).as("unixSeconds"))
        .execute()
        .get();
PipelineSnippets.java

TIMESTAMP_DIFF

Składnia:

timestamp_diff(end: TIMESTAMP, start: TIMESTAMP, unit: STRING) -> INT64

Opis:

Zwraca liczbę całkowitą określonych interwałów unit między dwiema datami TIMESTAMP.

  • Zwraca wartość ujemną, jeśli end występuje przed start.
  • Obcina dowolną jednostkę ułamkową. Na przykład timestamp_diff("2021-01-01 00:00:01", "2021-01-01 00:00:00", "minute") zwraca 0.

Argument unit musi być ciągiem znaków i mieć jedną z tych wartości:

  • microsecond
  • millisecond
  • second
  • minute
  • hour
  • day

Przykłady:

end start unit timestamp_diff(end, start, unit)
2026-07-04 00:01:00 UTC 2026-07-04 00:00:00 UTC „drugi” 60L
2026-07-04 00:00:00 UTC 2026-07-05 00:00:00 UTC "day" -1L
2026-07-04 00:00:59 UTC 2026-07-04 00:00:00 UTC „minuta” 0L

TIMESTAMP_EXTRACT

Składnia:

timestamp_extract(timestamp: TIMESTAMP, part: STRING[, timezone: STRING]) -> INT64

Opis:

Wyodrębnia z daty timestamp określony part (np. rok, miesiąc, dzień).

Argument part musi być ciągiem znaków i mieć jedną z tych wartości:

  • microsecond
  • millisecond
  • second
  • minute
  • hour
  • day
  • dayofweek: zwraca wartość od 1 (niedziela) do 7 (sobota).
  • dayofyear
  • week: zwraca numer tygodnia w roku, zaczynając od 1 w przypadku pierwszej niedzieli w roku.
  • week([weekday]): zwraca numer tygodnia w roku, zaczynając od określonego weekday.
  • month
  • quarter
  • year
  • isoweek: zwraca numer tygodnia zgodnie z normą ISO 8601.
  • isoyear: zwraca rok numeracji tygodni zgodnie z normą ISO 8601.

Jeśli podasz argument timezone, wyodrębnianie będzie oparte na kalendarzu danej strefy czasowej. Wyodrębnianie będzie uwzględniać czas letni.

Jeśli nie podasz wartości timezone, wyodrębnianie będzie oparte na wartości UTC.

Argument timezone powinien być ciągiem znaków reprezentującym strefę czasową z bazy danych stref czasowych, np. America/New_York. Możesz też użyć niestandardowego przesunięcia czasowego, określając przesunięcie od GMT.

Przykłady:

timestamp part timezone timestamp_extract(timestamp, part, timezone)
2025-02-20 10:20:30 UTC „year” Nie podano 2025
2025-02-20 10:20:30 UTC "day" Nie podano 20
2025-12-31 23:59:59 UTC „year” „Asia/Tokyo” 2026

Funkcje typu

Nazwa Opis
TYPE Zwraca typ wartości jako STRING.
IS_TYPE Zwraca true, jeśli wartość pasuje do określonego typu.

TYP

Składnia:

type(input: ANY) -> STRING

Opis:

Zwraca ciąg znaków reprezentujący typ input.

Jeśli podano wartość nieobecną, zwraca NULL.

Przykłady:

input type(input)
NULL „null”
prawda „boolean”
1 „int32”
-3L "int64"
3.14 „float64”
2024-01-01T00:00:00Z UTC „timestamp”
„foo” „string”
b"foo" „bajty”
[1, 2] „array”
{"a": 1} „map”
path("c/d") „reference”
vector([1.0, 2.0]) „wektor”
ABSENT NULL

Przykłady klientów

Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("title").notEqual("1984").as("not1984"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("title").notEqual("1984").as("not1984"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("title").notEqual("1984").as("not1984")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(field("title").notEqual("1984").alias("not1984"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("title").notEqual("1984").alias("not1984"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("title").not_equal("1984").as_("not1984"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(notEqual(field("title"), "1984").as("not1984"))
        .execute()
        .get();
PipelineSnippets.java

IS_TYPE

Składnia:

is_type(input: ANY, type: STRING) -> BOOLEAN

Opis:

Zwraca wartość true, jeśli input pasuje do określonego type, w przeciwnym razie zwraca false. Jeśli argument input nie jest podany, zwraca wartość NULL.

Obsługiwane ciągi znaków type:

  • "null"
  • "boolean"
  • "int32"
  • "int64"
  • "float64"
  • "decimal128"
  • "number"
  • "timestamp"
  • "string"
  • "bytes"
  • "array"
  • "map"
  • "reference"
  • "vector"
  • "geo_point"
  • "max_key"
  • "min_key"
  • "object_id"
  • "regex"
  • "bson_timestamp"

Przykłady:

input type is_type(input, type)
NULL „null” prawda
prawda „boolean” prawda
3.14 „float64” prawda
„foo” „string” prawda
b"foo" „string” fałsz
[1, 2] „array” prawda
{"a": 1} „map” prawda
vector([1.0, 2.0]) „wektor” prawda
ABSENT „string” NULL
„bar” „inne” BŁĄD

Funkcje wektorowe

Nazwa Opis
COSINE_DISTANCE Zwraca odległość cosinusową między dwoma wektorami.
DOT_PRODUCT Zwraca iloczyn skalarny dwóch wektorów.
EUCLIDEAN_DISTANCE Zwraca odległość euklidesową między dwoma wektorami.
MANHATTAN_DISTANCE Zwraca odległość Manhattan między dwoma wektorami.
VECTOR_LENGTH Zwraca liczbę elementów w wektorze

COSINE_DISTANCE

Składnia:

cosine_distance(x: VECTOR, y: VECTOR) -> FLOAT64

Opis:

Zwraca odległość cosinusową między x a y.

Node.js
const sampleVector = [0.0, 1, 2, 3, 4, 5];
const result = await db.pipeline()
  .collection("books")
  .select(
    field("embedding").cosineDistance(sampleVector).as("cosineDistance")
  )
  .execute();
test.firestore.js

Web

const sampleVector = [0.0, 1, 2, 3, 4, 5];
const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("embedding").cosineDistance(sampleVector).as("cosineDistance")));
test.firestore.js
Swift
let sampleVector = [0.0, 1, 2, 3, 4, 5]
let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("embedding").cosineDistance(sampleVector).as("cosineDistance")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val sampleVector = doubleArrayOf(0.0, 1.0, 2.0, 3.0, 4.0, 5.0)
val result = db.pipeline()
    .collection("books")
    .select(
        field("embedding").cosineDistance(sampleVector).alias("cosineDistance")
    )
    .execute()
DocSnippets.kt

Java

double[] sampleVector = {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("embedding").cosineDistance(sampleVector).alias("cosineDistance")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field
from google.cloud.firestore_v1.vector import Vector

sample_vector = Vector([0.0, 1.0, 2.0, 3.0, 4.0, 5.0])
result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("embedding").cosine_distance(sample_vector).as_("cosineDistance")
    )
    .execute()
)
firestore_pipelines.py
Java
double[] sampleVector = new double[] {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(cosineDistance(field("embedding"), sampleVector).as("cosineDistance"))
        .execute()
        .get();
PipelineSnippets.java

DOT_PRODUCT

Składnia:

dot_product(x: VECTOR, y: VECTOR) -> FLOAT64

Opis:

Zwraca iloczyn skalarny wektorów x i y.

Node.js
const sampleVector = [0.0, 1, 2, 3, 4, 5];
const result = await db.pipeline()
  .collection("books")
  .select(
    field("embedding").dotProduct(sampleVector).as("dotProduct")
  )
  .execute();
test.firestore.js

Web

const sampleVector = [0.0, 1, 2, 3, 4, 5];
const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("embedding").dotProduct(sampleVector).as("dotProduct")
  )
);
test.firestore.js
Swift
let sampleVector = [0.0, 1, 2, 3, 4, 5]
let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("embedding").dotProduct(sampleVector).as("dotProduct")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val sampleVector = doubleArrayOf(0.0, 1.0, 2.0, 3.0, 4.0, 5.0)
val result = db.pipeline()
    .collection("books")
    .select(
        field("embedding").dotProduct(sampleVector).alias("dotProduct")
    )
    .execute()
DocSnippets.kt

Java

double[] sampleVector = {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("embedding").dotProduct(sampleVector).alias("dotProduct")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field
from google.cloud.firestore_v1.vector import Vector

sample_vector = Vector([0.0, 1.0, 2.0, 3.0, 4.0, 5.0])
result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("embedding").dot_product(sample_vector).as_("dotProduct"))
    .execute()
)
firestore_pipelines.py
Java
double[] sampleVector = new double[] {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(dotProduct(field("embedding"), sampleVector).as("dotProduct"))
        .execute()
        .get();
PipelineSnippets.java

EUCLIDEAN_DISTANCE

Składnia:

euclidean_distance(x: VECTOR, y: VECTOR) -> FLOAT64

Opis:

Oblicza odległość euklidesową między x a y.

Node.js
const sampleVector = [0.0, 1, 2, 3, 4, 5];
const result = await db.pipeline()
  .collection("books")
  .select(
    field("embedding").euclideanDistance(sampleVector).as("euclideanDistance")
  )
  .execute();
test.firestore.js

Web

const sampleVector = [0.0, 1, 2, 3, 4, 5];
const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("embedding").euclideanDistance(sampleVector).as("euclideanDistance")
  )
);
test.firestore.js
Swift
let sampleVector = [0.0, 1, 2, 3, 4, 5]
let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("embedding").euclideanDistance(sampleVector).as("euclideanDistance")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val sampleVector = doubleArrayOf(0.0, 1.0, 2.0, 3.0, 4.0, 5.0)
val result = db.pipeline()
    .collection("books")
    .select(
        field("embedding").euclideanDistance(sampleVector).alias("euclideanDistance")
    )
    .execute()
DocSnippets.kt

Java

double[] sampleVector = {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("embedding").euclideanDistance(sampleVector).alias("euclideanDistance")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field
from google.cloud.firestore_v1.vector import Vector

sample_vector = Vector([0.0, 1.0, 2.0, 3.0, 4.0, 5.0])
result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("embedding")
        .euclidean_distance(sample_vector)
        .as_("euclideanDistance")
    )
    .execute()
)
firestore_pipelines.py
Java
double[] sampleVector = new double[] {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(euclideanDistance(field("embedding"), sampleVector).as("euclideanDistance"))
        .execute()
        .get();
PipelineSnippets.java

MANHATTAN_DISTANCE

Składnia:

manhattan_distance(x: VECTOR, y: VECTOR) -> FLOAT64

Opis:

Oblicza odległość Manhattan między x a y.

VECTOR_LENGTH

Składnia:

vector_length(vector: VECTOR) -> INT64

Opis:

Zwraca liczbę elementów w VECTOR.

Node.js
const result = await db.pipeline()
  .collection("books")
  .select(
    field("embedding").vectorLength().as("vectorLength")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("embedding").vectorLength().as("vectorLength")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("embedding").vectorLength().as("vectorLength")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        field("embedding").vectorLength().alias("vectorLength")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("embedding").vectorLength().alias("vectorLength")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("embedding").vector_length().as_("vectorLength"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(vectorLength(field("embedding")).as("vectorLength"))
        .execute()
        .get();
PipelineSnippets.java