כל הפונקציות

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

Web

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

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

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

Kotlin

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

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

Java

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

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

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

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

// Number of books with nonnull `ratings` field
Pipeline.Snapshot countField =
    firestore
        .pipeline()
        .collection("books")
        .aggregate(count("ratings").as("count"))
        .execute()
        .get();
המשך
// Total number of books in the collection
countAll, err := client.Pipeline().Collection("books").
	Aggregate(firestore.Accumulators(firestore.CountAll().As("count"))).
	Execute(ctx).Results().GetAll()
if err != nil {
	fmt.Fprintf(w, "GetAll failed: %v", err)
	return err
}

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

COUNT_IF

תחביר:

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .aggregate(Field.of("rating").greater_than(4).count_if().as_("filteredCount"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .aggregate(countIf(field("rating").greaterThan(4)).as("filteredCount"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("books").
	Aggregate(firestore.Accumulators(
		firestore.CountIf(firestore.FieldOf("rating").GreaterThan(4)).As("filteredCount"),
	)).
	Execute(ctx)

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .aggregate(Field.of("author").count_distinct().as_("unique_authors"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .aggregate(countDistinct("author").as("unique_authors"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("books").
	Aggregate(firestore.Accumulators(
		firestore.CountDistinct("author").As("unique_authors"),
	)).
	Execute(ctx)

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

Web

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

Kotlin

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

Java

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

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

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

Web

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

Kotlin

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

Java

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

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

מינימום

תחביר:

minimum(expression: ANY) -> ANY

תיאור:

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

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

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

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

Web

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

Kotlin

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

Java

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

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

מקסימום

תחביר:

maximum(expression: ANY) -> ANY

תיאור:

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

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

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

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

Web

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

Kotlin

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

Java

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

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

ראשון

תחביר:

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.
  • יוצרת שגיאה אם מתרחש גלישה או חוסר גלישה.

‫Cloud Firestore מבצע הרחבה של סוגים מספריים על סמך ההיררכיה הבאה: INT32 < INT64 < FLOAT64 < DECIMAL128. כשפונקציה אריתמטית מקבלת כמה ארגומנטים מספריים מסוגים שונים (לדוגמה, add(5.0D, 6L)), סוגים צרים יותר מומרים באופן מרומז לסוג הרחב ביותר שקיים בין האופרנדים. בדוגמה הקודמת, ה-6L הורחב ל-6.0D, ולכן הביטוי מחזיר סוג FLOAT64.

המרה משתמעת מ-INT64 ל-FLOAT64 עלולה לגרום לאובדן דיוק, כי הערך שעבר המרה עלול לאבד את הביטים הכי פחות משמעותיים שלו. הערך שיתקבל יהיה גרסה מעוגלת של ערך המספר השלם המקורי, באמצעות מצב העיגול הקרוב ביותר של IEEE 754.

שם תיאור
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();

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("soldBooks").add(Field.of("unsoldBooks")).as_("totalBooks"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(add(field("soldBooks"), field("unsoldBooks")).as("totalBooks"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.Add(firestore.FieldOf("soldBooks"), firestore.FieldOf("unsoldBooks")).As("totalBooks"),
	)).
	Execute(ctx)

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

Web

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

Kotlin

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

Java

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

store_credit = 7
result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("price").subtract(store_credit).as_("totalCost"))
    .execute()
)
Java
int storeCredit = 7;
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(subtract(field("price"), storeCredit).as("totalCost"))
        .execute()
        .get();
המשך
storeCredit := 7
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.Subtract(firestore.FieldOf("price"), storeCredit).As("totalCost"),
	)).
	Execute(ctx)

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("price").multiply(Field.of("soldBooks")).as_("revenue"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(multiply(field("price"), field("soldBooks")).as("revenue"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.Multiply(firestore.FieldOf("price"), firestore.FieldOf("soldBooks")).As("revenue"),
	)).
	Execute(ctx)

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("ratings").divide(Field.of("soldBooks")).as_("reviewRate"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(divide(field("ratings"), field("soldBooks")).as("reviewRate"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.Divide(firestore.FieldOf("ratings"), firestore.FieldOf("soldBooks")).As("reviewRate"),
	)).
	Execute(ctx)

מתמר

תחביר:

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

Web

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

Kotlin

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

Java

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

display_capacity = 1000
result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("unsoldBooks").mod(display_capacity).as_("warehousedBooks"))
    .execute()
)
Java
int displayCapacity = 1000;
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(mod(field("unsoldBooks"), displayCapacity).as("warehousedBooks"))
        .execute()
        .get();
המשך
displayCapacity := 1000
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.Mod(firestore.FieldOf("unsoldBooks"), displayCapacity).As("warehousedBooks"),
	)).
	Execute(ctx)

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

Web

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

Kotlin

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

Java

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

books_per_shelf = 100
result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("unsoldBooks")
        .divide(books_per_shelf)
        .ceil()
        .as_("requiredShelves")
    )
    .execute()
)
Java
int booksPerShelf = 100;
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(ceil(divide(field("unsoldBooks"), booksPerShelf)).as("requiredShelves"))
        .execute()
        .get();
המשך
booksPerShelf := 100
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.Ceil(firestore.Divide(firestore.FieldOf("unsoldBooks"), booksPerShelf)).As("requiredShelves"),
	)).
	Execute(ctx)

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .add_fields(
        Field.of("wordCount").divide(Field.of("pages")).floor().as_("wordsPerPage")
    )
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .addFields(floor(divide(field("wordCount"), field("pages"))).as("wordsPerPage"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("books").
	AddFields(firestore.Selectables(
		firestore.Floor(firestore.Divide(firestore.FieldOf("wordCount"), firestore.FieldOf("pages"))).As("wordsPerPage"),
	)).
	Execute(ctx)

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("soldBooks")
        .multiply(Field.of("price"))
        .round()
        .as_("partialRevenue")
    )
    .aggregate(Field.of("partialRevenue").sum().as_("totalRevenue"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(round(multiply(field("soldBooks"), field("price"))).as("partialRevenue"))
        .aggregate(sum("partialRevenue").as("totalRevenue"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.Round(firestore.Multiply(firestore.FieldOf("soldBooks"), firestore.FieldOf("price"))).As("partialRevenue"),
	)).
	Aggregate(firestore.Accumulators(
		firestore.Sum("partialRevenue").As("totalRevenue"),
	)).
	Execute(ctx)

TRUNC

תחביר:

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.

לדוגמה:

בסיס מעריך 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();

Web

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

Kotlin

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

Java

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

googleplexLat = 37.4221
googleplexLng = -122.0853
result = (
    client.pipeline()
    .collection("cities")
    .add_fields(
        Field.of("lat")
        .subtract(googleplexLat)
        .multiply(111)  # km per degree
        .pow(2)
        .as_("latitudeDifference"),
        Field.of("lng")
        .subtract(googleplexLng)
        .multiply(111)  # km per degree
        .pow(2)
        .as_("longitudeDifference"),
    )
    .select(
        Field.of("latitudeDifference")
        .add(Field.of("longitudeDifference"))
        .sqrt()
        # Inaccurate for large distances or close to poles
        .as_("approximateDistanceToGoogle")
    )
    .execute()
)
Java
double googleplexLat = 37.4221;
double googleplexLng = -122.0853;
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("cities")
        .addFields(
            pow(multiply(subtract(field("lat"), googleplexLat), 111), 2)
                .as("latitudeDifference"),
            pow(multiply(subtract(field("lng"), googleplexLng), 111), 2)
                .as("longitudeDifference"))
        .select(
            sqrt(add(field("latitudeDifference"), field("longitudeDifference")))
                // Inaccurate for large distances or close to poles
                .as("approximateDistanceToGoogle"))
        .execute()
        .get();
המשך
googleplexLat := 37.4221
googleplexLng := -122.0853
snapshot := client.Pipeline().
	Collection("cities").
	AddFields(firestore.Selectables(
		firestore.Pow(firestore.Multiply(firestore.Subtract(firestore.FieldOf("lat"), googleplexLat), 111), 2).As("latitudeDifference"),
		firestore.Pow(firestore.Multiply(firestore.Subtract(firestore.FieldOf("lng"), googleplexLng), 111), 2).As("longitudeDifference"),
	)).
	Select(firestore.Fields(
		firestore.Sqrt(firestore.Add(firestore.FieldOf("latitudeDifference"), firestore.FieldOf("longitudeDifference"))).
			// Inaccurate for large distances or close to poles
			As("approximateDistanceToGoogle"),
	)).
	Execute(ctx)

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

Web

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

Kotlin

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

Java

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

googleplexLat = 37.4221
googleplexLng = -122.0853
result = (
    client.pipeline()
    .collection("cities")
    .add_fields(
        Field.of("lat")
        .subtract(googleplexLat)
        .multiply(111)  # km per degree
        .pow(2)
        .as_("latitudeDifference"),
        Field.of("lng")
        .subtract(googleplexLng)
        .multiply(111)  # km per degree
        .pow(2)
        .as_("longitudeDifference"),
    )
    .select(
        Field.of("latitudeDifference")
        .add(Field.of("longitudeDifference"))
        .sqrt()
        # Inaccurate for large distances or close to poles
        .as_("approximateDistanceToGoogle")
    )
    .execute()
)
Java
double googleplexLat = 37.4221;
double googleplexLng = -122.0853;
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("cities")
        .addFields(
            pow(multiply(subtract(field("lat"), googleplexLat), 111), 2)
                .as("latitudeDifference"),
            pow(multiply(subtract(field("lng"), googleplexLng), 111), 2)
                .as("longitudeDifference"))
        .select(
            sqrt(add(field("latitudeDifference"), field("longitudeDifference")))
                // Inaccurate for large distances or close to poles
                .as("approximateDistanceToGoogle"))
        .execute()
        .get();
המשך
googleplexLat := 37.4221
googleplexLng := -122.0853
snapshot := client.Pipeline().
	Collection("cities").
	AddFields(firestore.Selectables(
		firestore.Pow(firestore.Multiply(firestore.Subtract(firestore.FieldOf("lat"), googleplexLat), 111), 2).As("latitudeDifference"),
		firestore.Pow(firestore.Multiply(firestore.Subtract(firestore.FieldOf("lng"), googleplexLng), 111), 2).As("longitudeDifference"),
	)).
	Select(firestore.Fields(
		firestore.Sqrt(firestore.Add(firestore.FieldOf("latitudeDifference"), firestore.FieldOf("longitudeDifference"))).
			// Inaccurate for large distances or close to poles
			As("approximateDistanceToGoogle"),
	)).
	Execute(ctx)

EXP

תחביר:

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

Web

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

Kotlin

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

Java

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

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

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

Web

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

Kotlin

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

Java

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

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

LOG

תחביר:

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

תיאור:

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

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

לדוגמה:

מספר בסיס 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

תיאור:

הפונקציה מחזירה מספר נקודה צפה פסאודו-אקראי, שנבחר באופן אחיד בין 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();
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("genre").arrayConcat([Field("subGenre")]).as("allGenres")])
  .execute()

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("genre").array_concat(Field.of("subGenre")).as_("allGenres"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(arrayConcat(field("genre"), field("subGenre")).as("allGenres"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.ArrayConcat(firestore.FieldOf("genre"), firestore.FieldOf("subGenre")).As("allGenres"),
	)).
	Execute(ctx)

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("genre").array_contains("mystery").as_("isMystery"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(arrayContains(field("genre"), "mystery").as("isMystery"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.ArrayContains(firestore.FieldOf("genre"), "mystery").As("isMystery"),
	)).
	Execute(ctx)

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("genre")
        .array_contains_all(["fantasy", "adventure"])
        .as_("isFantasyAdventure")
    )
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            arrayContainsAll(field("genre"), Arrays.asList("fantasy", "adventure"))
                .as("isFantasyAdventure"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.ArrayContainsAll(firestore.FieldOf("genre"), []string{"fantasy", "adventure"}).As("isFantasyAdventure"),
	)).
	Execute(ctx)

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("genre")
        .array_contains_any(["fantasy", "nonfiction"])
        .as_("isMysteryOrFantasy")
    )
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            arrayContainsAny(field("genre"), Arrays.asList("fantasy", "nonfiction"))
                .as("isMysteryOrFantasy"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.ArrayContainsAny(firestore.FieldOf("genre"), []string{"fantasy", "nonfiction"}).As("isMysteryOrFantasy"),
	)).
	Execute(ctx)

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

Web

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

Kotlin

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

Java

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

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

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

Web

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

Kotlin

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

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

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

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>

תיאור:

הפונקציה מחזירה מערך שמכיל את האינדקסים (המספרים) של כל המופעים של value ב-array, כשהספירה מתחילה מ-0. הפונקציה מחזירה [] אם 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();

Web

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

Kotlin

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

Java

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

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

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("rating").greater_than(4).as_("hasHighRating"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(greaterThan(field("rating"), 4).as("hasHighRating"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.GreaterThan(firestore.FieldOf("rating"), 4).As("hasHighRating"),
	)).
	Execute(ctx)

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("published")
        .greater_than_or_equal(1900)
        .as_("publishedIn20thCentury")
    )
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(greaterThanOrEqual(field("published"), 1900).as("publishedIn20thCentury"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.GreaterThanOrEqual(firestore.FieldOf("published"), 1900).As("publishedIn20thCentury"),
	)).
	Execute(ctx)

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("published").less_than(1923).as_("isPublicDomainProbably"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(lessThan(field("published"), 1923).as("isPublicDomainProbably"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.LessThan(firestore.FieldOf("published"), 1923).As("isPublicDomainProbably"),
	)).
	Execute(ctx)

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("rating").less_than_or_equal(2).as_("hasBadRating"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(lessThanOrEqual(field("rating"), 2).as("hasBadRating"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.LessThanOrEqual(firestore.FieldOf("rating"), 2).As("hasBadRating"),
	)).
	Execute(ctx)

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("title").not_equal("1984").as_("not1984"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(notEqual(field("title"), "1984").as("not1984"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.NotEqual(firestore.FieldOf("title"), "1984").As("not1984"),
	)).
	Execute(ctx)

השל

תחביר:

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

תיאור:

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

  • ‫1L אם x גדול מ-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();

Web

לדוגמה:

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

Kotlin

לדוגמה:

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

Java

לדוגמה:

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

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

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

תחביר:

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(
        And(
            Field.of("rating").greater_than(4), Field.of("price").less_than(10)
        ).as_("under10Recommendation")
    )
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            and(greaterThan(field("rating"), 4), lessThan(field("price"), 10))
                .as("under10Recommendation"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.And(
			firestore.GreaterThan(firestore.FieldOf("rating"), 4),
			firestore.LessThan(firestore.FieldOf("price"), 10),
		).As("under10Recommendation"),
	)).
	Execute(ctx)

או

תחביר:

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(
        Or(
            Field.of("genre").equal("Fantasy"),
            Field.of("tags").array_contains("adventure"),
        ).as_("matchesSearchFilters")
    )
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            or(equal(field("genre"), "Fantasy"), arrayContains(field("tags"), "adventure"))
                .as("matchesSearchFilters"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.Or(
			firestore.Equal(firestore.FieldOf("genre"), "Fantasy"),
			firestore.ArrayContains(firestore.FieldOf("tags"), "adventure"),
		).As("matchesSearchFilters"),
	)).
	Execute(ctx)

XOR

תחביר:

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(
        Xor(
            [
                Field.of("tags").array_contains("magic"),
                Field.of("tags").array_contains("nonfiction"),
            ]
        ).as_("matchesSearchFilters")
    )
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            xor(
                    arrayContains(field("tags"), "magic"),
                    arrayContains(field("tags"), "nonfiction"))
                .as("matchesSearchFilters"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.Xor(
			firestore.ArrayContains(firestore.FieldOf("tags"), "magic"),
			firestore.ArrayContains(firestore.FieldOf("tags"), "nonfiction"),
		).As("matchesSearchFilters"),
	)).
	Execute(ctx)

NOR

תחביר:

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

תיאור:

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

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(Not(Field.of("tags").array_contains("nonfiction")).as_("isFiction"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(not(arrayContains(field("tags"), "nonfiction")).as("isFiction"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.Not(firestore.ArrayContains(firestore.FieldOf("tags"), "nonfiction")).As("isFiction"),
	)).
	Execute(ctx)

מותנה

תחביר:

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("tags")
        .array_concat(
            Conditional(
                Field.of("pages").greater_than(100),
                Constant.of("longRead"),
                Constant.of("shortRead"),
            )
        )
        .as_("extendedTags")
    )
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            arrayConcat(
                    field("tags"),
                    conditional(
                        greaterThan(field("pages"), 100),
                        constant("longRead"),
                        constant("shortRead")))
                .as("extendedTags"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.ArrayConcat(
			firestore.FieldOf("tags"),
			firestore.Conditional(
				firestore.GreaterThan(firestore.FieldOf("pages"), 100),
				firestore.ConstantOf("longRead"),
				firestore.ConstantOf("shortRead"),
			),
		).As("extendedTags"),
	)).
	Execute(ctx)

IF_NULL

תחביר:

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, תוצג שגיאה אם אף אחד מהתנאים האחרים לא יחזיר את הערך 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")
  )
);

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("genre")
        .equal_any(["Science Fiction", "Psychological Thriller"])
        .as_("matchesGenreFilters")
    )
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            equalAny(field("genre"), Arrays.asList("Science Fiction", "Psychological Thriller"))
                .as("matchesGenreFilters"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.EqualAny(firestore.FieldOf("genre"), []string{"Science Fiction", "Psychological Thriller"}).As("matchesGenreFilters"),
	)).
	Execute(ctx)

NOT_EQUAL_ANY

תחביר:

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("author")
        .not_equal_any(["George Orwell", "F. Scott Fitzgerald"])
        .as_("byExcludedAuthors")
    )
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            notEqualAny(field("author"), Arrays.asList("George Orwell", "F. Scott Fitzgerald"))
                .as("byExcludedAuthors"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.NotEqualAny(firestore.FieldOf("author"), []string{"George Orwell", "F. Scott Fitzgerald"}).As("byExcludedAuthors"),
	)).
	Execute(ctx)

מקסימום

תחביר:

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("rating").logical_maximum(1).as_("flooredRating"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(logicalMaximum(field("rating"), 1).as("flooredRating"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.LogicalMaximum(firestore.FieldOf("rating"), 1).As("flooredRating"),
	)).
	Execute(ctx)

מינימום

תחביר:

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("rating").logical_minimum(5).as_("cappedRating"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(logicalMinimum(field("rating"), 5).as("cappedRating"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.LogicalMinimum(firestore.FieldOf("rating"), 5).As("cappedRating"),
	)).
	Execute(ctx)

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

שם תיאור
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();

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("awards").map_get("pulitzer").as_("hasPulitzerAward"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(mapGet(field("awards"), "pulitzer").as("hasPulitzerAward"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.MapGet(firestore.FieldOf("awards"), "pulitzer").As("hasPulitzerAward"),
	)).
	Execute(ctx)

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

Web

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

Kotlin

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

Java

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

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

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

Web

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

Kotlin

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

Java

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

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

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("title").starts_with("The").as_("needsSpecialAlphabeticalSort")
    )
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(startsWith(field("title"), "The").as("needsSpecialAlphabeticalSort"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.StartsWith(firestore.FieldOf("title"), "The").As("needsSpecialAlphabeticalSort"),
	)).
	Execute(ctx)

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();
Swift
let result = try await db.pipeline()
  .collection("inventory/devices/laptops")
  .select([
    Field("name").endsWith("16 inch")
      .as("16InLaptops")
  ])
  .execute()

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("inventory/devices/laptops")
    .select(Field.of("name").ends_with("16 inch").as_("16InLaptops"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("inventory/devices/laptops")
        .select(endsWith(field("name"), "16 inch").as("16InLaptops"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("inventory/devices/laptops").
	Select(firestore.Fields(
		firestore.EndsWith(firestore.FieldOf("name"), "16 inch").As("`Laptops16in`"),
	)).
	Execute(ctx)

אהבתי

תחביר:

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

תיאור:

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

לדוגמה:

ערך 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();

Web

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

Kotlin

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

Java

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

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

REGEX_CONTAINS

תחביר:

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

תיאור:

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

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

לדוגמה:

ערך pattern 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();

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("documents")
    .select(
        Field.of("title")
        .regex_contains("Firestore (Enterprise|Standard)")
        .as_("isFirestoreRelated")
    )
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(
            regexContains(field("title"), "Firestore (Enterprise|Standard)")
                .as("isFirestoreRelated"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("documents").
	Select(firestore.Fields(
		firestore.RegexContains(firestore.FieldOf("title"), "Firestore (Enterprise|Standard)").As("isFirestoreRelated"),
	)).
	Execute(ctx)

REGEX_MATCH

תחביר:

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

תיאור:

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

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

לדוגמה:

ערך pattern 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();

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("documents")
    .select(
        Field.of("title")
        .regex_match("Firestore (Enterprise|Standard)")
        .as_("isFirestoreExactly")
    )
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(
            regexMatch(field("title"), "Firestore (Enterprise|Standard)")
                .as("isFirestoreExactly"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("documents").
	Select(firestore.Fields(
		firestore.RegexMatch(firestore.FieldOf("title"), "Firestore (Enterprise|Standard)").As("isFirestoreExactly"),
	)).
	Execute(ctx)

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("title")
        .concat(" by ", Field.of("author"))
        .as_("fullyQualifiedTitle")
    )
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(stringConcat(field("title"), " by ", field("author")).as("fullyQualifiedTitle"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.StringConcat(firestore.FieldOf("title"), " by ", firestore.FieldOf("author")).As("fullyQualifiedTitle"),
	)).
	Execute(ctx)

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("articles")
    .select(Field.of("body").string_contains("Firestore").as_("isFirestoreRelated"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("articles")
        .select(stringContains(field("body"), "Firestore").as("isFirestoreRelated"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("articles").
	Select(firestore.Fields(
		firestore.StringContains(firestore.FieldOf("body"), "Firestore").As("isFirestoreRelated"),
	)).
	Execute(ctx)

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

Web

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

Kotlin

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

Java

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

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

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("authors")
    .select(Field.of("genre").to_lower().equal("fantasy").as_("isFantasy"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("authors")
        .select(equal(toLower(field("genre")), "fantasy").as("isFantasy"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("authors").
	Select(firestore.Fields(
		firestore.Equal(firestore.ToLower(firestore.FieldOf("genre")), "fantasy").As("isFantasy"),
	)).
	Execute(ctx)

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .where(Field.of("title").starts_with("The "))
    .select(Field.of("title").substring(4).as_("titleWithoutLeadingThe"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .where(startsWith(field("title"), "The "))
        .select(
            substring(field("title"), constant(4), field("title").charLength())
                .as("titleWithoutLeadingThe"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("books").
	Where(firestore.StartsWith(firestore.FieldOf("title"), "The ")).
	Select(firestore.Fields(
		firestore.Substring(firestore.FieldOf("title"), firestore.ConstantOf(4), firestore.FieldOf("title").CharLength()).As("titleWithoutLeadingThe"),
	)).
	Execute(ctx)

STRING_REVERSE

תחביר:

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

Web

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

Kotlin

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

Java

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

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

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

Kotlin

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

Java

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

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

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("documents")
    .select(
        Field.of("createdAtMicros")
        .unix_micros_to_timestamp()
        .as_("createdAtString")
    )
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(unixMicrosToTimestamp(field("createdAtMicros")).as("createdAtString"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("documents").
	Select(firestore.Fields(
		firestore.UnixMicrosToTimestamp(firestore.FieldOf("createdAtMicros")).As("createdAtString"),
	)).
	Execute(ctx)

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("documents")
    .select(
        Field.of("createdAtMillis")
        .unix_millis_to_timestamp()
        .as_("createdAtString")
    )
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(unixMillisToTimestamp(field("createdAtMillis")).as("createdAtString"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("documents").
	Select(firestore.Fields(
		firestore.UnixMillisToTimestamp(firestore.FieldOf("createdAtMillis")).As("createdAtString"),
	)).
	Execute(ctx)

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("documents")
    .select(
        Field.of("createdAtSeconds")
        .unix_seconds_to_timestamp()
        .as_("createdAtString")
    )
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(unixSecondsToTimestamp(field("createdAtSeconds")).as("createdAtString"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("documents").
	Select(firestore.Fields(
		firestore.UnixSecondsToTimestamp(firestore.FieldOf("createdAtSeconds")).As("createdAtString"),
	)).
	Execute(ctx)

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("documents")
    .select(Field.of("createdAt").timestamp_add("day", 3653).as_("expiresAt"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(timestampAdd(field("createdAt"), "day", 3653).as("expiresAt"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("documents").
	Select(firestore.Fields(
		firestore.TimestampAdd(firestore.FieldOf("createdAt"), "day", 3653).As("expiresAt"),
	)).
	Execute(ctx)

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("documents")
    .select(
        Field.of("expiresAt")
        .timestamp_subtract("day", 14)
        .as_("sendWarningTimestamp")
    )
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(timestampSubtract(field("expiresAt"), "day", 14).as("sendWarningTimestamp"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("documents").
	Select(firestore.Fields(
		firestore.TimestampSubtract(firestore.FieldOf("expiresAt"), "day", 14).As("sendWarningTimestamp"),
	)).
	Execute(ctx)

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("documents")
    .select(Field.of("dateString").timestamp_to_unix_micros().as_("unixMicros"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(timestampToUnixMicros(field("dateString")).as("unixMicros"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("documents").
	Select(firestore.Fields(
		firestore.TimestampToUnixMicros(firestore.FieldOf("dateString")).As("unixMicros"),
	)).
	Execute(ctx)

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("documents")
    .select(Field.of("dateString").timestamp_to_unix_millis().as_("unixMillis"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(timestampToUnixMillis(field("dateString")).as("unixMillis"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("documents").
	Select(firestore.Fields(
		firestore.TimestampToUnixMillis(firestore.FieldOf("dateString")).As("unixMillis"),
	)).
	Execute(ctx)

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

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("documents")
    .select(Field.of("dateString").timestamp_to_unix_seconds().as_("unixSeconds"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(timestampToUnixSeconds(field("dateString")).as("unixSeconds"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("documents").
	Select(firestore.Fields(
		firestore.TimestampToUnixSeconds(firestore.FieldOf("dateString")).As("unixSeconds"),
	)).
	Execute(ctx)

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 Functions

שם תיאור
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();

Web

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

Kotlin

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

Java

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

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("title").not_equal("1984").as_("not1984"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(notEqual(field("title"), "1984").as("not1984"))
        .execute()
        .get();
המשך
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.NotEqual(firestore.FieldOf("title"), "1984").As("not1984"),
	)).
	Execute(ctx)

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

Web

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

Kotlin

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

Java

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

sample_vector = Vector([0.0, 1.0, 2.0, 3.0, 4.0, 5.0])
result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("embedding").cosine_distance(sample_vector).as_("cosineDistance")
    )
    .execute()
)
Java
double[] sampleVector = new double[] {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(cosineDistance(field("embedding"), sampleVector).as("cosineDistance"))
        .execute()
        .get();
המשך
sampleVector := []float64{0.0, 1.0, 2.0, 3.0, 4.0, 5.0}
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.CosineDistance(firestore.FieldOf("embedding"), sampleVector).As("cosineDistance"),
	)).
	Execute(ctx)

DOT_PRODUCT

תחביר:

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

Web

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

Kotlin

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

Java

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

sample_vector = Vector([0.0, 1.0, 2.0, 3.0, 4.0, 5.0])
result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("embedding").dot_product(sample_vector).as_("dotProduct"))
    .execute()
)
Java
double[] sampleVector = new double[] {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(dotProduct(field("embedding"), sampleVector).as("dotProduct"))
        .execute()
        .get();
המשך
sampleVector := []float64{0.0, 1.0, 2.0, 3.0, 4.0, 5.0}
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.DotProduct(firestore.FieldOf("embedding"), sampleVector).As("dotProduct"),
	)).
	Execute(ctx)

EUCLIDEAN_DISTANCE

תחביר:

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

Web

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

Kotlin

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

Java

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

sample_vector = Vector([0.0, 1.0, 2.0, 3.0, 4.0, 5.0])
result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("embedding")
        .euclidean_distance(sample_vector)
        .as_("euclideanDistance")
    )
    .execute()
)
Java
double[] sampleVector = new double[] {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(euclideanDistance(field("embedding"), sampleVector).as("euclideanDistance"))
        .execute()
        .get();
המשך
sampleVector := []float64{0.0, 1.0, 2.0, 3.0, 4.0, 5.0}
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.EuclideanDistance(firestore.FieldOf("embedding"), sampleVector).As("euclideanDistance"),
	)).
	Execute(ctx)

MANHATTAN_DISTANCE

תחביר:

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

Web

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

Kotlin

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

Java

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

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