Cloud Firestore Enterprise edition in Native mode is now available! Learn more.

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

גרסת טרום-GA: השימוש ב-Firestore במצב Native (עם פעולות Pipeline) במהדורת Enterprise כפוף לתנאי השימוש במוצרים בגרסת טרום-GA, שמפורטים בחלק "תנאים כלליים לשירות" בתנאים הספציפיים לשירות. אתם יכולים להשתמש בתכונה הזו כדי לעבד מידע אישי כמו שמפורט בנספח לעיבוד נתונים ב-Cloud, בכפוף למחויבויות ולהגבלות שמפורטות בהסכם שמעניק לכם גישה ל-Google Cloud. השימוש בתכונות בגרסת טרום-GA הוא "כפי שהן" (As is), ויכול להיות שהתמיכה בהן תהיה מוגבלת. מידע נוסף זמין בקטע תיאורים של שלבי ההשקה.

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

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

וגם

תחביר:

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

תיאור:

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

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

לדוגמה:

`x`	`y`	`and(x, y)`
`TRUE`	`TRUE`	`TRUE`
`FALSE`	`TRUE`	`FALSE`
`NULL`	`TRUE`	`NULL`
`ABSENT`	`TRUE`	`NULL`
`NULL`	`FALSE`	`FALSE`
`FALSE`	`ABSENT`	`FALSE`

Node.js

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

Web

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

Swift

let result = try await db.pipeline()
  .collection("books")
  .select([
    (Field("rating").greaterThan(4) && Field("price").lessThan(10))
      .as("under10Recommendation")
  ])
  .execute()PipelineSnippets.swift

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        Expression.and(
            field("rating").greaterThan(4),
            field("price").lessThan(10)
        ).alias("under10Recommendation")
    )
    .execute();DocSnippets.java

Python

from google.cloud.firestore_v1.pipeline_expressions import Field, And

result = (
    client.pipeline()
    .collection("books")
    .select(
        And(
            Field.of("rating").greater_than(4), Field.of("price").less_than(10)
        ).as_("under10Recommendation")
    )
    .execute()
)firestore_pipelines.py

Java

Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            and(greaterThan(field("rating"), 4), lessThan(field("price"), 10))
                .as("under10Recommendation"))
        .execute()
        .get();PipelineSnippets.java

או

תחביר:

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

תיאור:

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

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

לדוגמה:

`x`	`y`	`or(x, y)`
`TRUE`	`TRUE`	`TRUE`
`FALSE`	`TRUE`	`TRUE`
`NULL`	`TRUE`	`TRUE`
`ABSENT`	`TRUE`	`TRUE`
`NULL`	`FALSE`	`NULL`
`FALSE`	`ABSENT`	`NULL`

Node.js

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

Web

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

Swift

let result = try await db.pipeline()
  .collection("books")
  .select([
    (Field("genre").equal("Fantasy") || Field("tags").arrayContains("adventure"))
      .as("matchesSearchFilters")
  ])
  .execute()PipelineSnippets.swift

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        Expression.or(
            field("genre").equal("Fantasy"),
            field("tags").arrayContains("adventure")
        ).alias("matchesSearchFilters")
    )
    .execute();DocSnippets.java

Python

from google.cloud.firestore_v1.pipeline_expressions import Field, And, Or

result = (
    client.pipeline()
    .collection("books")
    .select(
        Or(
            Field.of("genre").equal("Fantasy"),
            Field.of("tags").array_contains("adventure"),
        ).as_("matchesSearchFilters")
    )
    .execute()
)firestore_pipelines.py

Java

Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            or(equal(field("genre"), "Fantasy"), arrayContains(field("tags"), "adventure"))
                .as("matchesSearchFilters"))
        .execute()
        .get();PipelineSnippets.java

XOR

תחביר:

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

תיאור:

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

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

לדוגמה:

`x`	`y`	`xor(x, y)`
`TRUE`	`TRUE`	`FALSE`
`FALSE`	`FALSE`	`FALSE`
`FALSE`	`TRUE`	`TRUE`
`NULL`	`TRUE`	`NULL`
`ABSENT`	`TRUE`	`NULL`
`NULL`	`FALSE`	`NULL`
`FALSE`	`ABSENT`	`NULL`

Node.js

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    xor(field("tags").arrayContains("magic"), field("tags").arrayContains("nonfiction"))
      .as("matchesSearchFilters")
  )
);test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    xor(field("tags").arrayContains("magic"), field("tags").arrayContains("nonfiction"))
      .as("matchesSearchFilters")
  )
);test.firestore.js

Swift

let result = try await db.pipeline()
  .collection("books")
  .select([
    (Field("tags").arrayContains("magic") ^ Field("tags").arrayContains("nonfiction"))
      .as("matchesSearchFilters")
  ])
  .execute()PipelineSnippets.swift

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        Expression.xor(
            field("tags").arrayContains("magic"),
            field("tags").arrayContains("nonfiction")
        ).alias("matchesSearchFilters")
    )
    .execute();DocSnippets.java

Python

from google.cloud.firestore_v1.pipeline_expressions import Field, Xor

result = (
    client.pipeline()
    .collection("books")
    .select(
        Xor(
            [
                Field.of("tags").array_contains("magic"),
                Field.of("tags").array_contains("nonfiction"),
            ]
        ).as_("matchesSearchFilters")
    )
    .execute()
)firestore_pipelines.py

Java

Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            xor(
                    arrayContains(field("tags"), "magic"),
                    arrayContains(field("tags"), "nonfiction"))
                .as("matchesSearchFilters"))
        .execute()
        .get();PipelineSnippets.java

NOR

תחביר:

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

תיאור:

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

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

לדוגמה:

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

NOT

תחביר:

not(x: BOOLEAN) -> BOOLEAN

תיאור:

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

Node.js

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

Web

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

Swift

let result = try await db.pipeline()
  .collection("books")
  .select([
    (!Field("tags").arrayContains("nonfiction"))
      .as("isFiction")
  ])
  .execute()PipelineSnippets.swift

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        Expression.not(
            field("tags").arrayContains("nonfiction")
        ).alias("isFiction")
    )
    .execute();DocSnippets.java

Python

from google.cloud.firestore_v1.pipeline_expressions import Field, Not

result = (
    client.pipeline()
    .collection("books")
    .select(Not(Field.of("tags").array_contains("nonfiction")).as_("isFiction"))
    .execute()
)firestore_pipelines.py

Java

Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(not(arrayContains(field("tags"), "nonfiction")).as("isFiction"))
        .execute()
        .get();PipelineSnippets.java

CONDITIONAL

תחביר:

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

תיאור:

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

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

לדוגמה:

`condition`	`true_case`	`false_case`	`conditional(condition, true_case, false_case)`
`TRUE`	‫1L	0L	‫1L
`FALSE`	‫1L	0L	0L
`NULL`	‫1L	0L	0L
`ABSENT`	‫1L	0L	0L

Node.js

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("tags").arrayConcat([
      field("pages").greaterThan(100)
        .conditional(constant("longRead"), constant("shortRead"))
    ]).as("extendedTags")
  )
);test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("tags").arrayConcat([
      field("pages").greaterThan(100)
        .conditional(constant("longRead"), constant("shortRead"))
    ]).as("extendedTags")
  )
);test.firestore.js

Swift

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

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("tags").arrayConcat(
            Expression.conditional(
                field("pages").greaterThan(100),
                constant("longRead"),
                constant("shortRead")
            )
        ).alias("extendedTags")
    )
    .execute();DocSnippets.java

Python

from google.cloud.firestore_v1.pipeline_expressions import (
    Field,
    Constant,
    Conditional,
)

result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("tags")
        .array_concat(
            Conditional(
                Field.of("pages").greater_than(100),
                Constant.of("longRead"),
                Constant.of("shortRead"),
            )
        )
        .as_("extendedTags")
    )
    .execute()
)firestore_pipelines.py

Java

Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            arrayConcat(
                    field("tags"),
                    conditional(
                        greaterThan(field("pages"), 100),
                        constant("longRead"),
                        constant("shortRead")))
                .as("extendedTags"))
        .execute()
        .get();PipelineSnippets.java

IF_NULL

תחביר:

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

תיאור:

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

לדוגמה:

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

SWITCH_ON

תחביר:

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

תיאור:

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

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

לדוגמה:

`x`	`switch_on(eq(x, 1L), "one", eq(x, 2L), "two", "other")`
‫1L	‫"one"
‫2L	‫"two"
‫3L	‫"other" (אחר)

EQUAL_ANY

תחביר:

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

תיאור:

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

לדוגמה:

`value`	`search_space`	`equal_any(value, search_space)`
0L	‫[1L, ‏ 2L, ‏ 3L]	`FALSE`
‫2L	‫[1L, ‏ 2L, ‏ 3L]	`TRUE`
`NULL`	‫[1L, ‏ 2L, ‏ 3L]	`FALSE`
`NULL`	[1L, `NULL`]	`TRUE`
`ABSENT`	[1L, `NULL`]	`FALSE`
NaN	‫[1L, NaN, 3L]	`TRUE`

Node.js

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

Web

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

Swift

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

Kotlin

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

Java

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

Python

from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("genre")
        .equal_any(["Science Fiction", "Psychological Thriller"])
        .as_("matchesGenreFilters")
    )
    .execute()
)firestore_pipelines.py

Java

Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            equalAny(field("genre"), Arrays.asList("Science Fiction", "Psychological Thriller"))
                .as("matchesGenreFilters"))
        .execute()
        .get();PipelineSnippets.java

NOT_EQUAL_ANY

תחביר:

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

תיאור:

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

לדוגמה:

`value`	`search_space`	`not_equal_any(value, search_space)`
0L	‫[1L, ‏ 2L, ‏ 3L]	`TRUE`
‫2L	‫[1L, ‏ 2L, ‏ 3L]	`FALSE`
`NULL`	‫[1L, ‏ 2L, ‏ 3L]	`TRUE`
`NULL`	[1L, `NULL`]	`FALSE`
`ABSENT`	[1L, `NULL`]	`TRUE`
NaN	‫[1L, NaN, 3L]	`FALSE`

Node.js

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

Web

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

Swift

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

Kotlin

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

Java

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

Python

from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("author")
        .not_equal_any(["George Orwell", "F. Scott Fitzgerald"])
        .as_("byExcludedAuthors")
    )
    .execute()
)firestore_pipelines.py

Java

Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            notEqualAny(field("author"), Arrays.asList("George Orwell", "F. Scott Fitzgerald"))
                .as("byExcludedAuthors"))
        .execute()
        .get();PipelineSnippets.java

מקסימום

תחביר:

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

תיאור:

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

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

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

לדוגמה:

`x`	`y`	`maximum(x, y)`
`FALSE`	`TRUE`	`TRUE`
`FALSE`	‫‎-10L	‫‎-10L
0.0	‎-5L	0.0
‪"foo"	"bar"	‪"foo"
‪"foo"	‪["foo"]	‪["foo"]
`ABSENT`	`ABSENT`	`NULL`
`NULL`	`NULL`	`NULL`

Node.js

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

Web

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

Swift

let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("rating").logicalMaximum([1]).as("flooredRating")
  ])
  .execute()PipelineSnippets.swift

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("rating").logicalMaximum(1).alias("flooredRating")
    )
    .execute();DocSnippets.java

Python

from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("rating").logical_maximum(1).as_("flooredRating"))
    .execute()
)firestore_pipelines.py

Java

Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(logicalMaximum(field("rating"), 1).as("flooredRating"))
        .execute()
        .get();PipelineSnippets.java

MINIMUM

תחביר:

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

תיאור:

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

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

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

לדוגמה:

`x`	`y`	`minimum(x, y)`
`FALSE`	`TRUE`	`FALSE`
`FALSE`	‫‎-10L	`FALSE`
0.0	‎-5L	‎-5L
‪"foo"	"bar"	"bar"
‪"foo"	‪["foo"]	‪"foo"
`ABSENT`	`ABSENT`	`NULL`
`NULL`	`NULL`	`NULL`

Node.js

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

Web

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

Swift

let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("rating").logicalMinimum([5]).as("cappedRating")
  ])
  .execute()PipelineSnippets.swift

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("rating").logicalMinimum(5).alias("cappedRating")
    )
    .execute();DocSnippets.java

Python

from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("rating").logical_minimum(5).as_("cappedRating"))
    .execute()
)firestore_pipelines.py

Java

Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(logicalMinimum(field("rating"), 5).as("cappedRating"))
        .execute()
        .get();PipelineSnippets.java

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