כל הפונקציות

Aggregate

אפשר להשתמש בכל הפונקציות המצטברות כביטויים ברמה העליונה בשלב aggregate(...).

שם תיאור
COUNT הפונקציה מחזירה את מספר המסמכים.
COUNT_IF הפונקציה מחזירה את מספר המסמכים שבהם הערך של הביטוי הוא TRUE
COUNT_DISTINCT הפונקציה מחזירה את מספר הערכים הייחודיים שאינם NULL
SUM מחזירה את הסכום של כל הערכים של NUMERIC
AVERAGE הפונקציה מחזירה את הממוצע של כל הערכים של NUMERIC
MINIMUM מחזירה את הערך המינימלי שאינו NULL
MAXIMUM מחזירה את הערך המקסימלי שאינו NULL
FIRST הפונקציה מחזירה את הערך expression עבור המסמך הראשון.
LAST הפונקציה מחזירה את הערך expression עבור המסמך האחרון.
ARRAY_AGG הפונקציה מחזירה מערך של כל ערכי הקלט.
ARRAY_AGG_DISTINCT הפונקציה מחזירה מערך של כל ערכי הקלט השונים.

COUNT

תחביר:

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

תיאור:

הפונקציה מחזירה את מספר המסמכים מהשלב הקודם שבהם expression הערך שמתקבל הוא לא NULL. אם לא מציינים expression, הפונקציה מחזירה את המספר הכולל של המסמכים מהשלב הקודם.

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

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

Web

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

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

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

Kotlin

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

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

Java

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

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

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

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

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

COUNT_IF

תחביר:

count_if(expression: BOOLEAN) -> INT64

תיאור:

הפונקציה מחזירה את מספר המסמכים מהשלב הקודם שבהם הערך של expression הוא TRUE.

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

Web

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

Kotlin

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

Java

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

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

COUNT_DISTINCT

תחביר:

count_distinct(expression: ANY) -> INT64

תיאור:

הפונקציה מחזירה את מספר הערכים הייחודיים של expression שאינם NULL ואינם ABSENT.

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

Web

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

Kotlin

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

Java

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

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

SUM

תחביר:

sum(expression: ANY) -> NUMBER

תיאור:

הפונקציה מחזירה את הסכום של כל הערכים המספריים, תוך התעלמות מערכים לא מספריים. הפונקציה מחזירה NaN אם אחד מהערכים הוא NaN.

הפלט יהיה מאותו סוג כמו סוג הקלט הרחב ביותר, למעט במקרים הבאים:

  • אם אי אפשר לייצג INTEGER כ-INTEGER, הוא יומר ל-DOUBLE.
Node.js
const result = await db.pipeline()
  .collection("cities")
  .aggregate(field("population").sum().as("totalPopulation"))
  .execute();
test.firestore.js

Web

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

Kotlin

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

Java

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

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

AVERAGE

תחביר:

average(expression: ANY) -> FLOAT64

תיאור:

הפונקציה מחזירה את הממוצע של כל הערכים המספריים, תוך התעלמות מערכים לא מספריים. הפונקציה מחזירה NaN אם אחד מהערכים הוא NaN, או NULL אם לא מצורפים ערכים מספריים.

הפלט יהיה מאותו סוג כמו סוג הקלט, למעט במקרים הבאים:

  • אם אי אפשר לייצג INTEGER כ-INTEGER, הוא יומר ל-DOUBLE.
Node.js
const result = await db.pipeline()
  .collection("cities")
  .aggregate(field("population").average().as("averagePopulation"))
  .execute();
test.firestore.js

Web

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

Kotlin

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

Java

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

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

MINIMUM

תחביר:

minimum(expression: ANY) -> ANY

תיאור:

הפונקציה מחזירה את הערך המינימלי של המאפיין expression שלא שווה ל-NULL ולא חסר, כשמבצעים הערכה של כל מסמך.

אם אין ערכים שהם לא NULL ולא חסרים, הפונקציה מחזירה NULL. כולל מצבים שבהם לא נלקחים בחשבון מסמכים.

אם יש כמה ערכים מינימליים שווים, הפונקציה יכולה להחזיר כל אחד מהם. סדר סוגי הערכים הוא לפי הסדר שמופיע במסמכים.

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

Web

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

Kotlin

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

Java

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

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

מקסימום

תחביר:

maximum(expression: ANY) -> ANY

תיאור:

הפונקציה מחזירה את הערך המקסימלי של expression שאינו NULL ושאינו חסר, כשמבצעים הערכה בכל מסמך.

אם אין ערכים שהם לא NULL ולא חסרים, הפונקציה מחזירה NULL. כולל מצבים שבהם לא נלקחים בחשבון מסמכים.

אם יש כמה ערכים מקסימליים שווים, הפונקציה יכולה להחזיר כל אחד מהם. סדר סוגי הערכים הוא לפי הסדר שמופיע במסמכים.

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

Web

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

Kotlin

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

Java

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

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

FIRST

תחביר:

first(expression: ANY) -> ANY

תיאור:

הפונקציה מחזירה את הערך של expression עבור המסמך הראשון שמוחזר.

LAST

תחביר:

last(expression: ANY) -> ANY

תיאור:

הפונקציה מחזירה את הערך expression עבור המסמך האחרון שהוחזר.

ARRAY_AGG

תחביר:

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

תיאור:

הפונקציה מחזירה מערך שמכיל את כל הערכים של expression כשמבצעים הערכה בכל מסמך.

אם הביטוי מומר לערך חסר, הוא מומר ל-NULL.

סדר הרכיבים במערך הפלט לא יציב, ואין להסתמך עליו.

ARRAY_AGG_DISTINCT

תחביר:

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

תיאור:

הפונקציה מחזירה מערך שמכיל את כל הערכים הנפרדים של expression כשמבצעים הערכה בכל מסמך.

אם הביטוי מומר לערך חסר, הוא מומר ל-NULL.

סדר הרכיבים במערך הפלט לא יציב, ואין להסתמך עליו.

פונקציות אריתמטיות

כל הפונקציות האריתמטיות ב-Cloud Firestore פועלות באופן הבא:

  • הפונקציה מחזירה את הערך NULL אם אחד מפרמטרי הקלט הוא NULL.
  • הפונקציה מחזירה את הערך NaN אם אחד מהארגומנטים הוא NaN.
  • יוצרת שגיאה אם מתרחש גלישה או חוסר גלישה.

בנוסף, כשפונקציה אריתמטית מקבלת כמה ארגומנטים מספריים מסוגים שונים (לדוגמה: add(5.0, 6)), הפונקציה Cloud Firestore ממירה את הארגומנטים באופן מרומז לסוג הקלט הרחב ביותר. אם מספקים רק קלט של INT32, סוג ההחזרה יהיה INT64.

שם תיאור
ABS מחזירה את הערך המוחלט של number
ADD הפונקציה מחזירה את הערך של x + y
SUBTRACT הפונקציה מחזירה את הערך של x - y
MULTIPLY הפונקציה מחזירה את הערך של x * y
DIVIDE הפונקציה מחזירה את הערך של x / y
MOD מחזירה את השארית של החלוקה של x / y
CEIL מחזירה את הערך העגול כלפי מעלה של number
FLOOR הפונקציה מחזירה את הערך של number מעוגל כלפי מטה
ROUND מעגלת את number ל-places ספרות אחרי הנקודה העשרונית
TRUNC חיתוך של number ל-places ספרות אחרי הנקודה העשרונית
POW הפונקציה מחזירה את הערך של base^exponent
SQRT הפונקציה מחזירה את השורש הריבועי של number
EXP מחזירה את מספר אוילר בחזקת exponent
LN הפונקציה מחזירה את הלוגריתם הטבעי של number
LOG מחזירה את הלוגריתם של number
LOG10 הפונקציה מחזירה את הלוגריתם של number לפי בסיס 10
RAND הפונקציה מחזירה מספר פסאודו-אקראי בשיטת נקודה צפה

ABS

תחביר:

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

תיאור:

מחזירה את הערך המוחלט של number.

  • הפונקציה מחזירה שגיאה אם היא גורמת להצפת ערך מסוג INT32 או INT64.

לדוגמה:

מספר abs(number)
10 10
-10 10
‫10L ‫10L
‫-0.0 0.0
10.5 10.5
‫‎-10.5 10.5
‫-231 [error]
‫-263 [error]

הוספה

תחביר:

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

תיאור:

הפונקציה מחזירה את הערך של x + y.

לדוגמה:

x y add(x, y)
20 3 23
‫10.0 1 ‫11.0
22.5 2.0 24.5
INT64.MAX 1 [error]
INT64.MIN -1 [error]
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("soldBooks").add(field("unsoldBooks")).as("totalBooks"))
  .execute();
test.firestore.js

Web

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

Kotlin

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

Java

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

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

SUBTRACT

תחביר:

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

תיאור:

הפונקציה מחזירה את הערך של x - y.

לדוגמה:

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

Web

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

Kotlin

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

Java

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

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

MULTIPLY

תחביר:

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

תיאור:

הפונקציה מחזירה את הערך של x * y.

לדוגמה:

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

Web

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

Kotlin

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

Java

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

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

DIVIDE

תחביר:

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

תיאור:

הפונקציה מחזירה את הערך של x / y. התוצאה של חילוק מספרים שלמים מעוגלת כלפי מטה.

לדוגמה:

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

Web

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

Kotlin

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

Java

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

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

מתמר

תחביר:

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

תיאור:

הפונקציה מחזירה את השארית של x / y.

  • הפונקציה מחזירה שגיאה מסוג error אם y הוא אפס עבור סוגי מספרים שלמים (INT64).
  • מחזירה NaN אם y הוא אפס עבור סוגי נתונים מסוג float ‏ (FLOAT64).

לדוגמה:

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

Web

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

Kotlin

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

Java

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

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

CEIL

תחביר:

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

תיאור:

הפונקציה מחזירה את הערך השלם הקטן ביותר שלא קטן מ-number.

לדוגמה:

מספר ceil(number)
20 20
10 10
0 0
24L 24L
-0.4 ‫-0.0
0.4 1.0
22.5 23.0
+inf +inf
-inf -inf
Node.js
const booksPerShelf = 100;
const result = await db.pipeline()
  .collection("books")
  .select(
    field("unsoldBooks").divide(constant(booksPerShelf)).ceil().as("requiredShelves")
  )
  .execute();
test.firestore.js

Web

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

Kotlin

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

Java

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

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

FLOOR

תחביר:

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

תיאור:

הפונקציה מחזירה את הערך השלם הגדול ביותר שלא גדול מ-number.

לדוגמה:

מספר floor(number)
20 20
10 10
0 0
2147483648 2147483648
-0.4 ‫1.0-
0.4 0.0
22.5 22.0
+inf +inf
-inf -inf
Node.js
const result = await db.pipeline()
  .collection("books")
  .addFields(
    field("wordCount").divide(field("pages")).floor().as("wordsPerPage")
  )
  .execute();
test.firestore.js

Web

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

Kotlin

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

Java

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

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

ROUND

תחביר:

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

תיאור:

מעגלת places ספרות מתוך number. מעגלת ספרות מימין לנקודה העשרונית אם places חיובי, ומשמאל לנקודה העשרונית אם הוא שלילי.

  • אם מספקים רק את number, הפונקציה מעגלת למספר השלם הקרוב ביותר.
  • מעגל הרחק מהאפס במקרים של חציון.
  • אם העיגול עם ערך שלילי של places גורם לחריגה, מוצגת שגיאת error.

לדוגמה:

מספר מקומות round(number, places)
15.5 0 16.0
‫‎-15.5 0 ‫16.0-
15 1 15
15 0 15
15 -1 20
15 -2 0
15.48924 1 15.5
‫231-1 -1 [error]
‫263-1L -1 [error]
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("soldBooks").multiply(field("price")).round().as("partialRevenue"))
  .aggregate(field("partialRevenue").sum().as("totalRevenue"))
  .execute();
test.firestore.js

Web

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

Kotlin

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

Java

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

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

TRUNC

תחביר:

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

תיאור:

חותכת את המספר number למספר המבוקש של ספרות אחרי הנקודה places. אם places חיובי, הפונקציה חותכת ספרות מימין לנקודה העשרונית, ואם הוא שלילי, היא חותכת ספרות משמאל לנקודה העשרונית.

  • אם מספקים רק את number, הפונקציה מעגלת את הערך למספר השלם הקרוב ביותר לכיוון אפס.
  • אם חיתוך התוצאות גורם לגלישה, מוצגת שגיאת error.

לדוגמה:

מספר מקומות 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

תחביר:

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

תיאור:

הפונקציה מחזירה את הערך base בחזקת exponent.

  • הפונקציה מחזירה שגיאה אם הערכים של base <= 0 ו-exponent הם שליליים.

  • לכל exponent, ‏ pow(1, exponent) הוא 1.

  • לכל base, ‏ pow(base, 0) הוא 1.

לדוגמה:

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

Web

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

Kotlin

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

Java

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

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

SQRT

תחביר:

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

תיאור:

הפונקציה מחזירה את השורש הריבועי של number.

  • הפונקציה מחזירה שגיאה מסוג error אם number הוא מספר שלילי.

לדוגמה:

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

Web

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

Kotlin

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

Java

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

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

EXP

תחביר:

exp(exponent: FLOAT64) -> FLOAT64

תיאור:

הפונקציה מחזירה את הערך של מספר אוילר בחזקת exponent, שנקראת גם פונקציית האקספוננט הטבעי.

לדוגמה:

מעריך exp(exponent)
0.0 1.0
10 e^10 (FLOAT64)
+inf +inf
-inf 0
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("rating").exp().as("expRating"))
  .execute();
test.firestore.js

Web

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

Kotlin

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

Java

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

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

LN

תחביר:

ln(number: FLOAT64) -> FLOAT64

תיאור:

הפונקציה מחזירה את הלוגריתם הטבעי של number. הפונקציה הזו שוות ערך לפונקציה log(number).

לדוגמה:

מספר ln(number)
1 0.0
‫2L 0.693...
1.0 0.0
e (FLOAT64) 1.0
-inf NaN
+inf +inf
x <= 0 [error]
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("rating").ln().as("lnRating"))
  .execute();
test.firestore.js

Web

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

Kotlin

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

Java

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

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

LOG

תחביר:

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

תיאור:

הפונקציה מחזירה את הלוגריתם של number בבסיס base.

  • אם מספקים רק את number, הפונקציה מחזירה את הלוגריתם של number בבסיס base (שווה ל-ln(number)).

לדוגמה:

מספר base log(number, base)
100 10 2.0
-inf Numeric NaN
Numeric. +inf NaN
number <= 0 Numeric [error]
Numeric base <= 0 [error]
Numeric 1.0 [error]

LOG10

תחביר:

log10(x: FLOAT64) -> FLOAT64

תיאור:

הפונקציה מחזירה את הלוגריתם של number לפי בסיס 10.

לדוגמה:

מספר log10(number)
100 2.0
-inf NaN
+inf +inf
x <= 0 [error]

RAND

תחביר:

rand() -> FLOAT64

תיאור:

הפונקציה מחזירה מספר נקודה צפה (floating-point) פסאודו-אקראי, שנבחר באופן אחיד בין 0.0 (כולל) לבין 1.0 (לא כולל).

פונקציות של מערכים

שם תיאור
ARRAY מחזירה רכיב ARRAY שמכיל רכיב אחד לכל ארגומנט קלט
ARRAY_CONCAT הפונקציה משרשרת כמה מערכים למערך אחד ARRAY
ARRAY_CONTAINS הפונקציה מחזירה את הערך TRUE אם הערך ARRAY מכיל ערך מסוים
ARRAY_CONTAINS_ALL הפונקציה מחזירה את הערך TRUE אם כל הערכים מופיעים ב-ARRAY
ARRAY_CONTAINS_ANY הפונקציה מחזירה את הערך TRUE אם אחד מהערכים מופיע ב-ARRAY
ARRAY_FILTER סינון אלמנטים מ-ARRAY שלא עומדים בתנאי
ARRAY_FIRST הפונקציה מחזירה את הרכיב הראשון ב-ARRAY
ARRAY_FIRST_N הפונקציה מחזירה את n הרכיבים הראשונים ב-ARRAY
ARRAY_GET מחזירה את הרכיב באינדקס נתון ב-ARRAY
ARRAY_INDEX_OF הפונקציה מחזירה את האינדקס של המופע הראשון של ערך ב-ARRAY
ARRAY_INDEX_OF_ALL הפונקציה מחזירה את כל האינדקסים של ערך במערך ARRAY
ARRAY_LENGTH הפונקציה מחזירה את מספר הרכיבים ב-ARRAY
ARRAY_LAST הפונקציה מחזירה את הרכיב האחרון ב-ARRAY
ARRAY_LAST_N הפונקציה מחזירה את n הרכיבים האחרונים ב-ARRAY
ARRAY_REVERSE הופך את סדר הרכיבים ב-ARRAY
ARRAY_SLICE הפונקציה מחזירה פרוסה של ARRAY
ARRAY_TRANSFORM טרנספורמציה של רכיבים ב-ARRAY על ידי החלת ביטוי על כל רכיב
MAXIMUM הפונקציה מחזירה את הערך המקסימלי ב-ARRAY
MAXIMUM_N הפונקציה מחזירה את n הערכים הגדולים ביותר ב-ARRAY
MINIMUM הפונקציה מחזירה את הערך המינימלי ב-ARRAY
MINIMUM_N הפונקציה מחזירה את n הערכים הקטנים ביותר ב-ARRAY
SUM הפונקציה מחזירה את סכום כל הערכים של NUMERIC ב-ARRAY.
JOIN יוצרת שרשור של הרכיבים ב-ARRAY כערך STRING.

ARRAY

תחביר:

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

תיאור:

יוצרת מערך מהרכיבים שצוינו.

  • אם ארגומנט לא קיים, הוא מוחלף ב-NULL במערך שמתקבל.

לדוגמה:

ערכים 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

תחביר:

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

תיאור:

הפונקציה משרשרת שני מערכים או יותר למערך אחד ARRAY.

לדוגמה:

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

Kotlin

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

Java

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

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

ARRAY_CONTAINS

תחביר:

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

תיאור:

הפונקציה מחזירה TRUE אם המחרוזת value נמצאת במחרוזת array, אחרת היא מחזירה FALSE.

לדוגמה:

מערך ערך array_contains(array, value)
[1, 2, 3] 2 true
‪[[1, 2], [3]] [1, 2] true
‫[1, null] null true
‪"abc" הכול error
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("genre").arrayContains(constant("mystery")).as("isMystery"))
  .execute();
test.firestore.js

Web

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

Kotlin

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

Java

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

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

ARRAY_CONTAINS_ALL

תחביר:

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

תיאור:

הפונקציה מחזירה TRUE אם כל הערכים search_values נמצאים ב-array, ומחזירה FALSE אחרת.

לדוגמה:

מערך search_values array_contains_all(array, search_values)
[1, 2, 3] [1, 2] true
[1, 2, 3] [1, 4] false
‫[1, null] [אפס] true
[NaN] [NaN] true
[] [] true
[1, 2, 3] [] true
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(
    field("genre")
      .arrayContainsAll([constant("fantasy"), constant("adventure")])
      .as("isFantasyAdventure")
  )
  .execute();
test.firestore.js

Web

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

Kotlin

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

Java

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

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

ARRAY_CONTAINS_ANY

תחביר:

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

תיאור:

הפונקציה מחזירה TRUE אם אחד מהערכים search_values נמצא בערך array, ואחרת היא מחזירה FALSE.

לדוגמה:

מערך search_values array_contains_any(array, search_values)
[1, 2, 3] [4, 1] true
[1, 2, 3] [4, 5] false
[1, 2, null] [אפס] true
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(
    field("genre")
      .arrayContainsAny([constant("fantasy"), constant("nonfiction")])
      .as("isMysteryOrFantasy")
  )
  .execute();
test.firestore.js

Web

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

Kotlin

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

Java

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

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

ARRAY_FILTER

תחביר:

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

תיאור:

מסננת את array באמצעות ביטוי predicate ומחזירה מערך חדש עם רכיבים שעומדים בתנאי.

  • לכל רכיב ב-array, מתבצעת הערכה של predicate. אם הפונקציה מחזירה true, הרכיב נכלל בתוצאה. אחרת (אם הפונקציה מחזירה false או null), הרכיב מושמט.
  • אם predicate מוערך כערך שאינו בוליאני או שאינו null, הפונקציה מחזירה שגיאה.

לדוגמה:

מערך תנאי 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

תחביר:

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

תיאור:

הפונקציה מחזירה את הרכיב במיקום index (החל מ-0) ב-array.

  • אם index הוא מספר שלילי, הגישה לרכיבים היא מסוף המערך, כאשר -1 הוא הרכיב האחרון.
  • אם array הוא לא מסוג ARRAY ולא null, הפונקציה מחזירה שגיאה.
  • אם index הוא מחוץ לגבולות, הפונקציה מחזירה ערך חסר.
  • אם index הוא לא מסוג INT64, הפונקציה מחזירה שגיאה.

לדוגמה:

מערך אינדקס array_get(array, index)
[1, 2, 3] 0 1
[1, 2, 3] -1 3
[1, 2, 3] 3 נעדר/ת
[1, 2, 3] -4 נעדר/ת
‪"abc" 0 error
null 0 null
Array "a" error
Array 2.0 error

ARRAY_LENGTH

תחביר:

array_length(array: ARRAY) -> INT64

תיאור:

הפונקציה מחזירה את מספר הרכיבים ב-array.

לדוגמה:

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

Web

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

Kotlin

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

Java

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

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

ARRAY_REVERSE

תחביר:

array_reverse(array: ARRAY) -> ARRAY

תיאור:

הופכת את סדר המילים בarray הנתון.

לדוגמה:

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

Web

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

Kotlin

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

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

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

ARRAY_FIRST

תחביר:

array_first(array: ARRAY) -> ANY

תיאור:

הפונקציה מחזירה את הרכיב הראשון ב-array. הפונקציה הזו שוות ערך לפונקציה array_get(array, 0).

  • אם array ריק, הפונקציה מחזירה ערך חסר.

לדוגמה:

מערך array_first(array)
[1, 2, 3] 1
[] נעדר/ת

ARRAY_FIRST_N

תחביר:

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

תיאור:

הפונקציה מחזירה את n הרכיבים הראשונים של array. הפונקציה הזו שוות ערך לפונקציה array_slice(array, 0, n).

  • אם הערך של n הוא שלילי, הפונקציה מחזירה שגיאה.

לדוגמה:

מערך 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

תחביר:

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

תיאור:

הפונקציה מחזירה את האינדקס מבוסס-0 של המופע הראשון של value ב-array. הפונקציה מחזירה ‎-1 אם המחרוזת value לא נמצאה.

לדוגמה:

מערך ערך 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

תחביר:

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

תיאור:

הפונקציה מחזירה מערך שמכיל את האינדקסים מבוססי-0 של כל המופעים של value ב-array. מחזירה [] אם value לא נמצא.

לדוגמה:

מערך ערך 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

תחביר:

array_last(array: ARRAY) -> ANY

תיאור:

הפונקציה מחזירה את הרכיב האחרון ב-array. הפונקציה הזו שוות ערך לפונקציה array_get(array, -1).

  • אם array ריק, הפונקציה מחזירה ערך חסר.

לדוגמה:

מערך array_last(array)
[1, 2, 3] 3
[] נעדר/ת

ARRAY_LAST_N

תחביר:

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

תיאור:

הפונקציה מחזירה את n הרכיבים האחרונים של array.

  • אם הערך של n הוא שלילי, הפונקציה מחזירה שגיאה.

לדוגמה:

מערך 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

תחביר:

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

תיאור:

הפונקציה מחזירה קבוצת משנה של array החל מהאינדקס offset (מבוסס-0), כולל length רכיבים.

  • אם offset הוא מספר שלילי, הוא מציין את מיקום ההתחלה מסוף המערך, כאשר -1 הוא הרכיב האחרון.
  • אם הערך של length גדול ממספר האלמנטים שנותרו במערך אחרי offset, התוצאה תורחב עד לסוף המערך.
  • הערך length לא יכול להיות שלילי, אחרת הפונקציה מחזירה שגיאה.

לדוגמה:

מערך לקזז אורך 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

תחביר:

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

תיאור:

הפונקציה הופכת את array על ידי החלת expression על כל רכיב, ומחזירה מערך חדש עם רכיבים שעברו המרה. גודל מערך הפלט תמיד יהיה זהה לגודל מערך הקלט.

  • ‫expression יכולה להיות פונקציה אוניטרית element -> result או פונקציה בינארית (element, index) -> result.
  • אם expression הוא אונארי, הוא נקרא עם כל רכיב של array.
  • אם expression הוא בינארי, הוא נקרא עם כל רכיב של array והאינדקס המתאים שלו מבוסס-0.

לדוגמה:

מערך ביטוי 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 []

מקסימום

תחביר:

maximum(array: ARRAY) -> ANY

תיאור:

הפונקציה מחזירה את הערך המקסימלי ב-array.

  • המערכת מתעלמת מהערכים של NULL במהלך ההשוואה.
  • אם array ריק או מכיל רק ערכים של NULL, הפונקציה מחזירה NULL.

לדוגמה:

מערך maximum(array)
[1, 5, 2] 5
[1, null, 5] 5
‪["a", "c", "b"] "c"
[null, null] null
[] null

MAXIMUM_N

תחביר:

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

תיאור:

הפונקציה מחזירה מערך של n הערכים הגדולים ביותר ב-array בסדר יורד.

  • המערכת מתעלמת מהערכים של NULL.
  • אם הערך של n הוא שלילי, הפונקציה מחזירה שגיאה.

לדוגמה:

מערך n maximum_n(array, n)
‫[1, 5, 2, 4, 3] 3 ‫[5, 4, 3]
[1, null, 5] 3 [5, 1]

MINIMUM

תחביר:

minimum(array: ARRAY) -> ANY

תיאור:

הפונקציה מחזירה את הערך המינימלי ב-array.

  • המערכת מתעלמת מהערכים של NULL במהלך ההשוואה.
  • אם array ריק או מכיל רק ערכים של NULL, הפונקציה מחזירה NULL.

לדוגמה:

מערך minimum(array)
[1, 5, 2] 1
‫[5, null, 1] 1
‪["a", "c", "b"] "a"
[null, null] null
[] null

MINIMUM_N

תחביר:

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

תיאור:

הפונקציה מחזירה מערך של n הערכים הקטנים ביותר ב-array בסדר עולה.

  • המערכת מתעלמת מהערכים של NULL.
  • אם הערך של n הוא שלילי, הפונקציה מחזירה שגיאה.

לדוגמה:

מערך n minimum_n(array, n)
‫[1, 5, 2, 4, 3] 3 [1, 2, 3]
‫[5, null, 1] 3 [1, 5]

SUM

תחביר:

sum(array: ARRAY) -> INT64 | FLOAT64

תיאור:

הפונקציה מחזירה את סכום כל הערכים של NUMERIC ב-ARRAY.

  • המערכת מתעלמת מערכים לא מספריים במערך.
  • אם ערך מספרי כלשהו במערך הוא NaN, הפונקציה מחזירה NaN.
  • סוג ההחזרה נקבע לפי הסוג המספרי הרחב ביותר במערך: INT64 < FLOAT64.
  • אם מתרחשת גלישה של מספר שלם בן 64 ביט לפני סיכום של ערך נקודה צפה, הפונקציה מחזירה שגיאה. אם מסכמים ערכים של נקודה צפה, גלישה מעבר לקיבולת תגרום לתוצאה של אינסוף חיובי או שלילי.
  • אם המערך לא מכיל ערכים מספריים בכלל, הפונקציה מחזירה NULL.

לדוגמה:

מערך 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] error
[INT64.MAX_VALUE, 1, -1.0] error
‫[INT64.MAX_VALUE, 1.0] 9.223372036854776e+18

JOIN

תחביר:

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

תיאור:

הפונקציה מחזירה שרשור של האלמנטים ב-array בתור STRING. הפרמטר array יכול להיות מסוג הנתונים STRING או BYTES.

  • כל הרכיבים ב-array,‏ delimiter וגם null_text צריכים להיות מאותו סוג. הם צריכים להיות כולם STRING או כולם BYTES.
  • אם מציינים את null_text, כל הערכים של NULL ב-array מוחלפים ב-null_text.
  • אם לא מציינים את null_text, ערכי NULL ב-array לא נכללים בתוצאה.

לדוגמה:

אם לא מציינים את הערך null_text:

מערך תו מפריד 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'] "," error
‪["a", "c"] b',' error
[b'a', b'c'] "," error

כשהערך בשדה null_text הוא:

מערך תו מפריד 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' error
[b'a', null] b',' ‫"N" error

פונקציות השוואה

שם תיאור
EQUAL השוואה של שוויון
GREATER_THAN השוואה של ערכים גדולים יותר
GREATER_THAN_OR_EQUAL השוואה של גדול מ- או שווה ל-
LESS_THAN השוואה של ערכים קטנים יותר
LESS_THAN_OR_EQUAL השוואה של קטן מ- או שווה ל-
NOT_EQUAL השוואה של 'לא שווה'
CMP השוואה כללית

EQUAL

תחביר:

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

לדוגמה:

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

תיאור:

הפונקציה מחזירה TRUE אם x ו-y שווים, ו-FALSE אחרת.

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

Web

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

Kotlin

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

Java

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

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

GREATER_THAN

תחביר:

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

תיאור:

הפונקציה מחזירה TRUE אם x גדול מ-y, ו-FALSE אחרת.

אם אי אפשר להשוות בין x לבין y, הפונקציה מחזירה FALSE.

לדוגמה:

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

Web

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

Kotlin

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

Java

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

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

GREATER_THAN_OR_EQUAL

תחביר:

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

תיאור:

הפונקציה מחזירה TRUE אם x גדול מ-y או שווה לו, אחרת היא מחזירה FALSE.

אם אי אפשר להשוות בין x לבין y, הפונקציה מחזירה FALSE.

לדוגמה:

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

Web

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

Kotlin

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

Java

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

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

LESS_THAN

תחביר:

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

תיאור:

מחזירה TRUE אם x קטן מ-y, ומחזירה FALSE אחרת.

אם אי אפשר להשוות בין x לבין y, הפונקציה מחזירה FALSE.

לדוגמה:

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

Web

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

Kotlin

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

Java

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

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

LESS_THAN_OR_EQUAL

תחביר:

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

תיאור:

הפונקציה מחזירה את הערך TRUE אם x קטן מ-y או שווה לו, ואת הערך FALSE אחרת.

אם אי אפשר להשוות בין x לבין y, הפונקציה מחזירה FALSE.

לדוגמה:

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

Web

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

Kotlin

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

Java

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

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

NOT_EQUAL

תחביר:

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

תיאור:

הפונקציה מחזירה את הערך TRUE אם x לא שווה ל-y, ואת הערך FALSE אחרת.

לדוגמה:

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

Web

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

Kotlin

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

Java

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

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

השל

תחביר:

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

תיאור:

משווה בין x לבין y ומחזיר:

  • ‫1L if x is greater than y.
  • ‫-1L אם x קטן מ-y.
  • 0L אחרת.

בניגוד לפונקציות השוואה אחרות, הפונקציה cmp(...) פועלת על פני סוגים שונים, בהתאם לאותו סדר שבו נעשה שימוש בשלב sort(...). במאמר בנושא סדר של סוגי ערכים מוסבר איך הערכים מסודרים לפי סוגים.

לדוגמה:

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

ניפוי באגים בפונקציות

שם תיאור
EXISTS הפונקציה מחזירה TRUE אם הערך הוא לא ערך חסר
IS_ABSENT הפונקציה מחזירה את הערך TRUE אם הערך הוא ערך חסר
IF_ABSENT הפונקציה מחליפה את הערך בביטוי אם הוא לא קיים
IS_ERROR הפונקציה מאתרת ובודקת אם נוצרה שגיאה בביטוי הבסיסי
IF_ERROR הפונקציה מחליפה את הערך בביטוי אם היא החזירה שגיאה
ERROR הפונקציה מפסיקה את ההערכה ומחזירה שגיאה עם ההודעה שצוינה

EXISTS

תחביר:

exists(value: ANY) -> BOOLEAN

תיאור:

הפונקציה מחזירה TRUE אם value הוא לא הערך החסר.

לדוגמה:

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

Web

לדוגמה:

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

Kotlin

לדוגמה:

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

Java

לדוגמה:

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

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

IS_ABSENT

תחביר:

is_absent(value: ANY) -> BOOLEAN

תיאור:

הפונקציה מחזירה TRUE אם value הוא הערך החסר, ומחזירה FALSE אחרת. ערכים חסרים הם ערכים שחסרים בקלט, כמו שדה מסמך חסר.

לדוגמה:

value is_absent(value)
0L FALSE
‪"foo" FALSE
NULL FALSE
ABSENT TRUE

IF_ABSENT

תחביר:

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

תיאור:

אם value הוא ערך חסר, הפונקציה מחשבת ומחזירה את replacement. אחרת, הפונקציה מחזירה את הערך value.

לדוגמה:

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

IS_ERROR

תחביר:

is_error(try: ANY) -> BOOLEAN

תיאור:

הפונקציה מחזירה TRUE אם מתרחשת שגיאה במהלך ההערכה של try. אחרת, הפונקציה מחזירה את הערך FALSE.

IF_ERROR

תחביר:

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

תיאור:

אם מוצגת שגיאה במהלך ההערכה של try, הפונקציה מעריכה ומחזירה את replacement. אחרת, הפונקציה מחזירה את הערך שמתקבל אחרי הפעלת try.

שגיאה

תחביר:

error(message: STRING) -> ANY

תיאור:

הערכה של הפונקציה error גורמת להערכה של הפייפליין להסתיים בשגיאה. הערך message שצוין כלול בשגיאה.

לדוגמה:

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

פונקציות של הפניה

הסוג REFERENCE משמש כ'מצביע' למסמכים אחרים במסד הנתונים (או אפילו למסדי נתונים אחרים). הפונקציות הבאות מאפשרות לבצע מניפולציות בסוג הזה במהלך ביצוע השאילתה.

שם תיאור
COLLECTION_ID הפונקציה מחזירה את המזהה של אוסף העלים בהפניה שצוינה.
DOCUMENT_ID הפונקציה מחזירה את המזהה של המסמך בהפניה שצוינה
PARENT הפניה לאב
REFERENCE_SLICE מחזירה קבוצת משנה של פלחים מההפניה הנתונה

COLLECTION_ID

תחביר:

collection_id(ref: REFERENCE) -> STRING

תיאור:

מחזירה את מזהה אוסף העלים של REFERENCE נתון.

לדוגמה:

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

DOCUMENT_ID

תחביר:

document_id(ref: REFERENCE) -> ANY

תיאור:

מחזירה את מזהה המסמך של REFERENCE הנתון.

לדוגמה:

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

הורה

תחביר:

parent(ref: REFERENCE) -> REFERENCE

תיאור:

הפונקציה מחזירה את ההורה REFERENCE של ההפניה שצוינה, או NULL אם ההפניה היא כבר הפניה בסיסית.

לדוגמה:

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

REFERENCE_SLICE

תחביר:

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

תיאור:

‫REFERENCE היא רשימה של (collection_id, document_id) טאפלים, והיא מאפשרת לראות את הרשימה הזו, בדיוק כמו array_slice(...).

הפונקציה מחזירה אובייקט חדש מסוג REFERENCE שהוא קבוצת משנה של הפלחים של ref הנתון.

  • ‫offset: האינדקס ההתחלתי (מבוסס-0) של הפרוסה. אם הערך שלילי, הוא מייצג היסט מסוף ההפניה.
  • ‫length: מספר הפלחים שייכללו בפרוסה.

לדוגמה:

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

פונקציות לוגיות

שם תיאור
AND מבצעת פעולת AND לוגית
OR מבצעת פעולת OR לוגית
XOR מבצעת XOR לוגי
NOT מבצעת שלילה לוגית
NOR מבצעת NOR לוגי
CONDITIONAL הערכת ענפים על סמך ביטוי מותנה.
IF_NULL הפונקציה מחזירה את הערך הראשון שאינו null
SWITCH_ON הערכת ענפים על סמך סדרה של תנאים
EQUAL_ANY בודקת אם ערך מסוים שווה לאחד מהרכיבים במערך
NOT_EQUAL_ANY בודקת אם ערך מסוים לא שווה לאף אחד מהרכיבים במערך
MAXIMUM מחזירה את הערך המקסימלי בקבוצת ערכים.
MINIMUM מחזירה את הערך המינימלי בקבוצת ערכים.

וגם

תחביר:

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

תיאור:

מחזירה את הערך הלוגי AND של שני ערכים בוליאניים או יותר.

הפונקציה מחזירה NULL אם אי אפשר להפיק את התוצאה כי אחד מהערכים שצוינו הוא ABSENT או NULL.

לדוגמה:

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

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        Expression.and(
            field("rating").greaterThan(4),
            field("price").lessThan(10)
        ).alias("under10Recommendation")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field, And

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

או

תחביר:

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

תיאור:

מחזירה את הערך הלוגי OR של שני ערכים בוליאניים או יותר.

הפונקציה מחזירה NULL אם אי אפשר להפיק את התוצאה כי אחד מהערכים שצוינו הוא ABSENT או NULL.

לדוגמה:

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

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        Expression.or(
            field("genre").equal("Fantasy"),
            field("tags").arrayContains("adventure")
        ).alias("matchesSearchFilters")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field, And, Or

result = (
    client.pipeline()
    .collection("books")
    .select(
        Or(
            Field.of("genre").equal("Fantasy"),
            Field.of("tags").array_contains("adventure"),
        ).as_("matchesSearchFilters")
    )
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            or(equal(field("genre"), "Fantasy"), arrayContains(field("tags"), "adventure"))
                .as("matchesSearchFilters"))
        .execute()
        .get();
PipelineSnippets.java

XOR

תחביר:

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

תיאור:

הפונקציה מחזירה את הערך הלוגי XOR של שני ערכים בוליאניים או יותר.

הפונקציה מחזירה NULL אם אחד מהערכים שצוינו הוא ABSENT או NULL.

לדוגמה:

x y xor(x, y)
TRUE TRUE FALSE
FALSE FALSE FALSE
FALSE TRUE TRUE
NULL TRUE NULL
ABSENT TRUE NULL
NULL FALSE NULL
FALSE ABSENT NULL
Node.js
const result = await execute(db.pipeline()
  .collection("books")
  .select(
    xor(field("tags").arrayContains("magic"), field("tags").arrayContains("nonfiction"))
      .as("matchesSearchFilters")
  )
);
test.firestore.js

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        Expression.xor(
            field("tags").arrayContains("magic"),
            field("tags").arrayContains("nonfiction")
        ).alias("matchesSearchFilters")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field, Xor

result = (
    client.pipeline()
    .collection("books")
    .select(
        Xor(
            [
                Field.of("tags").array_contains("magic"),
                Field.of("tags").array_contains("nonfiction"),
            ]
        ).as_("matchesSearchFilters")
    )
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            xor(
                    arrayContains(field("tags"), "magic"),
                    arrayContains(field("tags"), "nonfiction"))
                .as("matchesSearchFilters"))
        .execute()
        .get();
PipelineSnippets.java

NOR

תחביר:

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

תיאור:

מחזירה את הערך הלוגי NOR של שני ערכים בוליאניים או יותר.

הפונקציה מחזירה NULL אם אי אפשר להפיק את התוצאה כי אחד מהערכים שצוינו הוא ABSENT או NULL.

לדוגמה:

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

תחביר:

not(x: BOOLEAN) -> BOOLEAN

תיאור:

מחזירה את הערך הלוגי NOT של ערך בוליאני.

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

Web

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        Expression.not(
            field("tags").arrayContains("nonfiction")
        ).alias("isFiction")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field, Not

result = (
    client.pipeline()
    .collection("books")
    .select(Not(Field.of("tags").array_contains("nonfiction")).as_("isFiction"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(not(arrayContains(field("tags"), "nonfiction")).as("isFiction"))
        .execute()
        .get();
PipelineSnippets.java

CONDITIONAL

תחביר:

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

תיאור:

הפונקציה בודקת את condition ומחזירה את true_case אם התוצאה של condition היא TRUE.

הפונקציה בודקת את התנאי ומחזירה את הערך false_case אם התנאי הוא FALSE, NULL או ABSENT.

לדוגמה:

condition true_case false_case conditional(condition, true_case, false_case)
TRUE ‫1L 0L ‫1L
FALSE ‫1L 0L 0L
NULL ‫1L 0L 0L
ABSENT ‫1L 0L 0L
Node.js
const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("tags").arrayConcat([
      field("pages").greaterThan(100)
        .conditional(constant("longRead"), constant("shortRead"))
    ]).as("extendedTags")
  )
);
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("tags").arrayConcat([
      field("pages").greaterThan(100)
        .conditional(constant("longRead"), constant("shortRead"))
    ]).as("extendedTags")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("tags").arrayConcat([
      ConditionalExpression(
        Field("pages").greaterThan(100),
        then: Constant("longRead"),
        else: Constant("shortRead")
      )
    ]).as("extendedTags")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("tags").arrayConcat(
            Expression.conditional(
                field("pages").greaterThan(100),
                constant("longRead"),
                constant("shortRead")
            )
        ).alias("extendedTags")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import (
    Field,
    Constant,
    Conditional,
)

result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("tags")
        .array_concat(
            Conditional(
                Field.of("pages").greater_than(100),
                Constant.of("longRead"),
                Constant.of("shortRead"),
            )
        )
        .as_("extendedTags")
    )
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            arrayConcat(
                    field("tags"),
                    conditional(
                        greaterThan(field("pages"), 100),
                        constant("longRead"),
                        constant("shortRead")))
                .as("extendedTags"))
        .execute()
        .get();
PipelineSnippets.java

IF_NULL

תחביר:

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

תיאור:

הפונקציה מחזירה expr אם הוא לא NULL, אחרת היא מחשבת ומחזירה את replacement. אם משתמשים ב-expr, הביטוי replacement לא מוערך.

לדוגמה:

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

SWITCH_ON

תחביר:

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

תיאור:

בודקת סדרה של תנאים ומחזירה את התוצאה שמשויכת לתנאי הראשון TRUE. אם אף אחד מהתנאים לא מקבל את הערך TRUE, הערך default מוחזר אם הוא צוין. אם לא מספקים ערך של default, תוצג שגיאה אם אף אחד מהתנאים האחרים לא יחזיר default.TRUE

כדי לספק ערך default, מעבירים אותו כארגומנט האחרון כך שמספר הארגומנטים יהיה אי-זוגי.

לדוגמה:

x switch_on(eq(x, 1L), "one", eq(x, 2L), "two", "other")
‫1L ‫"one"
‫2L ‫"two"
‫3L ‫"other"

EQUAL_ANY

תחביר:

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

תיאור:

הפונקציה מחזירה TRUE אם value נמצא במערך search_space.

לדוגמה:

value search_space equal_any(value, search_space)
0L ‫[1L, ‏ 2L, ‏ 3L] FALSE
‫2L ‫[1L, ‏ 2L, ‏ 3L] TRUE
NULL ‫[1L, ‏ 2L, ‏ 3L] FALSE
NULL [1L, NULL] TRUE
ABSENT [1L, NULL] FALSE
NaN [1L, NaN, 3L] TRUE
Node.js
const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("genre").equalAny(["Science Fiction", "Psychological Thriller"])
      .as("matchesGenreFilters")
  )
);
test.firestore.js

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("genre")
        .equal_any(["Science Fiction", "Psychological Thriller"])
        .as_("matchesGenreFilters")
    )
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            equalAny(field("genre"), Arrays.asList("Science Fiction", "Psychological Thriller"))
                .as("matchesGenreFilters"))
        .execute()
        .get();
PipelineSnippets.java

NOT_EQUAL_ANY

תחביר:

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

תיאור:

הפונקציה מחזירה TRUE אם value לא נמצא במערך search_space.

לדוגמה:

value search_space not_equal_any(value, search_space)
0L ‫[1L, ‏ 2L, ‏ 3L] TRUE
‫2L ‫[1L, ‏ 2L, ‏ 3L] FALSE
NULL ‫[1L, ‏ 2L, ‏ 3L] TRUE
NULL [1L, NULL] FALSE
ABSENT [1L, NULL] TRUE
NaN [1L, NaN, 3L] FALSE
Node.js
const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("author").notEqualAny(["George Orwell", "F. Scott Fitzgerald"])
      .as("byExcludedAuthors")
  )
);
test.firestore.js

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("author")
        .not_equal_any(["George Orwell", "F. Scott Fitzgerald"])
        .as_("byExcludedAuthors")
    )
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            notEqualAny(field("author"), Arrays.asList("George Orwell", "F. Scott Fitzgerald"))
                .as("byExcludedAuthors"))
        .execute()
        .get();
PipelineSnippets.java

מקסימום

תחביר:

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

תיאור:

הפונקציה מחזירה את הערך המקסימלי שאינו NULL ואינו ABSENT בסדרת הערכים x.

אם אין ערכים שהם לא NULL ולא ABSENT, הפונקציה מחזירה NULL.

אם יש כמה ערכים מקסימליים שווים, הפונקציה יכולה להחזיר כל אחד מהם. סדר סוגי הערכים הוא לפי הסדר שמופיע במסמכים.

לדוגמה:

x y maximum(x, y)
FALSE TRUE TRUE
FALSE ‫‎-10L ‫‎-10L
0.0 ‎-5L 0.0
‪"foo" "bar" ‪"foo"
‪"foo" ‪["foo"] ‪["foo"]
ABSENT ABSENT NULL
NULL NULL NULL
Node.js
const result = await execute(db.pipeline()
  .collection("books")
  .aggregate(field("price").maximum().as("maximumPrice"))
);
test.firestore.js

Web

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

Kotlin

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

Java

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

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

MINIMUM

תחביר:

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

תיאור:

הפונקציה מחזירה את הערך המינימלי שאינו NULL ואינו ABSENT בסדרת הערכים x.

אם אין ערכים שהם לא NULL ולא ABSENT, הפונקציה מחזירה NULL.

אם יש כמה ערכים מינימליים שווים, הפונקציה יכולה להחזיר כל אחד מהם. סדר סוגי הערכים הוא לפי הסדר שמופיע במסמכים.

לדוגמה:

x y minimum(x, y)
FALSE TRUE FALSE
FALSE ‫‎-10L FALSE
0.0 ‎-5L ‎-5L
‪"foo" "bar" "bar"
‪"foo" ‪["foo"] ‪"foo"
ABSENT ABSENT NULL
NULL NULL NULL
Node.js
const result = await execute(db.pipeline()
  .collection("books")
  .aggregate(field("price").minimum().as("minimumPrice"))
);
test.firestore.js

Web

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

Kotlin

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

Java

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

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

Map Functions

שם תיאור
MAP יוצר ערך של מפה מסדרה של צמדי מפתח/ערך
MAP_GET הפונקציה מחזירה את הערך במפה בהינתן מפתח שצוין
MAP_SET מחזירה עותק של מפה עם סדרה של מפתחות מעודכנים
MAP_REMOVE מחזירה עותק של מפה עם סדרה של מפתחות שהוסרו
MAP_MERGE מיזוג של סדרה של מפות.
CURRENT_CONTEXT הפונקציה מחזירה את ההקשר הנוכחי כמפה.
MAP_KEYS הפונקציה מחזירה מערך של כל המפתחות במיפוי.
MAP_VALUES הפונקציה מחזירה מערך של כל הערכים במיפוי.
MAP_ENTRIES הפונקציה מחזירה מערך של זוגות של מפתח וערך של מפה.

MAP

תחביר:

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

תיאור:

יוצר מפה מסדרה של צמדי מפתח/ערך.

MAP_GET

תחביר:

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

תיאור:

הפונקציה מחזירה את הערך במפה בהינתן מפתח מסוים. הפונקציה מחזירה ערך ABSENT אם key לא קיים במיפוי, או אם הארגומנט map הוא לא MAP.

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

Web

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

Kotlin

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

Java

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

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

MAP_SET

תחביר:

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

תיאור:

הפונקציה מחזירה עותק של הערך map עם תוכן מעודכן לפי סדרה של צמדי מפתח/ערך.

אם הערך שצוין לא קיים, המפתח המשויך מוסר מהמיפוי.

אם הארגומנט map הוא לא MAP, הפונקציה מחזירה ערך חסר.

MAP_REMOVE

תחביר:

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

תיאור:

מחזירה עותק של הערך map עם סדרה של מפתחות שהוסרו.

MAP_MERGE

תחביר:

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

הפונקציה ממזגת את התוכן של 2 מפות או יותר. אם יש כמה מיפויים עם ערכים סותרים, המערכת משתמשת בערך האחרון.

CURRENT_CONTEXT

תחביר:

current_context() -> MAP

הפונקציה מחזירה מפה שמורכבת מכל השדות שזמינים בנקודה הנוכחית של ההפעלה.

MAP_KEYS

תחביר:

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

תיאור:

הפונקציה מחזירה מערך שמכיל את כל המפתחות של הערך map.

MAP_VALUES

תחביר:

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

תיאור:

הפונקציה מחזירה מערך שמכיל את כל הערכים של הערך map.

MAP_ENTRIES

תחביר:

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

תיאור:

הפונקציה מחזירה מערך שמכיל את כל צמדי המפתח/ערך בערך map.

כל צמד מפתח/ערך יהיה בצורה של מפה עם שני רשומות, k ו-v.

לדוגמה:

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

פונקציות של מחרוזות

שם תיאור
BYTE_LENGTH הפונקציה מחזירה את מספר התווים BYTES בערך STRING או BYTES
CHAR_LENGTH הפונקציה מחזירה את מספר התווים ב-Unicode בערך STRING.
STARTS_WITH הפונקציה מחזירה את הערך TRUE אם המחרוזת STRING מתחילה בתחילית שצוינה
ENDS_WITH הפונקציה מחזירה את הערך TRUE אם STRING מסתיים בסיומת שצוינה
LIKE הפונקציה מחזירה את הערך TRUE אם מחרוזת STRING תואמת לתבנית
REGEX_CONTAINS הפונקציה מחזירה TRUE אם ערך מסוים תואם באופן חלקי או מלא לביטוי רגולרי
REGEX_MATCH הפונקציה מחזירה את הערך TRUE אם חלק כלשהו של ערך תואם לביטוי רגולרי
STRING_CONCAT הפונקציה משרשרת כמה ערכי STRING לערך STRING
STRING_CONTAINS הפונקציה מחזירה TRUE אם ערך מכיל STRING
STRING_INDEX_OF הפונקציה מחזירה את האינדקס מבוסס-0 של המופע הראשון של הערך STRING או BYTES.
TO_UPPER הפונקציה ממירה ערך STRING או BYTES לאותיות רישיות.
TO_LOWER הפונקציה ממירה ערך STRING או BYTES לאותיות קטנות.
SUBSTRING הפונקציה מחזירה מחרוזת משנה של ערך STRING או BYTES.
STRING_REVERSE היפוך של ערך STRING או BYTES.
STRING_REPEAT הפונקציה חוזרת על הערך STRING או BYTES מספר פעמים שצוין.
STRING_REPLACE_ALL הפונקציה מחליפה את כל המופעים של הערך STRING או BYTES.
STRING_REPLACE_ONE מחליפה את המופע הראשון של הערך STRING או BYTES.
TRIM הפונקציה מסירה תווים מובילים וסוגרים מערך STRING או BYTES.
LTRIM הפונקציה מסירה תווים מובילים מערך STRING או BYTES.
RTRIM הפונקציה מסירה תווים מסוף הערך STRING או BYTES.
SPLIT מפצלת ערך של STRING או BYTES למערך.

BYTE_LENGTH

תחביר:

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

תיאור:

הפונקציה מחזירה את מספר התווים BYTES בערך STRING או BYTES.

לדוגמה:

ערך byte_length(value)
‪"abc" 3
‪"xyzabc" 6
b"abc" 3
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(
    field("title").byteLength().as("titleByteLength")
  )
  .execute();
test.firestore.js

Web

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

Kotlin

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

Java

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

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

CHAR_LENGTH

תחביר:

char_length(value: STRING) -> INT64

תיאור:

הפונקציה מחזירה את מספר נקודות הקוד של Unicode בערך STRING.

לדוגמה:

ערך char_length(value)
‪"abc" 3
‫"hello" 5
‫"world" 5
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(
    field("title").charLength().as("titleCharLength")
  )
  .execute();
test.firestore.js

Web

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

Kotlin

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

Java

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

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

STARTS_WITH

תחביר:

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

תיאור:

הפונקציה מחזירה TRUE אם value מתחיל ב-prefix.

לדוגמה:

ערך תחילית starts_with(value, prefix)
‪"abc" "a" true
‪"abc" "b" false
‪"abc" "" true
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(
    field("title").startsWith("The")
      .as("needsSpecialAlphabeticalSort")
  )
  .execute();
test.firestore.js

Web

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

Kotlin

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

Java

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

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

ENDS_WITH

תחביר:

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

תיאור:

הפונקציה מחזירה את הערך TRUE אם value מסתיים ב-postfix.

לדוגמה:

ערך סיומת ends_with(value, postfix)
‪"abc" "c" true
‪"abc" "b" false
‪"abc" "" true
Node.js
const result = await db.pipeline()
  .collection("inventory/devices/laptops")
  .select(
    field("name").endsWith("16 inch")
      .as("16InLaptops")
  )
  .execute();
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("inventory/devices/laptops")
  .select([
    Field("name").endsWith("16 inch")
      .as("16InLaptops")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

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

Java

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

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

אהבתי

תחביר:

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

תיאור:

הפונקציה מחזירה את הערך TRUE אם value תואם ל-pattern.

לדוגמה:

ערך דוגמת עיצוב like(value, pattern)
‫"Firestore" "Fire%" true
‫"Firestore" ‫"%store" true
‫"Datastore" "Data_tore" true
‫"100%" ‪"100\%" true
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(
    field("genre").like("%Fiction")
      .as("anyFiction")
  )
  .execute();
test.firestore.js

Web

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

Kotlin

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

Java

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

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

REGEX_CONTAINS

תחביר:

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

תיאור:

הפונקציה מחזירה את הערך TRUE אם חלק כלשהו של value תואם ל-pattern. אם pattern הוא לא ביטוי רגולרי תקין, הפונקציה הזו מחזירה error.

הביטויים הרגולריים פועלים לפי התחביר של ספריית re2.

לדוגמה:

ערך דוגמת עיצוב regex_contains(value, pattern)
‫"Firestore" ‫"Fire" true
‫"Firestore" ‫"store$" true
‫"Firestore" ‫"data" false
Node.js
const result = await db.pipeline()
  .collection("documents")
  .select(
    field("title").regexContains("Firestore (Enterprise|Standard)")
      .as("isFirestoreRelated")
  )
  .execute();
test.firestore.js

Web

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

Kotlin

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

Java

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

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

REGEX_MATCH

תחביר:

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

תיאור:

הפונקציה מחזירה את הערך TRUE אם value תואם באופן מלא ל-pattern. אם pattern הוא לא ביטוי רגולרי תקין, הפונקציה הזו מחזירה error.

הביטויים הרגולריים פועלים לפי התחביר של ספריית re2.

לדוגמה:

ערך דוגמת עיצוב regex_match(value, pattern)
‫"Firestore" ‪"F.*store" true
‫"Firestore" ‫"Fire" false
‫"Firestore" "^F.*e$" true
Node.js
const result = await db.pipeline()
  .collection("documents")
  .select(
    field("title").regexMatch("Firestore (Enterprise|Standard)")
      .as("isFirestoreExactly")
  )
  .execute();
test.firestore.js

Web

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

Kotlin

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

Java

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

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

STRING_CONCAT

תחביר:

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

תיאור:

הפונקציה משרשרת שני ערכים או יותר של STRING לתוצאה אחת.

לדוגמה:

ארגומנטים string_concat(values...)
() error
("a") "a"
("abc", "def") ‪"abcdef"
("a", "", "c") "ac"
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(
    field("title").stringConcat(" by ", field("author"))
      .as("fullyQualifiedTitle")
  )
  .execute();
test.firestore.js

Web

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

Kotlin

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

Java

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

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

STRING_CONTAINS

תחביר:

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

תיאור:

בודקת אם value מכיל את המחרוזת המילולית substring.

לדוגמה:

ערך תת-מחרוזת string_contains(value, substring)
‪"abc" "b" true
‪"abc" "d" false
‪"abc" "" true
"a.c" "." true
"☃☃☃" "☃" true
Node.js
const result = await db.pipeline()
  .collection("articles")
  .select(
    field("body").stringContains("Firestore")
      .as("isFirestoreRelated")
  )
  .execute();
test.firestore.js

Web

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

Kotlin

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

Java

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

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

STRING_INDEX_OF

תחביר:

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

תיאור:

הפונקציה מחזירה את האינדקס מבוסס-0 של המופע הראשון של search ב-value.

  • מחזירה -1 אם search לא נמצא.
  • אם value הוא ערך STRING, התוצאה נמדדת בנקודות קוד של Unicode. אם זה ערך BYTES, המידה היא בבייטים.
  • אם search הוא ערך ריק של STRING או BYTES, התוצאה היא 0.

לדוגמה:

ערך חיפוש 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

תחביר:

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

תיאור:

הפונקציה ממירה ערך STRING או BYTES לאותיות רישיות.

אם בייט או תו לא תואמים לתו אלפביתי קטן ב-UTF-8, הם מועברים ללא שינוי.

לדוגמה:

ערך to_upper(value)
‪"abc" ‪"ABC"
‪"AbC" ‪"ABC"
b"abc" b"ABC"
b"a1c" b"A1C"
Node.js
const result = await db.pipeline()
  .collection("authors")
  .select(
    field("name").toUpper()
      .as("uppercaseName")
  )
  .execute();
test.firestore.js

Web

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

Kotlin

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

Java

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

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

TO_LOWER

תחביר:

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

תיאור:

הפונקציה ממירה ערך STRING או BYTES לאותיות קטנות.

אם בייט או תו לא תואמים לתו אלפביתי גדול ב-UTF-8, הם מועברים ללא שינוי.

לדוגמה:

ערך to_lower(value)
‪"ABC" ‪"abc"
‪"AbC" ‪"abc"
‪"A1C" ‪"a1c"
b"ABC" b"abc"
Node.js
const result = await db.pipeline()
  .collection("authors")
  .select(
    field("genre").toLower().equal("fantasy")
      .as("isFantasy")
  )
  .execute();
test.firestore.js

Web

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

Kotlin

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

Java

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

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

SUBSTRING

תחביר:

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

תיאור:

הפונקציה מחזירה מחרוזת משנה של input החל מ-position (אינדקס שמתחיל בספרה אפס) וכוללת עד length רשומות. אם לא מציינים length, הפונקציה מחזירה את מחרוזת המשנה מ-position עד סוף input.

  • אם input הוא ערך STRING, ‏ position ו-length נמדדים בנקודות קוד של Unicode. אם זה ערך BYTES, המידות הן בבייטים.

  • אם position גדול מהאורך של input, מוחזרת מחרוזת משנה ריקה. אם הסכום של position ו-length גדול מהאורך של input, מחרוזת המשנה נחתכת עד לסוף של input.

  • אם position הוא שלילי, המיקום נלקח מסוף הקלט. אם הערך השלילי position גדול מגודל הקלט, המיקום מוגדר לאפס. הערך של length לא יכול להיות שלילי.

לדוגמה:

אם לא מציינים את הערך length:

קלט position substring(input, position)
‪"abc" 0 ‪"abc"
‪"abc" 1 "bc"
‪"abc" 3 ""
‪"abc" -1 "c"
b"abc" 1 b"bc"

כשהערך בשדה length הוא:

קלט position אורך substring(input, position, length)
‪"abc" 0 1 "a"
‪"abc" 1 2 "bc"
‪"abc" -1 1 "c"
b"abc" 0 1 b"a"
Node.js
const result = await db.pipeline()
  .collection("books")
  .where(field("title").startsWith("The "))
  .select(
    field("title").substring(4)
      .as("titleWithoutLeadingThe")
  )
  .execute();
test.firestore.js

Web

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

Kotlin

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

Java

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

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

STRING_REVERSE

תחביר:

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

תיאור:

הפונקציה מחזירה את הקלט שסופק בסדר הפוך.

התווים מופרדים באמצעות נקודות קוד של Unicode כשהקלט הוא STRING, ובאמצעות בייטים כשהקלט הוא ערך BYTES.

לדוגמה:

קלט string_reverse(input)
‪"abc" "cba"
‫"a🌹b" ‪"b🌹a"
‫"hello" ‪"olleh"
b"abc" b"cba"
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(
    field("name").reverse().as("reversedName")
  )
  .execute();
test.firestore.js

Web

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

Kotlin

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

Java

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

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

STRING_REPEAT

תחביר:

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

תיאור:

הפונקציה מחזירה את הערך input שחוזר על עצמו repetitions פעמים.

  • הערך של repetitions חייב להיות מספר שלם לא שלילי.
  • אם repetitions הוא 0, הפונקציה מחזירה ערך ריק מאותו סוג כמו input.
  • אם התוצאה חורגת מהגודל המקסימלי המותר (1MB), מוחזרת שגיאה.

לדוגמה:

קלט חזרות string_repeat(input, repetitions)
‪"foo" 3 ‪"foofoofoo"
‪"foo" 0 ""
"a " 3 ‪"a a a "
b"ab" 2 b"abab"
‪"é🦆" 2 ‪"é🦆é🦆"

STRING_REPLACE_ALL

תחביר:

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

תיאור:

הפונקציה מחליפה את כל המופעים של find בתוך input ב-replacement, בלי חפיפה.

  • ההתאמות הן תלויות אותיות רישיות.
  • אם find ריק, לא מתבצעים החלפות.

לדוגמה:

קלט חיפוש החלפה 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

תחביר:

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

תיאור:

הפונקציה מחליפה את המופע הראשון של find ב-input ב-replacement.

  • ההתאמות הן תלויות אותיות רישיות.
  • אם find ריק, לא מתבצעים החלפות.

לדוגמה:

קלט חיפוש החלפה string_replace_one(input, find, replacement)
"foobarfoo" ‪"foo" ‪"baz" "bazbarfoo"
"é" "é" "a" "a"
b"foobar" b"o" b"z" b"fzoobar"

TRIM

תחביר:

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

תיאור:

הפונקציה מסירה קבוצה שצוינה של BYTES או CHARS מההתחלה ומהסוף של input שסופקה.

  • אם לא מציינים values_to_trim, המערכת מסירה את תווי הרווח הלבן.

לדוגמה:

אם לא מציינים את הערך values_to_trim:

קלט 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"

כשהערך בשדה values_to_trim הוא:

קלט values_to_trim trim(input, values_to_trim)
‪"abcbfooaacb" ‪"abc" ‪"foo"
"abcdaabadbac" ‪"abc" "daabad"
b"C1C2C3" b"C1" b"C2C3"
b"C1C2" ‪"foo" error
‪"foo" b"C1" error

Web

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

Kotlin

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

Java

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

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

LTRIM

תחביר:

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

תיאור:

הפונקציה מסירה קבוצה מסוימת של BYTES או CHARS מתחילת המחרוזת value שסופקה.

  • אם לא מציינים את to_trim, המערכת תסיר רווחים לבנים בתחילת השורה.

לדוגמה:

אם לא מציינים את הערך to_trim:

ערך ltrim(value)
‪" foo " ‪"foo "
‪"foo" ‪"foo"

כשהערך בשדה to_trim הוא:

ערך to_trim ltrim(value, to_trim)
‪"aaabc" "a" "bc"
"abacaba" "ba" "caba"
"é" "é" ""

RTRIM

תחביר:

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

תיאור:

מסירה קבוצה שצוינה של BYTES או CHARS מהסוף של value שסופקה.

  • אם לא מציינים את to_trim, המערכת חותכת רווחים לבנים בסוף.

לדוגמה:

אם לא מציינים את הערך to_trim:

ערך rtrim(value)
‪" foo " ‪" foo"
‪"foo" ‪"foo"

כשהערך בשדה to_trim הוא:

ערך to_trim rtrim(value, to_trim)
"abccc" "c" "ab"
"abacaba" "ba" "abac"
"é" "é" ""

SPLIT

תחביר:

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

תיאור:

מפצלת ערך STRING או BYTES באמצעות תו מפריד.

  • ב-STRING, תו ברירת המחדל להפרדה הוא הפסיק ,. התו המפריד נחשב למחרוזת אחת.

  • במאפיין BYTES, צריך לציין תו מפריד.

  • פיצול לפי תו מפריד ריק יוצר מערך של נקודות קוד ב-Unicode עבור ערכי STRING, ומערך של BYTES עבור ערכי BYTES.

  • פיצול של STRING ריק מחזיר ARRAY עם STRING ריק יחיד.

לדוגמה:

אם לא מציינים את הערך delimiter:

קלט split(input)
‪"foo,bar,foo" ‪["foo", "bar", "foo"]
‪"foo" ‪["foo"]
",foo," ‪["", "foo", ""]
"" ‪[""]
b"C120C2C4" error

כשהערך בשדה delimiter הוא:

קלט תו מפריד 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" error

פונקציות של חותמות זמן

שם תיאור
CURRENT_TIMESTAMP יוצרת TIMESTAMP שמתאים לזמן הבקשה.
TIMESTAMP_TRUNC חיתוך של TIMESTAMP לרמת פירוט נתונה.
UNIX_MICROS_TO_TIMESTAMP הפונקציה ממירה את מספר המיקרו-שניות מאז 1970-01-01 00:00:00 UTC ל-TIMESTAMP
UNIX_MILLIS_TO_TIMESTAMP הפונקציה ממירה את מספר אלפיות השנייה מאז 1970-01-01 00:00:00 UTC ל-TIMESTAMP
UNIX_SECONDS_TO_TIMESTAMP הפונקציה ממירה את מספר השניות מאז 1970-01-01 00:00:00 UTC ל-TIMESTAMP
TIMESTAMP_ADD הוספת מרווח זמן לTIMESTAMP
TIMESTAMP_SUB הפונקציה מחסרת מרווח זמן מ-TIMESTAMP
TIMESTAMP_TO_UNIX_MICROS הפונקציה ממירה TIMESTAMP למספר המיקרו-שניות מאז 1970-01-01 00:00:00 UTC
TIMESTAMP_TO_UNIX_MILLIS הפונקציה ממירה TIMESTAMP למספר אלפיות השנייה מאז 1970-01-01 00:00:00 UTC
TIMESTAMP_TO_UNIX_SECONDS הפונקציה ממירה את TIMESTAMP למספר השניות מאז 1970-01-01 00:00:00 UTC
TIMESTAMP_DIFF הפונקציה מחזירה את המספר השלם של מרווחי unit שצוינו בין שני TIMESTAMP.
TIMESTAMP_EXTRACT הפונקציה מחלצת part ספציפי (למשל, שנה, חודש, יום) מתוך TIMESTAMP.

CURRENT_TIMESTAMP

תחביר:

current_timestamp() -> TIMESTAMP

תיאור:

הפונקציה מחזירה את חותמת הזמן בתחילת זמן הבקשה input (הערך מתפרש כמספר המיקרו-שניות מאז 1970-01-01 00:00:00 UTC).

הערך הזה יציב בתוך שאילתה, ותמיד יתקבל אותו ערך אם הפונקציה תיקרא כמה פעמים.

TIMESTAMP_TRUNC

תחביר:

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

תיאור:

מקצרת חותמת זמן לרמת פירוט נתונה.

הארגומנט granularity חייב להיות מחרוזת ואחד מהערכים הבאים:

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

אם מציינים את הארגומנט timezone, החיתוך יתבסס על גבולות היומן של אזור הזמן שצוין (לדוגמה, חיתוך לפי יום יחתוך לחצות באזור הזמן שצוין). הקיטוע יתבצע בהתאם לשעון הקיץ.

אם לא מציינים את הערך timezone, החיתוך יתבסס על גבולות היומן UTC.

הארגומנט timezone צריך להיות ייצוג מחרוזת של אזור זמן ממסד הנתונים tz, למשל America/New_York. אפשר גם להשתמש בהזזת זמן בהתאמה אישית על ידי ציון הזזה מ-GMT.

לדוגמה:

timestamp granularity timezone timestamp_trunc(timestamp, granularity, timezone)
2000-01-01 10:20:30:123456 UTC ‫"second" לא צוין 2001-01-01 10:20:30 UTC
1997-05-31 04:30:30 UTC ‫"day" לא צוין 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) לא צוין 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

תחביר:

unix_micros_to_timestamp(input: INT64) -> TIMESTAMP

תיאור:

הפונקציה ממירה את input (שמפורש כמספר המיקרו-שניות מאז 1970-01-01 00:00:00 UTC) ל-TIMESTAMP. הפונקציה מחזירה error אם אי אפשר להמיר את input לערך TIMESTAMP תקין.

לדוגמה:

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

Web

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

Kotlin

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

Java

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

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

UNIX_MILLIS_TO_TIMESTAMP

תחביר:

unix_millis_to_timestamp(input: INT64) -> TIMESTAMP

תיאור:

הפונקציה ממירה את input (שמפורש כמספר אלפיות השנייה מאז 1970-01-01 00:00:00 UTC) ל-TIMESTAMP. הפונקציה מחזירה error אם אי אפשר להמיר את input לערך TIMESTAMP תקין.

לדוגמה:

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

Web

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

Kotlin

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

Java

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

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

UNIX_SECONDS_TO_TIMESTAMP

תחביר:

unix_seconds_to_timestamp(input: INT64) -> TIMESTAMP

תיאור:

הפונקציה ממירה את input (שמפורש כמספר השניות מאז 1970-01-01 00:00:00 UTC) ל-TIMESTAMP. הפונקציה מחזירה error אם אי אפשר להמיר את input לערך TIMESTAMP תקין.

לדוגמה:

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

Web

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

Kotlin

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

Java

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

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

TIMESTAMP_ADD

תחביר:

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

תיאור:

הפונקציה מוסיפה amount של unit מ-timestamp. הארגומנט amount יכול להיות שלילי, ובמקרה כזה הוא שווה ל-TIMESTAMP_SUB.

הארגומנט unit חייב להיות מחרוזת ואחד מהערכים הבאים:

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

הפונקציה מחזירה שגיאה אם חותמת הזמן שמתקבלת לא מתאימה לטווח TIMESTAMP.

לדוגמה:

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();
test.firestore.js

Web

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

Kotlin

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

Java

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

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

TIMESTAMP_SUB

תחביר:

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

תיאור:

הפונקציה מחסרת את הערך amount של unit מהערך timestamp. הארגומנט amount יכול להיות שלילי, ובמקרה כזה הוא שווה ל-TIMESTAMP_ADD.

הארגומנט unit חייב להיות מחרוזת ואחד מהערכים הבאים:

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

הפונקציה מחזירה שגיאה אם חותמת הזמן שמתקבלת לא מתאימה לטווח TIMESTAMP.

לדוגמה:

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();
test.firestore.js

Web

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

Kotlin

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

Java

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

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

TIMESTAMP_TO_UNIX_MICROS

תחביר:

timestamp_to_unix_micros(input: TIMESTAMP) -> INT64

תיאור:

הפונקציה ממירה את input למספר המיקרו-שניות מאז 1970-01-01 00:00:00 UTC. חיתוך של רמות דיוק גבוהות יותר על ידי עיגול כלפי מטה לתחילת המיקרו-שנייה.

לדוגמה:

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

Web

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

Kotlin

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

Java

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

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

TIMESTAMP_TO_UNIX_MILLIS

תחביר:

timestamp_to_unix_millis(input: TIMESTAMP) -> INT64

תיאור:

הפונקציה ממירה את input למספר אלפיות השנייה מאז 1970-01-01 00:00:00 UTC. קיצוץ של רמות דיוק גבוהות יותר על ידי עיגול כלפי מטה לתחילת המילי-שנייה.

לדוגמה:

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

Web

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

Kotlin

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

Java

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

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

TIMESTAMP_TO_UNIX_SECONDS

תחביר:

timestamp_to_unix_seconds(input: TIMESTAMP) -> INT64

תיאור:

הפונקציה ממירה את input למספר השניות מאז 1970-01-01 00:00:00 UTC. מבצע עיגול כלפי מטה לתחילת השנייה, כדי לקצר את רמות הדיוק הגבוהות יותר.

לדוגמה:

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

Web

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

Kotlin

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

Java

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

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

TIMESTAMP_DIFF

תחביר:

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

תיאור:

הפונקציה מחזירה את המספר השלם של מרווחי unit שצוינו בין שני TIMESTAMP.

  • הפונקציה מחזירה ערך שלילי אם end קודם ל-start.
  • הפונקציה מעגלת כל יחידה לא שלמה. לדוגמה, הפונקציה timestamp_diff("2021-01-01 00:00:01", "2021-01-01 00:00:00", "minute") מחזירה 0.

הארגומנט unit חייב להיות מחרוזת ואחד מהערכים הבאים:

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

לדוגמה:

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

תחביר:

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

תיאור:

הפונקציה מחלצת part ספציפי (למשל, שנה, חודש, יום) מ-timestamp.

הארגומנט part חייב להיות מחרוזת ואחד מהערכים הבאים:

  • microsecond
  • millisecond
  • second
  • minute
  • hour
  • day
  • ‫dayofweek: מחזירה ערך בין 1 (יום ראשון) ל-7 (יום שבת).
  • dayofyear
  • ‫week: הפונקציה מחזירה את מספר השבוע בשנה, החל מ-1 ביום ראשון הראשון של השנה.
  • ‫week([weekday]): מחזירה את מספר השבוע בשנה, החל מהיום weekday שצוין.
  • month
  • quarter
  • year
  • ‫isoweek: מחזירה את מספר השבוע לפי ISO 8601.
  • ‫isoyear: מחזירה את השנה לפי מספור השבועות בתקן ISO 8601.

אם מציינים את הארגומנט timezone, החילוץ יתבסס על היומן של אזור הזמן שצוין. החילוץ יתבצע בהתאם לשעון הקיץ.

אם לא מציינים את timezone, החילוץ יתבסס על UTC.

הארגומנט timezone צריך להיות מחרוזת שמייצגת אזור זמן ממסד הנתונים של אזורי הזמן, למשל America/New_York. אפשר גם להשתמש בהזזת זמן בהתאמה אישית על ידי ציון הזזה מ-GMT.

לדוגמה:

timestamp part timezone timestamp_extract(timestamp, part, timezone)
2025-02-20 10:20:30 UTC ‫"year" לא צוין 2025
2025-02-20 10:20:30 UTC ‫"day" לא צוין 20
2025-12-31 23:59:59 UTC ‫"year" ‫"Asia/Tokyo" 2026

פונקציות הקלדה

שם תיאור
TYPE הפונקציה מחזירה את סוג הערך כ-STRING.
IS_TYPE הפונקציה מחזירה את הערך true אם הערך תואם לסוג שצוין.

סוג

תחביר:

type(input: ANY) -> STRING

תיאור:

מחזירה ייצוג מחרוזת של הסוג input.

אם לא ניתן ערך, הפונקציה מחזירה NULL.

לדוגמה:

input type(input)
NULL ‪"null"
true "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} ‫"map"‏ (מפה)
path("c/d") ‫"reference"
vector([1.0, 2.0]) ‫"vector"
ABSENT NULL

דוגמאות ללקוחות

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

Web

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

Kotlin

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

Java

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

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

IS_TYPE

תחביר:

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

תיאור:

הפונקציה מחזירה את הערך true אם input תואם לערך type שצוין, אחרת היא מחזירה את הערך false. אם לא מצוין ערך ל-input, הפונקציה מחזירה NULL.

המחרוזות הנתמכות של 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"

לדוגמה:

input type is_type(input, type)
NULL ‪"null" true
true "boolean" true
3.14 ‫"float64" true
‪"foo" "string" true
b"foo" "string" false
[1, 2] "array" true
‪{"a": 1} ‫"map"‏ (מפה) true
vector([1.0, 2.0]) ‫"vector" true
ABSENT "string" NULL
"bar" ‫"other" שגיאה

פונקציות וקטוריות

שם תיאור
COSINE_DISTANCE מחזירה את מרחק הקוסינוס בין שני וקטורים
DOT_PRODUCT הפונקציה מחזירה את המכפלה הסקלרית בין שני וקטורים
EUCLIDEAN_DISTANCE הפונקציה מחזירה את המרחק האוקלידי בין שני וקטורים
MANHATTAN_DISTANCE הפונקציה מחזירה את מרחק מנהטן בין שני וקטורים
VECTOR_LENGTH הפונקציה מחזירה את מספר הרכיבים בווקטור

COSINE_DISTANCE

תחביר:

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

תיאור:

הפונקציה מחזירה את מרחק הקוסינוס בין x ל-y.

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

Web

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

Kotlin

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

Java

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

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

DOT_PRODUCT

תחביר:

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

תיאור:

הפונקציה מחזירה את המכפלה הסקלרית של x ו-y.

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

Web

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

Kotlin

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

Java

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

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

EUCLIDEAN_DISTANCE

תחביר:

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

תיאור:

הפונקציה מחשבת את המרחק האוקלידי בין x ל-y.

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

Web

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

Kotlin

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

Java

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

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

MANHATTAN_DISTANCE

תחביר:

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

תיאור:

מחשבת את מרחק מנהטן בין x לבין y.

VECTOR_LENGTH

תחביר:

vector_length(vector: VECTOR) -> INT64

תיאור:

הפונקציה מחזירה את מספר הרכיבים ב-VECTOR.

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

Web

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

Kotlin

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

Java

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

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