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

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

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