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

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

שם תיאור
BYTE_LENGTH הפונקציה מחזירה את מספר התווים BYTES בערך STRING או BYTES
CHAR_LENGTH הפונקציה מחזירה את מספר התווים ב-Unicode בערך STRING.
STARTS_WITH הפונקציה מחזירה את הערך TRUE אם STRING מתחיל בתחילית נתונה
ENDS_WITH הפונקציה מחזירה את הערך TRUE אם STRING מסתיים בסיומת שצוינה
LIKE הפונקציה מחזירה את הערך TRUE אם מחרוזת STRING תואמת לדפוס
REGEX_CONTAINS הפונקציה מחזירה TRUE אם ערך מסוים תואם באופן חלקי או מלא לביטוי רגולרי
REGEX_MATCH הפונקציה מחזירה את הערך TRUE אם חלק כלשהו של ערך תואם לביטוי רגולרי
STRING_CONCAT הפונקציה משרשרת כמה STRING ל-STRING
STRING_CONTAINS הפונקציה מחזירה TRUE אם ערך מכיל STRING
TO_UPPER הפונקציה ממירה ערך STRING או BYTES לאותיות רישיות.
TO_LOWER הפונקציה ממירה ערך STRING או BYTES לאותיות קטנות.
SUBSTRING הפונקציה מחזירה מחרוזת משנה של ערך STRING או BYTES.
STRING_REVERSE היפוך של ערך STRING או BYTES.
TRIM הפונקציה מסירה תווים מובילים וסוגרים מערך 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

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

CHAR_LENGTH

תחביר:

char_length(value: STRING) -> INT64

תיאור:

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

לדוגמה:

ערך char_length(value)
‪"abc" 3
"hello" 5
‫"world" 5

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

STARTS_WITH

תחביר:

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

תיאור:

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

לדוגמה:

ערך תחילית starts_with(value, prefix)
‪"abc" ‪"a" true
‪"abc" "b" false
‪"abc" "" true

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

ENDS_WITH

תחביר:

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

תיאור:

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

לדוגמה:

ערך סיומת ends_with(value, postfix)
‪"abc" "c" true
‪"abc" "b" false
‪"abc" "" true
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()
)

אהבתי

תחביר:

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

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

REGEX_CONTAINS

תחביר:

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

תיאור:

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

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

לדוגמה:

ערך קו פתיחת נעילה regex_contains(value, pattern)
‫"Firestore" ‫"Fire" true
‫"Firestore" ‪"store$" true
‫"Firestore" ‫"data" false

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

REGEX_MATCH

תחביר:

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

תיאור:

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

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

לדוגמה:

ערך קו פתיחת נעילה regex_match(value, pattern)
‫"Firestore" "F.*store" true
‫"Firestore" ‫"Fire" false
‫"Firestore" "^F.*e$" true

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

STRING_CONCAT

תחביר:

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

תיאור:

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

לדוגמה:

ארגומנטים string_concat(values...)
() error
("a") ‪"a"
("abc", "def") ‪"abcdef"
("a", "", "c") "ac"

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

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

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

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"

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

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"

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

SUBSTRING

תחביר:

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

תיאור:

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

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

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

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

לדוגמה:

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

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

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

קלט position אורך substring(input, position, length)
‪"abc" 0 1 ‪"a"
‪"abc" 1 2 "bc"
‪"abc" -1 1 "c"
b"abc" 0 1 b"a"

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

STRING_REVERSE

תחביר:

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

תיאור:

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

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

לדוגמה:

קלט string_reverse(input)
‪"abc" "cba"
"a🌹b" ‪"b🌹a"
"hello" ‪"olleh"
b"abc" b"cba"

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

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

SPLIT

תחביר:

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

תיאור:

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

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

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

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

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

לדוגמה:

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

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

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

קלט תו מפריד split(input, delimiter)
‪"foo bar foo" " " ‪["foo", "bar", "foo"]
‪"foo bar foo" ‪"z" ‪["foo bar foo"]
‪"abc" "" ‪["a", "b", "c"]
b"C1,C2,C4" b"," [b"C1", b"C2", b"C4"]
b"ABC" b"" [b"A", b"B", b"C"]
‪"foo" b"C1" error