Wszystkie funkcje

Zbiorcze

Wszystkie funkcje agregujące 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 ma 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 dla pierwszego dokumentu.
LAST Zwraca wartość expression dla ostatniego dokumentu.
ARRAY_AGG Zwraca tablicę wszystkich wartości wejściowych.
ARRAY_AGG_DISTINCT Zwraca tablicę wszystkich unikalnych 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 zwraca dowolną wartość inną niż NULL. Jeśli nie podasz parametru expression, zwracana jest łączna liczba 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();

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"))
);
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()

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()

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();
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()
)
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();
Go
// Total number of books in the collection
countAll, err := client.Pipeline().Collection("books").
	Aggregate(firestore.Accumulators(firestore.CountAll().As("count"))).
	Execute(ctx).Results().GetAll()
if err != nil {
	fmt.Fprintf(w, "GetAll failed: %v", err)
	return err
}

// Number of books with nonnull `ratings` field
countField, err := client.Pipeline().
	Collection("books").
	Aggregate(firestore.Accumulators(firestore.Count("ratings").As("count"))).
	Execute(ctx).Results().GetAll()
if err != nil {
	fmt.Fprintf(w, "GetAll failed: %v", err)
	return err
}

COUNT_IF

Składnia:

count_if(expression: BOOLEAN) -> INT64

Opis:

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

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

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .aggregate(
        AggregateFunction.countIf(field("rating").greaterThan(4)).alias("filteredCount")
    )
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .aggregate(countIf(field("rating").greaterThan(4)).as("filteredCount"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Aggregate(firestore.Accumulators(
		firestore.CountIf(firestore.FieldOf("rating").GreaterThan(4)).As("filteredCount"),
	)).
	Execute(ctx)

COUNT_DISTINCT

Składnia:

count_distinct(expression: ANY) -> INT64

Opis:

Zwraca liczbę unikalnych wartości expression, które nie są równe NULL ani ABSENT.

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

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .aggregate(AggregateFunction.countDistinct("author").alias("unique_authors"))
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .aggregate(countDistinct("author").as("unique_authors"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Aggregate(firestore.Accumulators(
		firestore.CountDistinct("author").As("unique_authors"),
	)).
	Execute(ctx)

SUMA

Składnia:

sum(expression: ANY) -> NUMBER

Opis:

Zwraca sumę wszystkich wartości liczbowych, ignorując wartości nieliczbowe. Zwraca NaN, jeśli dowolne wartości to NaN.

Dane wyjściowe będą miały taki sam typ jak najszerszy typ danych wejściowych, z wyjątkiem tych przypadków:

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("cities")
    .aggregate(Field.of("population").sum().as_("totalPopulation"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("cities")
        .aggregate(sum("population").as("totalPopulation"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("cities").
	Aggregate(firestore.Accumulators(
		firestore.Sum("population").As("totalPopulation"),
	)).
	Execute(ctx)

ŚREDNIA

Składnia:

average(expression: ANY) -> FLOAT64

Opis:

Zwraca średnią wszystkich wartości liczbowych, ignorując wartości nieliczbowe. Zwraca wartość NaN, jeśli dowolne wartości to NaN, lub NULL, jeśli nie są agregowane żadne wartości liczbowe.

Dane wyjściowe będą miały taki sam typ jak dane wejściowe, z wyjątkiem tych przypadków:

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("cities")
    .aggregate(Field.of("population").average().as_("averagePopulation"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("cities")
        .aggregate(average("population").as("averagePopulation"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("cities").
	Aggregate(firestore.Accumulators(
		firestore.Average("population").As("averagePopulation"),
	)).
	Execute(ctx)

MINIMUM

Składnia:

minimum(expression: ANY) -> ANY

Opis:

Zwraca minimalną wartość expression, która nie jest NULL ani nie jest nieobecna, po ocenie każdego dokumentu.

Jeśli nie ma wartości innych niż NULL i nieobecne, zwracana jest wartość NULL. Dotyczy to również sytuacji, gdy nie są uwzględniane żadne dokumenty.

Jeśli istnieje kilka minimalnych równoważnych wartości, może zostać zwrócona dowolna 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();

Web

const result = await execute(db.pipeline()
  .collection("books")
  .aggregate(field("price").minimum().as("minimumPrice"))
);
Swift
let result = try await db.pipeline()
  .collection("books")
  .aggregate([Field("price").minimum().as("minimumPrice")])
  .execute()

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .aggregate(Field.of("price").minimum().as_("minimumPrice"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .aggregate(minimum("price").as("minimumPrice"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Aggregate(firestore.Accumulators(
		firestore.Minimum("price").As("minimumPrice"),
	)).
	Execute(ctx)

MAKSYMALNA

Składnia:

maximum(expression: ANY) -> ANY

Opis:

Zwraca maksymalną wartość expression, która nie jest wartością NULL ani wartością nieobecną, po ocenie każdego dokumentu.

Jeśli nie ma wartości innych niż NULL i nieobecne, zwracana jest wartość NULL. Dotyczy to również sytuacji, gdy nie są uwzględniane żadne dokumenty.

Jeśli istnieje wiele maksymalnych równoważnych wartości, może zostać zwrócona dowolna 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();

Web

const result = await execute(db.pipeline()
  .collection("books")
  .aggregate(field("price").maximum().as("maximumPrice"))
);
Swift
let result = try await db.pipeline()
  .collection("books")
  .aggregate([Field("price").maximum().as("maximumPrice")])
  .execute()

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .aggregate(Field.of("price").maximum().as_("maximumPrice"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .aggregate(maximum("price").as("maximumPrice"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Aggregate(firestore.Accumulators(
		firestore.Maximum("price").As("maximumPrice"),
	)).
	Execute(ctx)

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 dla ostatniego zwróconego dokumentu.

ARRAY_AGG

Składnia:

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

Opis:

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

Jeśli wyrażenie zwraca brak wartości, 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 różne wartości expression po ocenie każdego dokumentu.

Jeśli wyrażenie zwraca brak wartości, 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 mają te właściwości:

  • 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 niedomiar.

Cloud Firestore wykonuje rozszerzanie typu liczbowego na podstawie tej hierarchii: INT32 < INT64 < FLOAT64 < DECIMAL128. Gdy funkcja arytmetyczna przyjmuje wiele argumentów liczbowych różnych typów (np. add(5.0D, 6L)), typy o mniejszym zakresie są niejawnie konwertowane na typ o największym zakresie spośród operandów. W poprzednim przykładzie typ 6L jest rozszerzany do 6.0D, co powoduje, że wyrażenie zwraca typ FLOAT64.

Niejawne wymuszenie typu INT64 -> FLOAT64 może spowodować utratę precyzji, ponieważ wymuszona wartość może utracić najmniej znaczące bity. Wynikowa wartość będzie zaokrągloną wersją pierwotnej wartości całkowitej przy użyciu trybu zaokrąglania do najbliższej wartości IEEE 754.

Nazwa Opis
ABS Zwraca wartość bezwzględną 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 wartość number zaokrągloną w górę
FLOOR Zwraca wartość podłogi dla 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 liczby number
EXP Zwraca liczbę Eulera podniesioną do potęgi exponent
LN Zwraca logarytm naturalny z number
LOG Zwraca logarytm number
LOG10 Zwraca logarytm liczby number o podstawie 10
RAND Zwraca pseudoprzypadkową liczbę zmiennoprzecinkową.

przypisane wyszukiwania z nazwą marki

Składnia:

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

Opis:

Zwraca wartość bezwzględną number.

  • Zgłasza błąd, gdy funkcja przekroczy wartość 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();

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(Expression.add(field("soldBooks"), field("unsoldBooks")).alias("totalBooks"))
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(add(field("soldBooks"), field("unsoldBooks")).as("totalBooks"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.Add(firestore.FieldOf("soldBooks"), firestore.FieldOf("unsoldBooks")).As("totalBooks"),
	)).
	Execute(ctx)

SUBTRACT

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();

Web

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

Kotlin

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

Java

int storeCredit = 7;
Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(Expression.subtract(field("price"), storeCredit).alias("totalCost"))
    .execute();
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()
)
Java
int storeCredit = 7;
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(subtract(field("price"), storeCredit).as("totalCost"))
        .execute()
        .get();
Go
storeCredit := 7
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.Subtract(firestore.FieldOf("price"), storeCredit).As("totalCost"),
	)).
	Execute(ctx)

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();

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(Expression.multiply(field("price"), field("soldBooks")).alias("revenue"))
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(multiply(field("price"), field("soldBooks")).as("revenue"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.Multiply(firestore.FieldOf("price"), firestore.FieldOf("soldBooks")).As("revenue"),
	)).
	Execute(ctx)

DIVIDE

Składnia:

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

Opis:

Zwraca wartość x / y. Dzielenie liczb całkowitych 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
0,0 0,0 NaN
+inf +inf NaN
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("ratings").divide(field("soldBooks")).as("reviewRate"))
  .execute();

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(Expression.divide(field("ratings"), field("soldBooks")).alias("reviewRate"))
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(divide(field("ratings"), field("soldBooks")).as("reviewRate"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.Divide(firestore.FieldOf("ratings"), firestore.FieldOf("soldBooks")).As("reviewRate"),
	)).
	Execute(ctx)

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 jest równe 0 w przypadku typów liczb całkowitych (INT64).
  • Zwraca NaN, gdy y jest równe 0 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();

Web

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

Kotlin

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

Java

int displayCapacity = 1000;
Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(Expression.mod(field("unsoldBooks"), displayCapacity).alias("warehousedBooks"))
    .execute();
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()
)
Java
int displayCapacity = 1000;
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(mod(field("unsoldBooks"), displayCapacity).as("warehousedBooks"))
        .execute()
        .get();
Go
displayCapacity := 1000
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.Mod(firestore.FieldOf("unsoldBooks"), displayCapacity).As("warehousedBooks"),
	)).
	Execute(ctx)

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
NaN NaN
+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();

Web

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

Kotlin

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

Java

int booksPerShelf = 100;
Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        Expression.divide(field("unsoldBooks"), booksPerShelf).ceil().alias("requiredShelves")
    )
    .execute();
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()
)
Java
int booksPerShelf = 100;
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(ceil(divide(field("unsoldBooks"), booksPerShelf)).as("requiredShelves"))
        .execute()
        .get();
Go
booksPerShelf := 100
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.Ceil(firestore.Divide(firestore.FieldOf("unsoldBooks"), booksPerShelf)).As("requiredShelves"),
	)).
	Execute(ctx)

ZAOKR.W.DÓŁ

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
NaN NaN
+inf +inf
-inf -inf
Node.js
const result = await db.pipeline()
  .collection("books")
  .addFields(
    field("wordCount").divide(field("pages")).floor().as("wordsPerPage")
  )
  .execute();

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .addFields(
        Expression.divide(field("wordCount"), field("pages")).floor().alias("wordsPerPage")
    )
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .addFields(floor(divide(field("wordCount"), field("pages"))).as("wordsPerPage"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	AddFields(firestore.Selectables(
		firestore.Floor(firestore.Divide(firestore.FieldOf("wordCount"), firestore.FieldOf("pages"))).As("wordsPerPage"),
	)).
	Execute(ctx)

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 cyfry od number. Zaokrągla cyfry po prawej stronie separatora dziesiętnego, jeśli wartość places jest dodatnia, i po lewej stronie separatora dziesiętnego, jeśli jest ujemna.

  • Jeśli podano tylko parametr number, zaokrągla do najbliższej wartości całkowitej.
  • Zaokrągla w górę, gdy wartość jest w połowie.
  • Jeśli zaokrąglenie z ujemną wartością places spowoduje przepełnienie, zostanie wygenerowany 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();

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("soldBooks").multiply(field("price")).round().as("partialRevenue"))
  .aggregate(field("partialRevenue").sum().as("totalRevenue"))
  );
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()

Kotlin

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

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();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(round(multiply(field("soldBooks"), field("price"))).as("partialRevenue"))
        .aggregate(sum("partialRevenue").as("totalRevenue"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.Round(firestore.Multiply(firestore.FieldOf("soldBooks"), firestore.FieldOf("price"))).As("partialRevenue"),
	)).
	Aggregate(firestore.Accumulators(
		firestore.Sum("partialRevenue").As("totalRevenue"),
	)).
	Execute(ctx)

TRUNC

Składnia:

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

Opis:

Skraca liczbę typu number do określonej liczby miejsc po przecinku (places). Obcina cyfry po prawej stronie separatora dziesiętnego, jeśli wartość places jest dodatnia, i po lewej stronie separatora dziesiętnego, jeśli jest ujemna.

  • Jeśli podano tylko parametr number, obcina do najbliższej wartości całkowitej w kierunku zera.
  • Jeśli obcięcie spowoduje przepełnienie, zostanie wygenerowany 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 base <= 0 i exponent są ujemne.

  • Dla dowolnego exponent (w tym NaN) pow(1, exponent) wynosi 1.

  • Dla dowolnego base (w tym NaN) 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
NaN 0 1,0
1 NaN 1,0
NaN Numeric NaN
Numeric NaN NaN
-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();

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")
  )
);
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()

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()

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();
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()
)
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();
Go
googleplexLat := 37.4221
googleplexLng := -122.0853
snapshot := client.Pipeline().
	Collection("cities").
	AddFields(firestore.Selectables(
		firestore.Pow(firestore.Multiply(firestore.Subtract(firestore.FieldOf("lat"), googleplexLat), 111), 2).As("latitudeDifference"),
		firestore.Pow(firestore.Multiply(firestore.Subtract(firestore.FieldOf("lng"), googleplexLng), 111), 2).As("longitudeDifference"),
	)).
	Select(firestore.Fields(
		firestore.Sqrt(firestore.Add(firestore.FieldOf("latitudeDifference"), firestore.FieldOf("longitudeDifference"))).
			// Inaccurate for large distances or close to poles
			As("approximateDistanceToGoogle"),
	)).
	Execute(ctx)

PIERWIASTEK

Składnia:

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

Opis:

Zwraca pierwiastek kwadratowy z liczby number.

  • Zwraca błąd error, jeśli number jest liczbą ujemną.

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();

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")
  )
);
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()

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()

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();
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()
)
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();
Go
googleplexLat := 37.4221
googleplexLng := -122.0853
snapshot := client.Pipeline().
	Collection("cities").
	AddFields(firestore.Selectables(
		firestore.Pow(firestore.Multiply(firestore.Subtract(firestore.FieldOf("lat"), googleplexLat), 111), 2).As("latitudeDifference"),
		firestore.Pow(firestore.Multiply(firestore.Subtract(firestore.FieldOf("lng"), googleplexLng), 111), 2).As("longitudeDifference"),
	)).
	Select(firestore.Fields(
		firestore.Sqrt(firestore.Add(firestore.FieldOf("latitudeDifference"), firestore.FieldOf("longitudeDifference"))).
			// Inaccurate for large distances or close to poles
			As("approximateDistanceToGoogle"),
	)).
	Execute(ctx)

EXP

Składnia:

exp(exponent: FLOAT64) -> FLOAT64

Opis:

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

Przykłady:

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("rating").exp().as_("expRating"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(exp(field("rating")).as("expRating"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.Exp(firestore.FieldOf("rating")).As("expRating"),
	)).
	Execute(ctx)

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
NaN NaN
-inf NaN
+inf +inf
x <= 0 [error]
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("rating").ln().as("lnRating"))
  .execute();

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("rating").ln().as_("lnRating"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(ln(field("rating")).as("lnRating"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.Ln(firestore.FieldOf("rating")).As("lnRating"),
	)).
	Execute(ctx)

DZIENNIK

Składnia:

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

Opis:

Zwraca logarytm liczby number o podstawie base.

  • Jeśli podano tylko argument number, zwraca logarytm argumentu number o podstawie base (odpowiednik funkcji ln(number)).

Przykłady:

liczba podstawa log(number, base)
100 10 2,0
NaN Numeric NaN
Numeric NaN NaN
-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 z number o podstawie 10.

Przykłady:

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

RAND

Składnia:

rand() -> FLOAT64

Opis:

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

Funkcje tablicowe

Nazwa Opis
ARRAY Zwraca ARRAY zawierający po 1 elemencie dla każdego argumentu wejściowego.
ARRAY_CONCAT Łączy wiele tablic w jedną tablicę ARRAY
ARRAY_CONTAINS Zwraca wartość TRUE, jeśli dany element ARRAY zawiera określoną wartość
ARRAY_CONTAINS_ALL Zwraca wartość TRUE, jeśli wszystkie wartości są obecne w ARRAY
ARRAY_CONTAINS_ANY Zwraca TRUE, jeśli dowolna z wartości jest obecna w ARRAY
ARRAY_FILTER Odfiltrowuje elementy z ARRAY, które nie spełniają warunku
ARRAY_FIRST Zwraca pierwszy element w ARRAY
ARRAY_FIRST_N Zwraca pierwsze elementy (n) w ARRAY
ARRAY_GET Zwraca element o danym indeksie w ARRAY
ARRAY_INDEX_OF Zwraca indeks pierwszego wystąpienia wartości w obiekcie ARRAY
ARRAY_INDEX_OF_ALL Zwraca wszystkie indeksy wartości w ARRAY
ARRAY_LENGTH Zwraca liczbę elementów w obiekcie ARRAY
ARRAY_LAST Zwraca ostatni element w ARRAY
ARRAY_LAST_N Zwraca ostatnie elementy (n) w tablicy (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 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 tablicy wynikowej 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ą tablicę 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();
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("genre").arrayConcat([Field("subGenre")]).as("allGenres")])
  .execute()

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("genre").arrayConcat(field("subGenre")).alias("allGenres"))
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(arrayConcat(field("genre"), field("subGenre")).as("allGenres"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.ArrayConcat(firestore.FieldOf("genre"), firestore.FieldOf("subGenre")).As("allGenres"),
	)).
	Execute(ctx)

ARRAY_CONTAINS

Składnia:

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

Opis:

Zwraca TRUE, jeśli value znajduje się w array, a w przeciwnym razie – 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();

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("genre").arrayContains("mystery").alias("isMystery"))
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(arrayContains(field("genre"), "mystery").as("isMystery"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.ArrayContains(firestore.FieldOf("genre"), "mystery").As("isMystery"),
	)).
	Execute(ctx)

ARRAY_CONTAINS_ALL

Składnia:

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

Opis:

Zwraca TRUE, jeśli wszystkie elementy search_values zostaną znalezione w array, a w przeciwnym razie – 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();

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("genre")
            .arrayContainsAll(Arrays.asList("fantasy", "adventure"))
            .alias("isFantasyAdventure")
    )
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            arrayContainsAll(field("genre"), Arrays.asList("fantasy", "adventure"))
                .as("isFantasyAdventure"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.ArrayContainsAll(firestore.FieldOf("genre"), []string{"fantasy", "adventure"}).As("isFantasyAdventure"),
	)).
	Execute(ctx)

ARRAY_CONTAINS_ANY

Składnia:

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

Opis:

Zwraca TRUE, jeśli w array zostanie znaleziony dowolny z search_values, a w przeciwnym razie – 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();

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("genre")
            .arrayContainsAny(Arrays.asList("fantasy", "nonfiction"))
            .alias("isMysteryOrFantasy")
    )
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            arrayContainsAny(field("genre"), Arrays.asList("fantasy", "nonfiction"))
                .as("isMysteryOrFantasy"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.ArrayContainsAny(firestore.FieldOf("genre"), []string{"fantasy", "nonfiction"}).As("isMysteryOrFantasy"),
	)).
	Execute(ctx)

ARRAY_FILTER

Składnia:

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

Opis:

Filtruje array za pomocą wyrażenia predicate, zwracając nową tablicę zawierającą tylko elementy, które spełniają warunek.

  • W przypadku każdego elementu w array oceniany jest predicate. Jeśli zwraca wartość true, element jest uwzględniany w wyniku. W przeciwnym razie (jeśli zwraca wartość false lub null) jest pomijany.
  • Jeśli predicate zwraca wartość inną niż logiczna lub wartość inną niż null, funkcja zwraca błąd.

Przykłady:

tablica warunek 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 o indeksie index (licząc od 0) w tablicy array.

  • Jeśli index jest ujemny, dostęp do elementów jest uzyskiwany od końca tablicy, gdzie -1 jest ostatnim elementem.
  • Jeśli array nie jest typu ARRAY ani null, zwraca błąd.
  • Jeśli index jest poza zakresem, funkcja zwraca brak wartości.
  • Jeśli 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();

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("genre").array_length().as_("genreCount"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(arrayLength(field("genre")).as("genreCount"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.ArrayLength(firestore.FieldOf("genre")).As("genreCount"),
	)).
	Execute(ctx)

ARRAY_REVERSE

Składnia:

array_reverse(array: ARRAY) -> ARRAY

Opis:

Odwraca podany element 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();

Web

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

Kotlin

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

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

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("genre").array_reverse().as_("reversedGenres"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(arrayReverse(field("genre")).as("reversedGenres"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.ArrayReverse(firestore.FieldOf("genre")).As("reversedGenres"),
	)).
	Execute(ctx)

ARRAY_FIRST

Składnia:

array_first(array: ARRAY) -> ANY

Opis:

Zwraca pierwszy element w tablicy array. Odpowiada to array_get(array, 0).

  • Jeśli parametr array jest pusty, zwraca brak wartości.

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 elementy (n) tablicy array. Odpowiada to array_slice(array, 0, n).

  • Jeśli argument n jest ujemny, 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 0) pierwszego wystąpienia ciągu value w ciągu array. Jeśli nie znajdzie ciągu value, zwraca -1.

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 (liczone od 0) wszystkich wystąpień value w array. Zwraca [], jeśli nie znaleziono 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. Odpowiada to array_get(array, -1).

  • Jeśli parametr array jest pusty, zwraca brak wartości.

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 elementy (n) tablicy array.

  • Jeśli argument n jest ujemny, 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 0) i zawierający length elementów.

  • Jeśli wartość offset jest ujemna, oznacza pozycję początkową od końca tablicy, przy czym -1 jest ostatnim elementem.
  • Jeśli wartość 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ć liczbą nieujemną, w przeciwnym razie zwracany jest błąd.

Przykłady:

tablica offset 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 będzie zawsze miała taki sam rozmiar jak tablica wejściowa.

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

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 puste 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ę zawierającą n największych wartości w array w porządku malejącym.

  • Wartości NULL są ignorowane.
  • Jeśli argument n jest ujemny, 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 array.

  • Wartości NULL są ignorowane podczas porównywania.
  • Jeśli array jest puste 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 argumencie array w porządku rosnącym.

  • Wartości NULL są ignorowane.
  • Jeśli argument n jest ujemny, 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.
  • Zwracany typ jest określany przez najszerszy typ liczbowy w tablicy: INT64 < FLOAT64.
  • Jeśli przed zsumowaniem wartości zmiennoprzecinkowej wystąpi przepełnienie 64-bitowej liczby całkowitej, zwracany jest błąd. Jeśli sumowane są wartości zmiennoprzecinkowe, przepełnienie spowoduje zwrócenie 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 konkatenację elementów w array jako STRING. array może być typu danych STRING lub BYTES.

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

Przykłady:

Jeśli nie podano parametru 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 parametr 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 niż lub równe”
LESS_THAN Porównanie „mniejsze niż”
LESS_THAN_OR_EQUAL Porównanie mniejsze niż lub równe
NOT_EQUAL Porównanie „nie równa się”
CMP Porównanie ogólne

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 FALSE.

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("rating").equal(5).as_("hasPerfectRating"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(equal(field("rating"), 5).as("hasPerfectRating"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.Equal(firestore.FieldOf("rating"), 5).As("hasPerfectRating"),
	)).
	Execute(ctx)

GREATER_THAN

Składnia:

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

Opis:

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

Jeśli wartości x i y są nieporównywalne, zwraca 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();

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("rating").greaterThan(4).alias("hasHighRating"))
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(greaterThan(field("rating"), 4).as("hasHighRating"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.GreaterThan(firestore.FieldOf("rating"), 4).As("hasHighRating"),
	)).
	Execute(ctx)

GREATER_THAN_OR_EQUAL

Składnia:

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

Opis:

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

Jeśli wartości x i y są nieporównywalne, zwraca 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();

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("published").greaterThanOrEqual(1900).alias("publishedIn20thCentury"))
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(greaterThanOrEqual(field("published"), 1900).as("publishedIn20thCentury"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.GreaterThanOrEqual(firestore.FieldOf("published"), 1900).As("publishedIn20thCentury"),
	)).
	Execute(ctx)

LESS_THAN

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 są nieporównywalne, zwraca 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();

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("published").lessThan(1923).alias("isPublicDomainProbably"))
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(lessThan(field("published"), 1923).as("isPublicDomainProbably"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.LessThan(firestore.FieldOf("published"), 1923).As("isPublicDomainProbably"),
	)).
	Execute(ctx)

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 są nieporównywalne, zwraca 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();

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("rating").lessThanOrEqual(2).alias("hasBadRating"))
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(lessThanOrEqual(field("rating"), 2).as("hasBadRating"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.LessThanOrEqual(firestore.FieldOf("rating"), 2).As("hasBadRating"),
	)).
	Execute(ctx)

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();

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("title").notEqual("1984").alias("not1984"))
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(notEqual(field("title"), "1984").as("not1984"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.NotEqual(firestore.FieldOf("title"), "1984").As("not1984"),
	)).
	Execute(ctx)

PC

Składnia:

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

Opis:

Porównuje x i y, zwracając:

  • 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 na różnych typach, zgodnie z tą samą kolejnością, która jest używana na etapie sort(...). Informacje o tym, jak wartości są porządkowane według typów, 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ą nieobecną
IS_ABSENT Zwraca TRUE, jeśli wartość jest wartością nieobecną
IF_ABSENT Zastępuje wartość wyrażeniem, jeśli jest nieobecna
IS_ERROR Przechwytuje 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

EXISTS

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();

Web

Przykład:

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

Kotlin

Przykład:

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

Java

Przykład:

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

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("rating").exists().as_("hasRating"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(exists(field("rating")).as("hasRating"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.FieldExists(firestore.FieldOf("rating")).As("hasRating"),
	)).
	Execute(ctx)

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 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 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 try wystąpi błąd, funkcja ocenia i zwraca replacement. W przeciwnym razie zwraca wartość try.

BŁĄD

Składnia:

error(message: STRING) -> ANY

Opis:

Wyznaczenie wartości funkcji error powoduje, że ocena potoku kończy się 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łań

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

Nazwa Opis
COLLECTION_ID Zwraca identyfikator kolekcji liści w podanym odwołaniu.
DOCUMENT_ID Zwraca identyfikator dokumentu w podanym odwołaniu
PARENT Zwraca odwołanie do elementu nadrzędnego
REFERENCE_SLICE Zwraca podzbiór segmentów z danego pliku referencyjnego.

COLLECTION_ID

Składnia:

collection_id(ref: REFERENCE) -> STRING

Opis:

Zwraca identyfikator kolekcji liści dla 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 dla podanego elementu REFERENCE.

Przykłady:

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

RODZIC

Składnia:

parent(ref: REFERENCE) -> REFERENCE

Opis:

Zwraca nadrzędny element 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 krotek (collection_id, document_id), która umożliwia wyświetlenie 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 pliku referencyjnego.
  • length: liczba segmentów, które mają być uwzględnione 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 logiczne 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 dowolnemu 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 iloczyn logiczny co najmniej 2 wartości logicznych.

Zwraca NULL, jeśli nie można uzyskać wyniku, ponieważ dowolna 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();

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    and(field("rating").greaterThan(4), field("price").lessThan(10))
      .as("under10Recommendation")
  )
);
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([
    (Field("rating").greaterThan(4) && Field("price").lessThan(10))
      .as("under10Recommendation")
  ])
  .execute()

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        Expression.and(
            field("rating").greaterThan(4),
            field("price").lessThan(10)
        ).alias("under10Recommendation")
    )
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            and(greaterThan(field("rating"), 4), lessThan(field("price"), 10))
                .as("under10Recommendation"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.And(
			firestore.GreaterThan(firestore.FieldOf("rating"), 4),
			firestore.LessThan(firestore.FieldOf("price"), 10),
		).As("under10Recommendation"),
	)).
	Execute(ctx)

LUB

Składnia:

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

Opis:

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

Zwraca NULL, jeśli nie można uzyskać wyniku, ponieważ dowolna 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();

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    or(field("genre").equal("Fantasy"), field("tags").arrayContains("adventure"))
      .as("matchesSearchFilters")
  )
);
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([
    (Field("genre").equal("Fantasy") || Field("tags").arrayContains("adventure"))
      .as("matchesSearchFilters")
  ])
  .execute()

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        Expression.or(
            field("genre").equal("Fantasy"),
            field("tags").arrayContains("adventure")
        ).alias("matchesSearchFilters")
    )
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            or(equal(field("genre"), "Fantasy"), arrayContains(field("tags"), "adventure"))
                .as("matchesSearchFilters"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.Or(
			firestore.Equal(firestore.FieldOf("genre"), "Fantasy"),
			firestore.ArrayContains(firestore.FieldOf("tags"), "adventure"),
		).As("matchesSearchFilters"),
	)).
	Execute(ctx)

XOR

Składnia:

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

Opis:

Zwraca logiczną alternatywę wykluczającą (XOR) co najmniej 2 wartości logicznych.

Zwraca wartość NULL, jeśli dowolna 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")
  )
);

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    xor(field("tags").arrayContains("magic"), field("tags").arrayContains("nonfiction"))
      .as("matchesSearchFilters")
  )
);
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([
    (Field("tags").arrayContains("magic") ^ Field("tags").arrayContains("nonfiction"))
      .as("matchesSearchFilters")
  ])
  .execute()

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        Expression.xor(
            field("tags").arrayContains("magic"),
            field("tags").arrayContains("nonfiction")
        ).alias("matchesSearchFilters")
    )
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            xor(
                    arrayContains(field("tags"), "magic"),
                    arrayContains(field("tags"), "nonfiction"))
                .as("matchesSearchFilters"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.Xor(
			firestore.ArrayContains(firestore.FieldOf("tags"), "magic"),
			firestore.ArrayContains(firestore.FieldOf("tags"), "nonfiction"),
		).As("matchesSearchFilters"),
	)).
	Execute(ctx)

NOR

Składnia:

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

Opis:

Zwraca logiczną wartość NOR co najmniej 2 wartości logicznych.

Zwraca NULL, jeśli nie można uzyskać wyniku, ponieważ dowolna 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 logiczne zaprzeczenie wartości logicznej.

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

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("tags").arrayContains("nonfiction").not()
      .as("isFiction")
  )
);
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([
    (!Field("tags").arrayContains("nonfiction"))
      .as("isFiction")
  ])
  .execute()

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        Expression.not(
            field("tags").arrayContains("nonfiction")
        ).alias("isFiction")
    )
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(not(arrayContains(field("tags"), "nonfiction")).as("isFiction"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.Not(firestore.ArrayContains(firestore.FieldOf("tags"), "nonfiction")).As("isFiction"),
	)).
	Execute(ctx)

WARUNKOWY

Składnia:

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

Opis:

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

Analizuje i zwraca wartość false_case, jeśli warunek ma 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")
  )
);

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("tags").arrayConcat([
      field("pages").greaterThan(100)
        .conditional(constant("longRead"), constant("shortRead"))
    ]).as("extendedTags")
  )
);
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()

Kotlin

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

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();
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()
)
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();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.ArrayConcat(
			firestore.FieldOf("tags"),
			firestore.Conditional(
				firestore.GreaterThan(firestore.FieldOf("pages"), 100),
				firestore.ConstantOf("longRead"),
				firestore.ConstantOf("shortRead"),
			),
		).As("extendedTags"),
	)).
	Execute(ctx)

IF_NULL

Składnia:

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

Opis:

Zwraca expr, jeśli nie jest to NULL, w przeciwnym razie ocenia i zwraca replacement. Wyrażenie replacement nie jest oceniane, jeśli używane jest 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 zostanie oceniony jako TRUE, zwracana jest wartość default (jeśli została podana). Jeśli nie podano wartości default, a żaden inny warunek nie został oceniony jako TRUE, wystąpi 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 „other”

EQUAL_ANY

Składnia:

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

Opis:

Zwraca wartość 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")
  )
);

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("genre").equalAny(Arrays.asList("Science Fiction", "Psychological Thriller"))
            .alias("matchesGenreFilters")
    )
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            equalAny(field("genre"), Arrays.asList("Science Fiction", "Psychological Thriller"))
                .as("matchesGenreFilters"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.EqualAny(firestore.FieldOf("genre"), []string{"Science Fiction", "Psychological Thriller"}).As("matchesGenreFilters"),
	)).
	Execute(ctx)

NOT_EQUAL_ANY

Składnia:

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

Opis:

Zwraca TRUE, jeśli value nie znajduje się 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")
  )
);

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("author").notEqualAny(Arrays.asList("George Orwell", "F. Scott Fitzgerald"))
            .alias("byExcludedAuthors")
    )
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            notEqualAny(field("author"), Arrays.asList("George Orwell", "F. Scott Fitzgerald"))
                .as("byExcludedAuthors"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.NotEqualAny(firestore.FieldOf("author"), []string{"George Orwell", "F. Scott Fitzgerald"}).As("byExcludedAuthors"),
	)).
	Execute(ctx)

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 wiele maksymalnych równoważnych wartości, może zostać zwrócona dowolna 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"))
);

Web

const result = await execute(db.pipeline()
  .collection("books")
  .aggregate(field("price").maximum().as("maximumPrice"))
);
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("rating").logicalMaximum([1]).as("flooredRating")
  ])
  .execute()

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("rating").logicalMaximum(1).alias("flooredRating")
    )
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(logicalMaximum(field("rating"), 1).as("flooredRating"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.LogicalMaximum(firestore.FieldOf("rating"), 1).As("flooredRating"),
	)).
	Execute(ctx)

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 równoważnych wartości, może zostać zwrócona dowolna 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"))
);

Web

const result = await execute(db.pipeline()
  .collection("books")
  .aggregate(field("price").minimum().as("minimumPrice"))
);
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("rating").logicalMinimum([5]).as("cappedRating")
  ])
  .execute()

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("rating").logicalMinimum(5).alias("cappedRating")
    )
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(logicalMinimum(field("rating"), 5).as("cappedRating"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.LogicalMinimum(firestore.FieldOf("rating"), 5).As("cappedRating"),
	)).
	Execute(ctx)

Funkcje mapy

Nazwa Opis
MAP Tworzy wartość mapy z serii par klucz-wartość
MAP_GET Zwraca wartość w mapie dla 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 w mapie.
MAP_VALUES Zwraca tablicę wszystkich wartości w mapie.
MAP_ENTRIES Zwraca tablicę par klucz-wartość mapy.

MAPA

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 dla określonego klucza. Zwraca wartość ABSENT, jeśli key nie istnieje na mapie lub jeśli argument map nie jest MAP.

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

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("awards").mapGet("pulitzer").alias("hasPulitzerAward")
    )
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(mapGet(field("awards"), "pulitzer").as("hasPulitzerAward"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.MapGet(firestore.FieldOf("awards"), "pulitzer").As("hasPulitzerAward"),
	)).
	Execute(ctx)

MAP_SET

Składnia:

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

Opis:

Zwraca kopię wartości map z zawartością zaktualizowaną przez serię par klucz-wartość.

Jeśli podana wartość zostanie rozwiązana do wartości nieobecnej, powiązany klucz zostanie usunięty z mapy.

Jeśli argument map nie jest typu MAP, zwraca brak wartości.

MAP_REMOVE

Składnia:

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

Opis:

Zwraca kopię wartości map z usuniętą serią kluczy.

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 wykonywania.

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 wartości 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 operujące na ciągach znaków

Nazwa Opis
BYTE_LENGTH Zwraca liczbę BYTES w wartości STRING lub BYTES
CHAR_LENGTH Zwraca liczbę znaków Unicode w wartości STRING
STARTS_WITH Zwraca TRUE, jeśli STRING zaczyna się od podanego prefiksu
ENDS_WITH Zwraca TRUE, jeśli STRING kończy się podanym sufiksem
LIKE Zwraca wartość TRUE, jeśli STRING pasuje do wzorca
REGEX_CONTAINS Zwraca TRUE, jeśli wartość częściowo lub całkowicie pasuje do wyrażenia regularnego
REGEX_MATCH Zwraca TRUE, jeśli dowolna część wartości pasuje do wyrażenia regularnego
STRING_CONCAT Łączy wiele obiektów STRING w obiekt STRING
STRING_CONTAINS Zwraca TRUE, jeśli wartość zawiera STRING
STRING_INDEX_OF Zwraca indeks (liczony od 0) pierwszego wystąpienia wartości STRING lub BYTES.
TO_UPPER Konwertuje wartość STRING lub BYTES na wielkie litery.
TO_LOWER Przekształca wartość STRING lub BYTES na małe litery.
SUBSTRING Pobiera podłańcuch 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 początkowe i końcowe znaki z wartości STRING lub BYTES.
LTRIM Usuwa początkowe znaki z 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ę 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();

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("title").byte_length().as_("titleByteLength"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(byteLength(field("title")).as("titleByteLength"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.ByteLength(firestore.FieldOf("title")).As("titleByteLength"),
	)).
	Execute(ctx)

CHAR_LENGTH

Składnia:

char_length(value: STRING) -> INT64

Opis:

Zwraca liczbę punktów kodowych Unicode w wartości STRING.

Przykłady:

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("title").char_length().as_("titleCharLength"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(charLength(field("title")).as("titleCharLength"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.CharLength(firestore.FieldOf("title")).As("titleCharLength"),
	)).
	Execute(ctx)

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();

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("title").startsWith("The")
            .alias("needsSpecialAlphabeticalSort")
    )
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(startsWith(field("title"), "The").as("needsSpecialAlphabeticalSort"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.StartsWith(firestore.FieldOf("title"), "The").As("needsSpecialAlphabeticalSort"),
	)).
	Execute(ctx)

ENDS_WITH

Składnia:

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

Opis:

Zwraca TRUE, jeśli value kończy się na 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();
Swift
let result = try await db.pipeline()
  .collection("inventory/devices/laptops")
  .select([
    Field("name").endsWith("16 inch")
      .as("16InLaptops")
  ])
  .execute()

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("inventory/devices/laptops")
    .select(
        field("name").endsWith("16 inch")
            .alias("16InLaptops")
    )
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("inventory/devices/laptops")
        .select(endsWith(field("name"), "16 inch").as("16InLaptops"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("inventory/devices/laptops").
	Select(firestore.Fields(
		firestore.EndsWith(firestore.FieldOf("name"), "16 inch").As("`Laptops16in`"),
	)).
	Execute(ctx)

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();

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("genre").like("%Fiction").as_("anyFiction"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(like(field("genre"), "%Fiction").as("anyFiction"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.Like(firestore.FieldOf("genre"), "%Fiction").As("anyFiction"),
	)).
	Execute(ctx)

REGEX_CONTAINS

Składnia:

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

Opis:

Zwraca wartość TRUE, jeśli jakaś część ciągu value pasuje do ciągu pattern. Jeśli pattern nie jest prawidłowym wyrażeniem regularnym, funkcja zwraca błąd 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" "data" fałsz
Node.js
const result = await db.pipeline()
  .collection("documents")
  .select(
    field("title").regexContains("Firestore (Enterprise|Standard)")
      .as("isFirestoreRelated")
  )
  .execute();

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("title").regexContains("Firestore (Enterprise|Standard)")
            .alias("isFirestoreRelated")
    )
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(
            regexContains(field("title"), "Firestore (Enterprise|Standard)")
                .as("isFirestoreRelated"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("documents").
	Select(firestore.Fields(
		firestore.RegexContains(firestore.FieldOf("title"), "Firestore (Enterprise|Standard)").As("isFirestoreRelated"),
	)).
	Execute(ctx)

REGEX_MATCH

Składnia:

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

Opis:

Zwraca TRUE, jeśli value w pełni pasuje do pattern. Jeśli pattern nie jest prawidłowym wyrażeniem regularnym, funkcja zwraca błąd 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();

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("title").regexMatch("Firestore (Enterprise|Standard)")
            .alias("isFirestoreExactly")
    )
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(
            regexMatch(field("title"), "Firestore (Enterprise|Standard)")
                .as("isFirestoreExactly"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("documents").
	Select(firestore.Fields(
		firestore.RegexMatch(firestore.FieldOf("title"), "Firestore (Enterprise|Standard)").As("isFirestoreExactly"),
	)).
	Execute(ctx)

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();

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("title").concat(" by ", field("author"))
            .alias("fullyQualifiedTitle")
    )
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(stringConcat(field("title"), " by ", field("author")).as("fullyQualifiedTitle"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.StringConcat(firestore.FieldOf("title"), " by ", firestore.FieldOf("author")).As("fullyQualifiedTitle"),
	)).
	Execute(ctx)

STRING_CONTAINS

Składnia:

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

Opis:

Sprawdza, czy value zawiera ciąg znaków 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();

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("articles")
    .select(
        field("body").stringContains("Firestore")
            .alias("isFirestoreRelated")
    )
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("articles")
        .select(stringContains(field("body"), "Firestore").as("isFirestoreRelated"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("articles").
	Select(firestore.Fields(
		firestore.StringContains(firestore.FieldOf("body"), "Firestore").As("isFirestoreRelated"),
	)).
	Execute(ctx)

STRING_INDEX_OF

Składnia:

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

Opis:

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

  • Zwraca -1, jeśli nie znaleziono 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 search jest pustą wartością STRING lub BYTES, wynik to 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:

Konwertuje wartość STRING lub BYTES na wielkie litery.

Jeśli bajt lub znak nie odpowiada małej literze 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();

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("authors")
    .select(Field.of("name").to_upper().as_("uppercaseName"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("authors")
        .select(toUpper(field("name")).as("uppercaseName"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("authors").
	Select(firestore.Fields(
		firestore.ToUpper(firestore.FieldOf("name")).As("uppercaseName"),
	)).
	Execute(ctx)

TO_LOWER

Składnia:

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

Opis:

Przekształca 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();

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("authors")
    .select(
        field("genre").toLower().equal("fantasy")
            .alias("isFantasy")
    )
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("authors")
        .select(equal(toLower(field("genre")), "fantasy").as("isFantasy"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("authors").
	Select(firestore.Fields(
		firestore.Equal(firestore.ToLower(firestore.FieldOf("genre")), "fantasy").As("isFantasy"),
	)).
	Execute(ctx)

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 znaków input zaczynający się od position (indeks zaczyna się od 0) i zawierający maksymalnie length wpisów. Jeśli nie podano parametru length, zwraca podłańcuch od position do końca 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 position jest większy niż długość input, zwracany jest pusty podłańcuch. Jeśli suma position i length jest większa niż długość input, podłańcuch jest skracany do końca input.

  • Jeśli argument position jest ujemny, pozycja jest liczona od końca danych wejściowych. Jeśli ujemna wartość position jest większa niż rozmiar danych wejściowych, pozycja jest ustawiana na 0. Wartość length nie może być ujemna.

Przykłady:

Jeśli nie podano parametru 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 parametr 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();

Web

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

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()

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();
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()
)
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();
Go
snapshot := client.Pipeline().
	Collection("books").
	Where(firestore.StartsWith(firestore.FieldOf("title"), "The ")).
	Select(firestore.Fields(
		firestore.Substring(firestore.FieldOf("title"), firestore.ConstantOf(4), firestore.FieldOf("title").CharLength()).As("titleWithoutLeadingThe"),
	)).
	Execute(ctx)

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 to STRING, i przez bajty, gdy dane wejściowe to wartość 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();

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("name").string_reverse().as_("reversedName"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(reverse(field("name")).as("reversedName"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.Reverse(firestore.FieldOf("name")).As("reversedName"),
	)).
	Execute(ctx)

STRING_REPEAT

Składnia:

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

Opis:

Zwraca input powtórzony 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:

Zastępuje wszystkie nienakładające się wystąpienia ciągu find w ciągu input ciągiem replacement.

  • Wielkość liter ma znaczenie.
  • Jeśli parametr find jest pusty, nie są wprowadzane żadne zastąpienia.

Przykłady:

wprowadzanie danych znajdź wymiana, 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.

  • Wielkość liter ma znaczenie.
  • Jeśli parametr find jest pusty, nie są wprowadzane żadne zastąpienia.

Przykłady:

wprowadzanie danych znajdź wymiana, 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 argumentu values_to_trim, usuwa znaki odstępu.

Przykłady:

Jeśli nie podano parametru 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 parametr 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")
  )
);
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("name").trim(" \n\t").as("whitespaceTrimmedName")
  ])
  .execute()

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("name").trim().as_("whitespaceTrimmedName"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(trim(field("name")).as("whitespaceTrimmedName"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.Trim(firestore.FieldOf("name")).As("whitespaceTrimmedName"),
	)).
	Execute(ctx)

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 nie podano argumentu to_trim, usuwa początkowe znaki odstępu.

Przykłady:

Jeśli nie podano parametru to_trim:

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

Gdy podano parametr 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 ciągu value.

  • Jeśli nie podano argumentu to_trim, usuwa końcowe znaki odstępu.

Przykłady:

Jeśli nie podano parametru to_trim:

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

Gdy podano parametr to_trim:

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

WYDZIEL

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ą separatora.

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

  • W przypadku BYTES musisz określić separator.

  • Podział na pusty separator daje tablicę punktów kodowych Unicode dla wartości STRING i tablicę BYTES dla wartości BYTES.

  • Podział pustego elementu STRING zwraca element ARRAY z jednym pustym elementem STRING.

Przykłady:

Jeśli nie podano parametru delimiter:

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

Gdy podano parametr 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ący czasowi żądania.
TIMESTAMP_TRUNC Skraca TIMESTAMP do podanej szczegółowości.
UNIX_MICROS_TO_TIMESTAMP Konwertuje liczbę mikrosekund od 1970-01-01 00:00:00 UTC na TIMESTAMP
UNIX_MILLIS_TO_TIMESTAMP Konwertuje liczbę milisekund od 1970-01-01 00:00:00 UTC na TIMESTAMP
UNIX_SECONDS_TO_TIMESTAMP Konwertuje 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 Konwertuje TIMESTAMP na liczbę mikrosekund od 1970-01-01 00:00:00 UTC
TIMESTAMP_TO_UNIX_MILLIS Konwertuje TIMESTAMP na liczbę milisekund od 1970-01-01 00:00:00 UTC
TIMESTAMP_TO_UNIX_SECONDS Konwertuje 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 2 TIMESTAMP.
TIMESTAMP_EXTRACT Wyodrębnia określony element part (np. rok, miesiąc, dzień) z TIMESTAMP.

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 stabilna w ramach zapytania i zawsze zwraca tę samą wartość, jeśli zostanie wywołana wielokrotnie.

TIMESTAMP_TRUNC

Składnia:

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

Opis:

Skraca sygnaturę czasową do określonej szczegółowości.

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

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

Jeśli podano argument timezone, obcinanie będzie się odbywać na podstawie granic kalendarza w danej strefie czasowej (np. obcinanie dnia będzie obcinać do północy w danej strefie czasowej). Skracanie będzie uwzględniać czas letni.

Jeśli nie podasz argumentu 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 czasu, 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 "second" 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 "month" "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 input (interpretowane jako liczba mikrosekund od 1970-01-01 00:00:00 UTC) na TIMESTAMP. Zwraca błąd error, jeśli nie można przekonwertować input na prawidłowy 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();

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("createdAtMicros").unixMicrosToTimestamp().alias("createdAtString")
    )
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(unixMicrosToTimestamp(field("createdAtMicros")).as("createdAtString"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("documents").
	Select(firestore.Fields(
		firestore.UnixMicrosToTimestamp(firestore.FieldOf("createdAtMicros")).As("createdAtString"),
	)).
	Execute(ctx)

UNIX_MILLIS_TO_TIMESTAMP

Składnia:

unix_millis_to_timestamp(input: INT64) -> TIMESTAMP

Opis:

Konwertuje wartość input (interpretowaną jako liczba milisekund od 1970-01-01 00:00:00 UTC) na TIMESTAMP. Zwraca błąd error, jeśli nie można przekonwertować input na prawidłowy 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();

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("createdAtMillis").unixMillisToTimestamp().alias("createdAtString")
    )
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(unixMillisToTimestamp(field("createdAtMillis")).as("createdAtString"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("documents").
	Select(firestore.Fields(
		firestore.UnixMillisToTimestamp(firestore.FieldOf("createdAtMillis")).As("createdAtString"),
	)).
	Execute(ctx)

UNIX_SECONDS_TO_TIMESTAMP

Składnia:

unix_seconds_to_timestamp(input: INT64) -> TIMESTAMP

Opis:

Przekształca wartość input (interpretowaną jako liczba sekund od 1970-01-01 00:00:00 UTC) w TIMESTAMP. Zwraca błąd error, jeśli nie można przekonwertować input na prawidłowy 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();

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("createdAtSeconds").unixSecondsToTimestamp().alias("createdAtString")
    )
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(unixSecondsToTimestamp(field("createdAtSeconds")).as("createdAtString"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("documents").
	Select(firestore.Fields(
		firestore.UnixSecondsToTimestamp(firestore.FieldOf("createdAtSeconds")).As("createdAtString"),
	)).
	Execute(ctx)

TIMESTAMP_ADD

Składnia:

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

Opis:

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

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

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

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

Przykłady:

timestamp unit amount timestamp_add(timestamp, unit, amount)
2025-02-20 00:00:00 UTC "minute" 2L 2025-02-20 00:02:00 UTC
2025-02-20 00:00:00 UTC "hour" -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();

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("createdAt").timestampAdd("day", 3653).alias("expiresAt")
    )
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(timestampAdd(field("createdAt"), "day", 3653).as("expiresAt"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("documents").
	Select(firestore.Fields(
		firestore.TimestampAdd(firestore.FieldOf("createdAt"), "day", 3653).As("expiresAt"),
	)).
	Execute(ctx)

TIMESTAMP_SUB

Składnia:

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

Opis:

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

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

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

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

Przykłady:

timestamp unit amount timestamp_sub(timestamp, unit, amount)
2026-07-04 00:00:00 UTC "minute" 40L 2026-07-03 23:20:00 UTC
2026-07-04 00:00:00 UTC „hour” -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();

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("expiresAt").timestampSubtract("day", 14).alias("sendWarningTimestamp")
    )
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(timestampSubtract(field("expiresAt"), "day", 14).as("sendWarningTimestamp"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("documents").
	Select(firestore.Fields(
		firestore.TimestampSubtract(firestore.FieldOf("expiresAt"), "day", 14).As("sendWarningTimestamp"),
	)).
	Execute(ctx)

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 dokładności, 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();

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("dateString").timestampToUnixMicros().alias("unixMicros")
    )
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(timestampToUnixMicros(field("dateString")).as("unixMicros"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("documents").
	Select(firestore.Fields(
		firestore.TimestampToUnixMicros(firestore.FieldOf("dateString")).As("unixMicros"),
	)).
	Execute(ctx)

TIMESTAMP_TO_UNIX_MILLIS

Składnia:

timestamp_to_unix_millis(input: TIMESTAMP) -> INT64

Opis:

Przekształca wartość input w liczbę milisekund, które upłynęły 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();

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("dateString").timestampToUnixMillis().alias("unixMillis")
    )
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(timestampToUnixMillis(field("dateString")).as("unixMillis"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("documents").
	Select(firestore.Fields(
		firestore.TimestampToUnixMillis(firestore.FieldOf("dateString")).As("unixMillis"),
	)).
	Execute(ctx)

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();

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("dateString").timestampToUnixSeconds().alias("unixSeconds")
    )
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(timestampToUnixSeconds(field("dateString")).as("unixSeconds"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("documents").
	Select(firestore.Fields(
		firestore.TimestampToUnixSeconds(firestore.FieldOf("dateString")).As("unixSeconds"),
	)).
	Execute(ctx)

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 2 TIMESTAMP.

  • Zwraca wartość ujemną, jeśli end jest przed start.
  • Obcina wszystkie jednostki ułamkowe. 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 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 "second" 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 "minute" 0L

TIMESTAMP_EXTRACT

Składnia:

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

Opis:

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

Argument part musi być ciągiem znaków i 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 dla pierwszej niedzieli w roku.
  • week([weekday]): zwraca numer tygodnia w roku, zaczynając od określonego dnia (weekday).
  • month
  • quarter
  • year
  • isoweek: zwraca numer tygodnia w formacie ISO 8601.
  • isoyear: zwraca rok według numeracji tygodni ISO 8601.

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

Jeśli nie podasz właściwości timezone, wyodrębnianie będzie oparte na właściwoś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 czasu, 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
31 grudnia 2025 r., 23:59:59 UTC "year" "Asia/Tokyo" 2026

Funkcje typów

Nazwa Opis
TYPE Zwraca typ wartości jako STRING.
IS_TYPE Zwraca true, jeśli wartość jest zgodna z określonym typem.

TYP

Składnia:

type(input: ANY) -> STRING

Opis:

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

Jeśli podano brakującą wartość, 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" "bytes"
[1, 2] "array"
{"a": 1} „mapa”
path("c/d") "reference"
vector([1.0, 2.0]) "vector"
BRAK NULL

Przykłady klientów

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

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("title").notEqual("1984").alias("not1984"))
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(notEqual(field("title"), "1984").as("not1984"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.NotEqual(firestore.FieldOf("title"), "1984").As("not1984"),
	)).
	Execute(ctx)

IS_TYPE

Składnia:

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

Opis:

Zwraca true, jeśli input pasuje do określonego type, w przeciwnym razie zwraca false. Jeśli nie podano argumentu input, zwraca 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} „mapa” prawda
vector([1.0, 2.0]) "vector" prawda
BRAK "string" NULL
„bar” „other” BŁĄD

Funkcje wektorowe

Nazwa Opis
COSINE_DISTANCE Zwraca odległość cosinusową między 2 wektorami
DOT_PRODUCT Zwraca iloczyn skalarny 2 wektorów.
EUCLIDEAN_DISTANCE Zwraca odległość euklidesową między 2 wektorami
MANHATTAN_DISTANCE Zwraca odległość Manhattanu między 2 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();

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")));
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()

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()

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();
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()
)
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();
Go
sampleVector := []float64{0.0, 1.0, 2.0, 3.0, 4.0, 5.0}
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.CosineDistance(firestore.FieldOf("embedding"), sampleVector).As("cosineDistance"),
	)).
	Execute(ctx)

DOT_PRODUCT

Składnia:

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

Opis:

Zwraca iloczyn skalarny 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();

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")
  )
);
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()

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()

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();
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()
)
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();
Go
sampleVector := []float64{0.0, 1.0, 2.0, 3.0, 4.0, 5.0}
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.DotProduct(firestore.FieldOf("embedding"), sampleVector).As("dotProduct"),
	)).
	Execute(ctx)

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();

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")
  )
);
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()

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()

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();
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()
)
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();
Go
sampleVector := []float64{0.0, 1.0, 2.0, 3.0, 4.0, 5.0}
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.EuclideanDistance(firestore.FieldOf("embedding"), sampleVector).As("euclideanDistance"),
	)).
	Execute(ctx)

MANHATTAN_DISTANCE

Składnia:

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

Opis:

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

VECTOR_LENGTH

Składnia:

vector_length(vector: VECTOR) -> INT64

Opis:

Zwraca liczbę elementów w obiekcie VECTOR.

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("embedding").vector_length().as_("vectorLength"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(vectorLength(field("embedding")).as("vectorLength"))
        .execute()
        .get();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.VectorLength(firestore.FieldOf("embedding")).As("vectorLength"),
	)).
	Execute(ctx)