צבירה
אפשר להשתמש בכל פונקציות הצבירה כביטויים ברמה העליונה בשלב 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
תיאור:
הפונקציה מחזירה את הערך המקסימלי שאינו NULL ואינו חסר של expression, כשהוא מוערך בכל מסמך.
אם אין ערכים שהם לא 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(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
|
הפונקציה מחזירה מספר אקראי לכאורה בשיטת נקודה צפה (float) |
ABS
תחביר:
abs[N <: INT32 | INT64 | FLOAT64 | DECIMAL128](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 | DECIMAL128](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 | DECIMAL128](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 | DECIMAL128](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 | DECIMAL128](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 |
| 0.0 | 0.0 | NaN |
+inf |
+inf |
NaN |
Node.js
const result = await db.pipeline() .collection("books") .select(field("ratings").divide(field("soldBooks")).as("reviewRate")) .execute();
Web
const result = await execute(db.pipeline() .collection("books") .select(field("ratings").divide(field("soldBooks")).as("reviewRate")) );
Swift
let result = try await db.pipeline() .collection("books") .select([Field("ratings").divide(Field("soldBooks")).as("reviewRate")]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select(Expression.divide(field("ratings"), field("soldBooks")).alias("reviewRate")) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select(Expression.divide(field("ratings"), field("soldBooks")).alias("reviewRate")) .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field result = ( client.pipeline() .collection("books") .select(Field.of("ratings").divide(Field.of("soldBooks")).as_("reviewRate")) .execute() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(divide(field("ratings"), field("soldBooks")).as("reviewRate")) .execute() .get();
המשך
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 | DECIMAL128](x: N, y: N) -> N
תיאור:
הפונקציה מחזירה את השארית של x / y.
- הפונקציה מחזירה שגיאת
errorכש-yהוא אפס לסוגי מספרים שלמים (INT64). - הפונקציה מחזירה את הערך
NaNכש-yהוא אפס לסוגי מספרים ממשיים (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 | DECIMAL128](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 |
NaN |
NaN |
+inf |
+inf |
-inf |
-inf |
Node.js
const booksPerShelf = 100; const result = await db.pipeline() .collection("books") .select( field("unsoldBooks").divide(constant(booksPerShelf)).ceil().as("requiredShelves") ) .execute();
Web
const booksPerShelf = 100; const result = await execute(db.pipeline() .collection("books") .select( field("unsoldBooks").divide(constant(booksPerShelf)).ceil().as("requiredShelves") ) );
Swift
let booksPerShelf = 100 let result = try await db.pipeline() .collection("books") .select([ Field("unsoldBooks").divide(Constant(booksPerShelf)).ceil().as("requiredShelves") ]) .execute()
Kotlin
val booksPerShelf = 100 val result = db.pipeline() .collection("books") .select( Expression.divide(field("unsoldBooks"), booksPerShelf).ceil().alias("requiredShelves") ) .execute()
Java
int booksPerShelf = 100; Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select( Expression.divide(field("unsoldBooks"), booksPerShelf).ceil().alias("requiredShelves") ) .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field books_per_shelf = 100 result = ( client.pipeline() .collection("books") .select( Field.of("unsoldBooks") .divide(books_per_shelf) .ceil() .as_("requiredShelves") ) .execute() )
Java
int booksPerShelf = 100; Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(ceil(divide(field("unsoldBooks"), booksPerShelf)).as("requiredShelves")) .execute() .get();
המשך
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 | DECIMAL128](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 |
NaN |
NaN |
+inf |
+inf |
-inf |
-inf |
Node.js
const result = await db.pipeline() .collection("books") .addFields( field("wordCount").divide(field("pages")).floor().as("wordsPerPage") ) .execute();
Web
const result = await execute(db.pipeline() .collection("books") .addFields( field("wordCount").divide(field("pages")).floor().as("wordsPerPage") ) );
Swift
let result = try await db.pipeline() .collection("books") .addFields([ Field("wordCount").divide(Field("pages")).floor().as("wordsPerPage") ]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .addFields( Expression.divide(field("wordCount"), field("pages")).floor().alias("wordsPerPage") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .addFields( Expression.divide(field("wordCount"), field("pages")).floor().alias("wordsPerPage") ) .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field result = ( client.pipeline() .collection("books") .add_fields( Field.of("wordCount").divide(Field.of("pages")).floor().as_("wordsPerPage") ) .execute() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .addFields(floor(divide(field("wordCount"), field("pages"))).as("wordsPerPage")) .execute() .get();
המשך
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(כוללNaN),pow(1, exponent)הוא 1.לכל
base(כוללNaN),pow(base, 0)הוא 1.
לדוגמה:
| בסיס | מעריך | pow(base, exponent) |
|---|---|---|
| 2 | 3 | 8.0 |
| 2 | -3 | 0.125 |
+inf |
0 | 1.0 |
| 1 | +inf |
1.0 |
NaN |
0 | 1.0 |
| 1 | NaN |
1.0 |
NaN |
Numeric |
NaN |
Numeric |
NaN |
NaN |
| -1 | 0.5 | [error] |
| 0 | -1 | [error] |
Node.js
const googleplex = { latitude: 37.4221, longitude: 122.0853 }; const result = await db.pipeline() .collection("cities") .addFields( field("lat").subtract(constant(googleplex.latitude)) .multiply(111 /* km per degree */) .pow(2) .as("latitudeDifference"), field("lng").subtract(constant(googleplex.longitude)) .multiply(111 /* km per degree */) .pow(2) .as("longitudeDifference") ) .select( field("latitudeDifference").add(field("longitudeDifference")).sqrt() // Inaccurate for large distances or close to poles .as("approximateDistanceToGoogle") ) .execute();
Web
const googleplex = { latitude: 37.4221, longitude: 122.0853 }; const result = await execute(db.pipeline() .collection("cities") .addFields( field("lat").subtract(constant(googleplex.latitude)) .multiply(111 /* km per degree */) .pow(2) .as("latitudeDifference"), field("lng").subtract(constant(googleplex.longitude)) .multiply(111 /* km per degree */) .pow(2) .as("longitudeDifference") ) .select( field("latitudeDifference").add(field("longitudeDifference")).sqrt() // Inaccurate for large distances or close to poles .as("approximateDistanceToGoogle") ) );
Swift
let googleplex = CLLocation(latitude: 37.4221, longitude: 122.0853) let result = try await db.pipeline() .collection("cities") .addFields([ Field("lat").subtract(Constant(googleplex.coordinate.latitude)) .multiply(111 /* km per degree */) .pow(2) .as("latitudeDifference"), Field("lng").subtract(Constant(googleplex.coordinate.latitude)) .multiply(111 /* km per degree */) .pow(2) .as("longitudeDifference") ]) .select([ Field("latitudeDifference").add(Field("longitudeDifference")).sqrt() // Inaccurate for large distances or close to poles .as("approximateDistanceToGoogle") ]) .execute()
Kotlin
val googleplex = GeoPoint(37.4221, -122.0853) val result = db.pipeline() .collection("cities") .addFields( field("lat").subtract(googleplex.latitude) .multiply(111) // km per degree .pow(2) .alias("latitudeDifference"), field("lng").subtract(googleplex.longitude) .multiply(111) // km per degree .pow(2) .alias("longitudeDifference") ) .select( field("latitudeDifference").add(field("longitudeDifference")).sqrt() // Inaccurate for large distances or close to poles .alias("approximateDistanceToGoogle") ) .execute()
Java
GeoPoint googleplex = new GeoPoint(37.4221, -122.0853); Task<Pipeline.Snapshot> result = db.pipeline() .collection("cities") .addFields( field("lat").subtract(googleplex.getLatitude()) .multiply(111 /* km per degree */) .pow(2) .alias("latitudeDifference"), field("lng").subtract(googleplex.getLongitude()) .multiply(111 /* km per degree */) .pow(2) .alias("longitudeDifference") ) .select( field("latitudeDifference").add(field("longitudeDifference")).sqrt() // Inaccurate for large distances or close to poles .alias("approximateDistanceToGoogle") ) .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field googleplexLat = 37.4221 googleplexLng = -122.0853 result = ( client.pipeline() .collection("cities") .add_fields( Field.of("lat") .subtract(googleplexLat) .multiply(111) # km per degree .pow(2) .as_("latitudeDifference"), Field.of("lng") .subtract(googleplexLng) .multiply(111) # km per degree .pow(2) .as_("longitudeDifference"), ) .select( Field.of("latitudeDifference") .add(Field.of("longitudeDifference")) .sqrt() # Inaccurate for large distances or close to poles .as_("approximateDistanceToGoogle") ) .execute() )
Java
double googleplexLat = 37.4221; double googleplexLng = -122.0853; Pipeline.Snapshot result = firestore .pipeline() .collection("cities") .addFields( pow(multiply(subtract(field("lat"), googleplexLat), 111), 2) .as("latitudeDifference"), pow(multiply(subtract(field("lng"), googleplexLng), 111), 2) .as("longitudeDifference")) .select( sqrt(add(field("latitudeDifference"), field("longitudeDifference"))) // Inaccurate for large distances or close to poles .as("approximateDistanceToGoogle")) .execute() .get();
המשך
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) |
NaN |
NaN |
+inf |
+inf |
-inf |
0 |
Node.js
const result = await db.pipeline() .collection("books") .select(field("rating").exp().as("expRating")) .execute();
Web
const result = await execute(db.pipeline() .collection("books") .select(field("rating").exp().as("expRating")) );
Swift
let result = try await db.pipeline() .collection("books") .select([Field("rating").exp().as("expRating")]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select(field("rating").exp().alias("expRating")) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select(field("rating").exp().alias("expRating")) .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field result = ( client.pipeline() .collection("books") .select(Field.of("rating").exp().as_("expRating")) .execute() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(exp(field("rating")).as("expRating")) .execute() .get();
המשך
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 |
NaN |
NaN |
-inf |
NaN |
+inf |
+inf |
x <= 0 |
[error] |
Node.js
const result = await db.pipeline() .collection("books") .select(field("rating").ln().as("lnRating")) .execute();
Web
const result = await execute(db.pipeline() .collection("books") .select(field("rating").ln().as("lnRating")) );
Swift
let result = try await db.pipeline() .collection("books") .select([Field("rating").ln().as("lnRating")]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select(field("rating").ln().alias("lnRating")) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select(field("rating").ln().alias("lnRating")) .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field result = ( client.pipeline() .collection("books") .select(Field.of("rating").ln().as_("lnRating")) .execute() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(ln(field("rating")).as("lnRating")) .execute() .get();
המשך
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 |
NaN |
Numeric |
NaN |
Numeric |
NaN |
NaN |
-inf |
Numeric |
NaN |
Numeric. |
+inf |
NaN |
number <= 0 |
Numeric |
[error] |
Numeric |
base <= 0 |
[error] |
Numeric |
1.0 | [error] |
LOG10
תחביר:
log10(x: FLOAT64) -> FLOAT64
תיאור:
הפונקציה מחזירה את הלוגריתם של number לפי בסיס 10.
לדוגמה:
| מספר | log10(number) |
|---|---|
| 100 | 2.0 |
NaN |
NaN |
-inf |
NaN |
+inf |
+inf |
x <= 0 |
[error] |
RAND
תחביר:
rand() -> FLOAT64
תיאור:
החזרת מספר נקודה צפה (floating-point) אקראי לכאורה, שנבחר באופן אחיד בין 0.0 (כולל) לבין 1.0 (לא כולל).
פונקציות מערך
| שם | תיאור |
ARRAY
|
הפונקציה מחזירה ARRAY שמכיל רכיב אחד לכל ארגומנט קלט
|
ARRAY_CONCAT
|
משרשרת כמה מערכים ל-ARRAY אחד
|
ARRAY_CONTAINS
|
הפונקציה מחזירה את הערך TRUE אם ARRAY נתון מכיל ערך מסוים
|
ARRAY_CONTAINS_ALL
|
הפונקציה מחזירה את הערך TRUE אם כל הערכים קיימים ב-ARRAY
|
ARRAY_CONTAINS_ANY
|
הפונקציה מחזירה את הערך TRUE אם אחד מהערכים קיים ב-ARRAY
|
ARRAY_FILTER
|
מסנן רכיבים מ-ARRAY שלא עומדים בתנאי
|
ARRAY_FIRST
|
הפונקציה מחזירה את הרכיב הראשון ב-ARRAY
|
ARRAY_FIRST_N
|
הפונקציה מחזירה את n הרכיבים הראשונים ב-ARRAY
|
ARRAY_GET
|
הפונקציה מחזירה את הרכיב באינדקס נתון ב-ARRAY
|
ARRAY_INDEX_OF
|
הפונקציה מחזירה את האינדקס של המופע הראשון של ערך ב-ARRAY
|
ARRAY_INDEX_OF_ALL
|
הפונקציה מחזירה את כל האינדקסים של ערך ב-ARRAY
|
ARRAY_LENGTH
|
הפונקציה מחזירה את מספר הרכיבים ב-ARRAY
|
ARRAY_LAST
|
הפונקציה מחזירה את הרכיב האחרון ב-ARRAY
|
ARRAY_LAST_N
|
הפונקציה מחזירה את n הרכיבים האחרונים ב-ARRAY
|
ARRAY_REVERSE
|
הופכת את סדר הרכיבים ב-ARRAY
|
ARRAY_SLICE
|
הפונקציה מחזירה חלק מ-ARRAY
|
ARRAY_TRANSFORM
|
המרת רכיבים ב-ARRAY על ידי החלת ביטוי על כל רכיב
|
MAXIMUM
|
הפונקציה מחזירה את הערך המקסימלי ב-ARRAY
|
MAXIMUM_N
|
הפונקציה מחזירה את n הערכים הגדולים ביותר ב-ARRAY
|
MINIMUM
|
הפונקציה מחזירה את הערך המינימלי ב-ARRAY
|
MINIMUM_N
|
הפונקציה מחזירה את הערכים הקטנים ביותר של n ב-ARRAY
|
SUM
|
הפונקציה מחזירה את הסכום של כל הערכים מסוג NUMERIC ב-ARRAY.
|
JOIN
|
מפיקה שרשור של הרכיבים ב-ARRAY כערך STRING.
|
ARRAY
תחביר:
array(values: ANY...) -> ARRAY
תיאור:
יוצרת מערך מהרכיבים שצוינו.
- אם ארגומנט לא קיים, הוא מוחלף ב-
NULLבמערך שנוצר.
לדוגמה:
| ערכים | array(values) |
|---|---|
| () | [] |
| (1, 2, 3) | [1, 2, 3] |
| ("a", 1, true) | ["a", 1, true] |
| (1, null) | [1, null] |
| (1, [2, 3]) | [1, [2, 3]] |
ARRAY_CONCAT
תחביר:
array_concat(arrays: ARRAY...) -> ARRAY
תיאור:
הפונקציה משרשרת שני מערכים או יותר ל-ARRAY אחד.
לדוגמה:
| מערכים | array_concat(arrays) |
|---|---|
| ([1, 2], [3, 4]) | [1, 2, 3, 4] |
| (["a", "b"], ["c"]) | ["a", "b", "c"] |
| ([1], [2], [3]) | [1, 2, 3] |
| ([], [1, 2]) | [1, 2] |
Node.js
const result = await db.pipeline() .collection("books") .select(field("genre").arrayConcat([field("subGenre")]).as("allGenres")) .execute();
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>
תיאור:
מחזירה מערך שמכיל את האינדקסים (הספירה מתחילה מ-0) של כל המופעים של value ב-array. הפונקציה מחזירה את הערך [] אם הערך value לא נמצא.
לדוגמה:
| מערך | ערך | array_index_of_all(array, value) |
|---|---|---|
| [1, 2, 3, 2] | 2 | [1, 3] |
| [1, 2, 3] | 4 | [] |
| [1, null, 3, null] | null | [1, 3] |
ARRAY_LAST
תחביר:
array_last(array: ARRAY) -> ANY
תיאור:
הפונקציה מחזירה את הרכיב האחרון ב-array. זה שווה ערך ל-array_get(array, -1).
- אם
arrayריק, הפונקציה מחזירה ערך חסר.
לדוגמה:
| מערך | array_last(array) |
|---|---|
| [1, 2, 3] | 3 |
| [] | לא קיים |
ARRAY_LAST_N
תחביר:
array_last_n(array: ARRAY, n: INT64) -> ARRAY
תיאור:
הפונקציה מחזירה את הרכיבים האחרונים של n ב-array.
- אם הערך של
nשלילי, הפונקציה מחזירה שגיאה.
לדוגמה:
| מערך | n | array_last_n(array, n) |
|---|---|---|
| [1, 2, 3, 4, 5] | 3 | [3, 4, 5] |
| [1, 2] | 3 | [1, 2] |
| [1, 2, 3] | 0 | [] |
ARRAY_SLICE
תחביר:
array_slice(array: ARRAY, offset: INT64, length: INT64) -> ARRAY
תיאור:
הפונקציה מחזירה קבוצת משנה של array החל מהאינדקס offset (הספירה מתחילה מ-0), וכוללת את הרכיבים length.
- אם הערך של
offsetשלילי, הוא מציין את מיקום ההתחלה מסוף המערך, כאשר-1הוא הרכיב האחרון. - אם
lengthגדול ממספר הרכיבים שנותרו במערך אחריoffset, התוצאה נמשכת עד לסוף המערך. - הערך של
lengthלא יכול להיות שלילי, אחרת תוחזר שגיאה.
לדוגמה:
| מערך | היסט | אורך | array_slice(array, offset, length) |
|---|---|---|---|
| [1, 2, 3, 4, 5] | 1 | 3 | [2, 3, 4] |
| [1, 2, 3, 4, 5] | -2 | 2 | [4, 5] |
| [1, 2, 3] | 1 | 5 | [2, 3] |
| [1, 2, 3] | 3 | 2 | [] |
ARRAY_TRANSFORM
תחביר:
array_transform(array: ARRAY, expression: (ANY) -> ANY) -> ARRAY
array_transform(array: ARRAY, expression: (ANY, INT64) -> ANY) -> ARRAY
תיאור:
הפונקציה משנה את array על ידי החלת expression על כל רכיב, ומחזירה מערך חדש עם הרכיבים שהשתנו. מערך הפלט תמיד יהיה באותו גודל כמו מערך הקלט.
-
expressionיכולה להיות פונקציה אונאריתelement -> resultאו פונקציה בינארית(element, index) -> result. - אם
expressionהוא אונרי, הוא נקרא עם כל רכיב שלarray. - אם
expressionהוא בינארי, הוא נקרא עם כל רכיב שלarrayוהאינדקס התואם שלו שמבוסס על 0.
לדוגמה:
| מערך | ביטוי | array_transform(array, expression) |
|---|---|---|
| [1, 2, 3] | x -> x * 2 | [2, 4, 6] |
| [1, 2, 3] | x -> x + 1 | [2, 3, 4] |
| [10, 20] | (x, i) -> x + i | [10, 21] |
| [] | x -> 1 | [] |
מקסימום
תחביר:
maximum(array: ARRAY) -> ANY
תיאור:
הפונקציה מחזירה את הערך המקסימלי בעמודה array.
- המערכת מתעלמת מערכי
NULLבמהלך ההשוואה. - אם
arrayריק או מכיל רק ערכיNULL, הפונקציה מחזירהNULL.
לדוגמה:
| מערך | maximum(array) |
|---|---|
| [1, 5, 2] | 5 |
| [1, null, 5] | 5 |
| ["a", "c", "b"] | "c" |
| [null, null] | null |
| [] | null |
MAXIMUM_N
תחביר:
maximum_n(array: ARRAY, n: INT64) -> ARRAY
תיאור:
הפונקציה מחזירה מערך של n הערכים הגדולים ביותר ב-array בסדר יורד.
- המערכת מתעלמת מהערכים של
NULL. - אם הערך של
nשלילי, הפונקציה מחזירה שגיאה.
לדוגמה:
| מערך | n | maximum_n(array, n) |
|---|---|---|
| [1, 5, 2, 4, 3] | 3 | [5, 4, 3] |
| [1, null, 5] | 3 | [5, 1] |
מינימום
תחביר:
minimum(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(ref: REFERENCE) -> REFERENCE
תיאור:
הפונקציה מחזירה את ההורה REFERENCE של ההפניה הנתונה, או NULL אם ההפניה היא כבר הפניה ברמה הבסיסית (root).
לדוגמה:
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
|
מבצעת פעולת "וגם" לוגית |
OR
|
מבצעת פעולת "או" לוגית |
XOR
|
מבצעת פעולת XOR לוגית |
NOT
|
מבצעת פעולת 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
תיאור:
הפונקציה מחזירה את הערך הלוגי NOT של ערך בוליאני.
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
תיאור:
הפונקציה בודקת ומחזירה את 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_FIND
|
הפונקציה מחזירה את מחרוזת המשנה הראשונה שתואמת לביטוי רגולרי, או NULL אם אין התאמה.
|
REGEX_FIND_ALL
|
הפונקציה מחזירה מערך של כל מחרוזות המשנה שתואמות לביטוי רגולרי, או מערך ריק אם אין התאמות. |
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
תיאור:
הפונקציה מחזירה את מספר מיקומי התווים (code points) ב-Unicode בערך STRING.
לדוגמה:
| ערך | char_length(value) |
|---|---|
| "abc" | 3 |
| "שלום" | 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.
לדוגמה:
| ערך | דוגמת עיצוב | 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, regexp: STRING | REGEX) -> BOOLEAN
תיאור:
הפונקציה מחזירה את הערך TRUE אם חלק כלשהו של value תואם ל-regexp. אם regexp הוא לא ביטוי רגולרי תקין, הפונקציה מחזירה error.
הארגומנט regexp יכול להיות גם ערך REGEX שנוצר באמצעות regex("pattern", "options"). הפורמט הזה מאפשר לכם לספק אפשרויות של ביטויים רגולריים יחד עם התבנית. האפשרויות הנתמכות הן:
-
i: התאמה לא תלוית-רישיות. -
m: מצב של כמה שורות (^ו-$תואמים להתחלה או לסוף של שורות). -
s: מצב Dotall (.תואם לשורות חדשות).
אם regexp הוא STRING, לא מוחלות אפשרויות מלבד אלה שמוטמעות בתבנית עצמה (למשל, (?i)).
הביטויים הרגולריים תואמים לתחביר של ספריית re2.
לדוגמה:
| ערך | ביטוי רגיל | regex_contains(value, regexp) |
|---|---|---|
| "Firestore" | "אש" | true |
| "Firestore" | "store$" | true |
| "Firestore" | "data" | false |
| "Firestore" | regex("fire", "i") |
true |
| "Firestore" | regex("FIRE", "") |
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_FIND
תחביר:
regex_find(value: STRING, regexp: STRING | REGEX) -> STRING
תיאור:
הפונקציה מחזירה את מחרוזת המשנה הראשונה ב-value שתואמת ל-regexp, או את NULL אם אין התאמה. אם regexp הוא לא ביטוי רגולרי תקין, הפונקציה הזו מחזירה error.
הארגומנט regexp יכול להיות גם ערך REGEX שנוצר באמצעות regex("pattern", "options"). הפורמט הזה מאפשר לכם לספק אפשרויות של ביטויים רגולריים יחד עם התבנית. האפשרויות הנתמכות הן:
-
i: התאמה לא תלוית-רישיות. -
m: מצב של כמה שורות (^ו-$תואמים להתחלה או לסוף של שורות). -
s: מצב Dotall (.תואם לשורות חדשות).
אם regexp הוא STRING, לא מוחלות אפשרויות מלבד אלה שמוטמעות בתבנית עצמה (למשל, (?i)).
הביטויים הרגולריים תואמים לתחביר של ספריית re2.
לדוגמה:
| ערך | ביטוי רגיל | regex_find(value, regexp) |
|---|---|---|
| "Sometext MATCH" | "SomeText" | "Sometext" |
| "Sometext MATCH" | regex("match", "i") |
"MATCH" |
| "Sometext MATCH" | regex("(match)", "i") |
"MATCH" |
| "Sometext match" | regex("MATCH", "") |
null |
REGEX_FIND_ALL
תחביר:
regex_find_all(value: STRING, regexp: STRING | REGEX) -> ARRAY<STRING>
תיאור:
הפונקציה מחזירה מערך של כל מחרוזות המשנה ב-value שתואמות ל-regexp, או מערך ריק אם אין התאמות. אם regexp הוא לא ביטוי רגולרי תקין, הפונקציה מחזירה error.
הארגומנט regexp יכול להיות גם ערך REGEX שנוצר באמצעות regex("pattern", "options"). הפורמט הזה מאפשר לכם לספק אפשרויות של ביטויים רגולריים יחד עם התבנית. האפשרויות הנתמכות הן:
-
i: התאמה לא תלוית-רישיות. -
m: מצב של כמה שורות (^ו-$תואמים להתחלה או לסוף של שורות). -
s: מצב Dotall (.תואם לשורות חדשות).
אם regexp הוא STRING, לא מוחלות אפשרויות מלבד אלה שמוטמעות בתבנית עצמה (למשל, (?i)).
הביטויים הרגולריים תואמים לתחביר של ספריית re2.
לדוגמה:
| ערך | ביטוי רגיל | regex_find_all(value, regexp) |
|---|---|---|
| "אחת שתיים שלוש שתיים" | "one" | ["one"] |
| "one TWO three Two" | regex("two", "i") |
["TWO", "Two"] |
| "אחת שתיים שלוש שתיים" | regex("TWO", "") |
[] |
REGEX_MATCH
תחביר:
regex_match(value: STRING, regexp: STRING | REGEX) -> BOOLEAN
תיאור:
הפונקציה מחזירה את הערך TRUE אם value תואם באופן מלא ל-regexp. אם regexp הוא לא ביטוי רגולרי תקין, הפונקציה מחזירה error.
הארגומנט regexp יכול להיות גם ערך REGEX שנוצר באמצעות regex("pattern", "options"). הפורמט הזה מאפשר לכם לספק אפשרויות של ביטויים רגולריים יחד עם התבנית. האפשרויות הנתמכות הן:
-
i: התאמה לא תלוית-רישיות. -
m: מצב של כמה שורות (^ו-$תואמים להתחלה או לסוף של שורות). -
s: מצב Dotall (.תואם לשורות חדשות).
אם regexp הוא STRING, לא מוחלות אפשרויות מלבד אלה שמוטמעות בתבנית עצמה (למשל, (?i)).
הביטויים הרגולריים תואמים לתחביר של ספריית re2.
לדוגמה:
| ערך | ביטוי רגיל | regex_match(value, regexp) |
|---|---|---|
| "Firestore" | "F.*store" | true |
| "Firestore" | "אש" | false |
| "Firestore" | "^F.*e$" | true |
| "FiReStOrE" | regex("firestore", "i") |
true |
| "Firestore" | regex("firestore", "") |
false |
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, התוצאה נמדדת במיקומי תווים (code points) של Unicode. אם זה ערך שלBYTES, הוא נמדד בבייטים. - אם
searchהוא ערךSTRINGאוBYTESריק, התוצאה היא0.
לדוגמה:
| ערך | חיפוש | string_index_of(value, search) |
|---|---|---|
| "hello world" | "o" | 4 |
| "hello world" | "l" | 2 |
| "hello world" | "z" | -1 |
| "בננה" | "ana" | 1 |
| "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נמדדים במיקומי תווים (code points) של 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
תיאור:
הפונקציה מחזירה את הקלט שסופק בסדר הפוך.
התווים מוגדרים על ידי מיקומי תווים (code points) ב-Unicode כשהקלט הוא ערך STRING, ועל ידי בייטים כשהקלט הוא ערך BYTES.
לדוגמה:
| קלט | string_reverse(input) |
|---|---|
| "abc" | "cba" |
| "a🌹b" | "b🌹a" |
| "שלום" | "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(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 | BSON_TIMESTAMP, granularity: STRING[, timezone: STRING]) -> TIMESTAMP
תיאור:
הפונקציה מקצרת חותמת זמן לרמת פירוט נתונה.
הארגומנט granularity חייב להיות מחרוזת ואחד מהערכים הבאים:
microsecondmillisecondsecondminutehourdayweekweek([weekday])monthquarteryearisoyear
אם הארגומנט 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 | "שנייה" | לא צוין | 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 |
| 23 במרץ 2001, 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 | BSON_TIMESTAMP, unit: STRING, amount: INT64) -> TIMESTAMP
תיאור:
הוספת amount של unit מ-timestamp. הארגומנט amount יכול להיות שלילי, ובמקרה כזה הוא שווה ערך ל-TIMESTAMP_SUB.
הארגומנט unit חייב להיות מחרוזת ואחד מהערכים הבאים:
microsecondmillisecondsecondminutehourday
אם חותמת הזמן שמתקבלת לא נמצאת בטווח של 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 | "שעה" | -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 | BSON_TIMESTAMP, unit: STRING, amount: INT64) -> TIMESTAMP
תיאור:
הפונקציה מחסירה amount של unit מ-timestamp. הארגומנט amount יכול להיות שלילי, ובמקרה כזה הוא שווה ערך ל-TIMESTAMP_ADD.
הארגומנט unit חייב להיות מחרוזת ואחד מהערכים הבאים:
microsecondmillisecondsecondminutehourday
אם חותמת הזמן שמתקבלת לא נמצאת בטווח של 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 | "שעה" | -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 | BSON_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 | BSON_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 | BSON_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 | BSON_TIMESTAMP, start: TIMESTAMP | BSON_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 חייב להיות מחרוזת ואחד מהערכים הבאים:
microsecondmillisecondsecondminutehourday
לדוגמה:
end |
start |
unit |
timestamp_diff(end, start, unit) |
|---|---|---|---|
| 2026-07-04 00:01:00 UTC | 2026-07-04 00:00:00 UTC | "שנייה" | 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 | BSON_TIMESTAMP, part: STRING[, timezone: STRING]) -> INT64
תיאור:
מחלצת part ספציפי (למשל: שנה, חודש, יום) מתוך timestamp.
הארגומנט part חייב להיות מחרוזת ואחד מהערכים הבאים:
microsecondmillisecondsecondminutehourday-
dayofweek: מחזירה ערך בין 1 (יום ראשון) ל-7 (יום שבת). dayofyear-
week: מחזירה את מספר השבוע בשנה, החל מ-1 ליום ראשון הראשון בשנה. -
week([weekday]): הפונקציה מחזירה את מספר השבוע בשנה, החל מהיוםweekdayשצוין. monthquarteryear-
isoweek: מחזירה את מספר השבוע לפי תקן ISO 8601. -
isoyear: מחזירה את השנה לפי מספור השבועות של ISO 8601.
אם הארגומנט timezone צוין, החילוץ יתבסס על היומן של אזור הזמן שצוין. החילוץ יתחשב בשעון קיץ.
אם לא צוין timezone, החילוץ יתבסס על UTC.
הארגומנט timezone צריך להיות ייצוג מחרוזת של אזור זמן ממסד הנתונים של אזורי הזמן, לדוגמה America/New_York. אפשר גם להשתמש בהזמן שחלף בהתאמה אישית על ידי ציון היסט מ-GMT.
לדוגמה:
timestamp |
part |
timezone |
timestamp_extract(timestamp, part, timezone) |
|---|---|---|---|
| 2025-02-20 10:20:30 UTC | "year" | לא צוין | 2025 |
| 2025-02-20 10:20:30 UTC | "day" | לא צוין | 20 |
| 2025-12-31 23:59:59 לפי שעון UTC | "year" | "Asia/Tokyo" | 2026 |
פונקציות של סוגים
| שם | תיאור |
TYPE
|
הפונקציה מחזירה את סוג הערך בתור STRING.
|
IS_TYPE
|
הפונקציה מחזירה את הערך true אם הערך תואם לסוג שצוין.
|
סוג
תחביר:
type(input: ANY) -> STRING
תיאור:
מחזירה ייצוג מחרוזת של הסוג input.
אם הערך חסר, הפונקציה מחזירה NULL.
לדוגמה:
input |
type(input) |
|---|---|
| NULL | "null" |
| true | "boolean" |
| 1 | "int32" |
| -3L | "int64" |
| 3.14 | "float64" |
| 2024-01-01T00:00:00Z UTC | "timestamp" |
| "foo" | "string" |
| b"foo" | "bytes" |
| [1, 2] | "array" |
| {"a": 1} | "map" |
path("c/d") |
"reference" |
vector([1.0, 2.0]) |
"vector" |
object_id "a7f2c9d18b3e4509f67c12d8" |
"object_id" |
1.2e9m |
"decimal128" |
regex "/pattern/i" |
"regex" |
bson_timestamp(1732754912, 500) |
"bson_timestamp" |
| לא נוכח/ת | 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 |
| לא נוכח/ת | "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)