Funkcje ciągu znaków

Funkcje operujące na ciągach znaków

Nazwa Opis
BYTE_LENGTH Zwraca liczbę BYTES w wartości STRING lub BYTES
CHAR_LENGTH Zwraca liczbę znaków Unicode w wartości STRING
STARTS_WITH Zwraca TRUE, jeśli STRING zaczyna się od podanego prefiksu
ENDS_WITH Zwraca TRUE, jeśli STRING kończy się podanym sufiksem
LIKE Zwraca wartość TRUE, jeśli STRING pasuje do wzorca
REGEX_CONTAINS Zwraca TRUE, jeśli wartość częściowo lub całkowicie pasuje do wyrażenia regularnego
REGEX_FIND Zwraca pierwszy podłańcuch, który pasuje do wyrażenia regularnego, lub NULL, jeśli nie ma dopasowania.
REGEX_FIND_ALL Zwraca tablicę wszystkich podłańcuchów pasujących do wyrażenia regularnego lub pustą tablicę, jeśli nie ma dopasowań.
REGEX_MATCH Zwraca TRUE, jeśli dowolna część wartości pasuje do wyrażenia regularnego
STRING_CONCAT Łączy wiele obiektów STRING w obiekt STRING
STRING_CONTAINS Zwraca TRUE, jeśli wartość zawiera STRING
STRING_INDEX_OF Zwraca indeks (liczony od 0) pierwszego wystąpienia wartości STRING lub BYTES.
TO_UPPER Konwertuje wartość STRING lub BYTES na wielkie litery.
TO_LOWER Przekształca wartość STRING lub BYTES na małe litery.
SUBSTRING Pobiera podłańcuch wartości STRING lub BYTES.
STRING_REVERSE Odwraca wartość STRING lub BYTES.
STRING_REPEAT Powtarza wartość STRING lub BYTES określoną liczbę razy.
STRING_REPLACE_ALL Zastępuje wszystkie wystąpienia wartości STRING lub BYTES.
STRING_REPLACE_ONE Zastępuje pierwsze wystąpienie wartości STRING lub BYTES.
TRIM Usuwa początkowe i końcowe znaki z wartości STRING lub BYTES.
LTRIM Usuwa początkowe znaki z wartości STRING lub BYTES.
RTRIM Usuwa końcowe znaki z wartości STRING lub BYTES.
SPLIT Dzieli wartość STRING lub BYTES na tablicę.

BYTE_LENGTH

Składnia:

byte_length[T <: STRING | BYTES](value: T) -> INT64

Opis:

Zwraca liczbę BYTES w wartości STRING lub BYTES.

Przykłady:

wartość 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();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.ByteLength(firestore.FieldOf("title")).As("titleByteLength"),
	)).
	Execute(ctx)

CHAR_LENGTH

Składnia:

char_length(value: STRING) -> INT64

Opis:

Zwraca liczbę punktów kodowych Unicode w wartości STRING.

Przykłady:

wartość char_length(value)
"abc" 3
„Witaj” 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();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.CharLength(firestore.FieldOf("title")).As("titleCharLength"),
	)).
	Execute(ctx)

STARTS_WITH

Składnia:

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

Opis:

Zwraca wartość TRUE, jeśli value zaczyna się od prefix.

Przykłady:

wartość prefiks starts_with(value, prefix)
"abc" "a" prawda
"abc" "b" fałsz
"abc" "" prawda
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();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.StartsWith(firestore.FieldOf("title"), "The").As("needsSpecialAlphabeticalSort"),
	)).
	Execute(ctx)

ENDS_WITH

Składnia:

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

Opis:

Zwraca TRUE, jeśli value kończy się na postfix.

Przykłady:

wartość przyrostek ends_with(value, postfix)
"abc" "c" prawda
"abc" "b" fałsz
"abc" "" prawda
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();
Go
snapshot := client.Pipeline().
	Collection("inventory/devices/laptops").
	Select(firestore.Fields(
		firestore.EndsWith(firestore.FieldOf("name"), "16 inch").As("`Laptops16in`"),
	)).
	Execute(ctx)

PODOBA MI SIĘ

Składnia:

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

Opis:

Zwraca TRUE, jeśli value pasuje do pattern.

Przykłady:

wartość wzór like(value, pattern)
"Firestore" "Fire%" prawda
"Firestore" „%store” prawda
„Datastore” "Data_tore" prawda
"100%" "100\%" prawda
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();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.Like(firestore.FieldOf("genre"), "%Fiction").As("anyFiction"),
	)).
	Execute(ctx)

REGEX_CONTAINS

Składnia:

regex_contains(value: STRING, regexp: STRING | REGEX) -> BOOLEAN

Opis:

Zwraca wartość TRUE, jeśli jakaś część ciągu value pasuje do ciągu regexp. Jeśli regexp nie jest prawidłowym wyrażeniem regularnym, funkcja zwraca błąd error.

Argument regexp może też być wartością REGEX utworzoną za pomocą regex("pattern", "options"). Ten format umożliwia podanie opcji wyrażenia regularnego wraz ze wzorcem. Obsługiwane opcje:

  • i: dopasowanie, w którym wielkość liter nie jest rozróżniana.
  • m: tryb wielowierszowy (^ i $ dopasowują początek lub koniec wierszy).
  • s: tryb Dotall (. dopasowuje znaki nowego wiersza).

Jeśli regexp to STRING, nie są stosowane żadne opcje oprócz tych, które są osadzone we wzorcu (np. (?i)).

Wyrażenia regularne są zgodne ze składnią biblioteki re2.

Przykłady:

wartość regexp regex_contains(value, regexp)
"Firestore" „Ogień” prawda
"Firestore" "store$" prawda
"Firestore" "data" fałsz
"Firestore" regex("fire", "i") prawda
"Firestore" regex("FIRE", "") fałsz
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();
Go
snapshot := client.Pipeline().
	Collection("documents").
	Select(firestore.Fields(
		firestore.RegexContains(firestore.FieldOf("title"), "Firestore (Enterprise|Standard)").As("isFirestoreRelated"),
	)).
	Execute(ctx)

REGEX_FIND

Składnia:

regex_find(value: STRING, regexp: STRING | REGEX) -> STRING

Opis:

Zwraca pierwszy podłańcuch w value, który pasuje do regexp, lub NULL, jeśli nie ma dopasowania. Jeśli regexp nie jest prawidłowym wyrażeniem regularnym, ta funkcja zwraca błąd error.

Argument regexp może też być wartością REGEX utworzoną za pomocą regex("pattern", "options"). Ten format umożliwia podanie opcji wyrażenia regularnego wraz ze wzorcem. Obsługiwane opcje:

  • i: dopasowanie, w którym wielkość liter nie jest rozróżniana.
  • m: tryb wielowierszowy (^ i $ dopasowują początek lub koniec wierszy).
  • s: tryb Dotall (. dopasowuje znaki nowego wiersza).

Jeśli regexp to STRING, nie są stosowane żadne opcje oprócz tych, które są osadzone we wzorcu (np. (?i)).

Wyrażenia regularne są zgodne ze składnią biblioteki re2.

Przykłady:

wartość regexp 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

Składnia:

regex_find_all(value: STRING, regexp: STRING | REGEX) -> ARRAY<STRING>

Opis:

Zwraca tablicę wszystkich podłańcuchów w value, które pasują do regexp, lub pustą tablicę, jeśli nie ma dopasowań. Jeśli regexp nie jest prawidłowym wyrażeniem regularnym, ta funkcja zwraca błąd error.

Argument regexp może też być wartością REGEX utworzoną za pomocą regex("pattern", "options"). Ten format umożliwia podanie opcji wyrażenia regularnego wraz ze wzorcem. Obsługiwane opcje:

  • i: dopasowanie, w którym wielkość liter nie jest rozróżniana.
  • m: tryb wielowierszowy (^ i $ dopasowują początek lub koniec wierszy).
  • s: tryb Dotall (. dopasowuje znaki nowego wiersza).

Jeśli regexp to STRING, nie są stosowane żadne opcje oprócz tych, które są osadzone we wzorcu (np. (?i)).

Wyrażenia regularne są zgodne ze składnią biblioteki re2.

Przykłady:

wartość regexp regex_find_all(value, regexp)
„jeden dwa trzy dwa” "one" ["one"]
„one TWO three Two” regex("two", "i") ["TWO", "Two"]
„jeden dwa trzy dwa” regex("TWO", "") []

REGEX_MATCH

Składnia:

regex_match(value: STRING, regexp: STRING | REGEX) -> BOOLEAN

Opis:

Zwraca TRUE, jeśli value w pełni pasuje do regexp. Jeśli regexp nie jest prawidłowym wyrażeniem regularnym, funkcja zwraca błąd error.

Argument regexp może też być wartością REGEX utworzoną za pomocą regex("pattern", "options"). Ten format umożliwia podanie opcji wyrażenia regularnego wraz ze wzorcem. Obsługiwane opcje:

  • i: dopasowanie, w którym wielkość liter nie jest rozróżniana.
  • m: tryb wielowierszowy (^ i $ dopasowują początek lub koniec wierszy).
  • s: tryb Dotall (. dopasowuje znaki nowego wiersza).

Jeśli regexp to STRING, nie są stosowane żadne opcje oprócz tych, które są osadzone we wzorcu (np. (?i)).

Wyrażenia regularne są zgodne ze składnią biblioteki re2.

Przykłady:

wartość regexp regex_match(value, regexp)
"Firestore" "F.*store" prawda
"Firestore" „Ogień” fałsz
"Firestore" "^F.*e$" prawda
"FiReStOrE" regex("firestore", "i") prawda
"Firestore" regex("firestore", "") fałsz
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();
Go
snapshot := client.Pipeline().
	Collection("documents").
	Select(firestore.Fields(
		firestore.RegexMatch(firestore.FieldOf("title"), "Firestore (Enterprise|Standard)").As("isFirestoreExactly"),
	)).
	Execute(ctx)

STRING_CONCAT

Składnia:

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

Opis:

Łączy co najmniej 2 wartości STRING w jeden wynik.

Przykłady:

argumenty string_concat(values...)
() błąd
("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();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.StringConcat(firestore.FieldOf("title"), " by ", firestore.FieldOf("author")).As("fullyQualifiedTitle"),
	)).
	Execute(ctx)

STRING_CONTAINS

Składnia:

string_contains(value: STRING, substring: STRING) -> BOOLEAN

Opis:

Sprawdza, czy value zawiera ciąg znaków substring.

Przykłady:

wartość podłańcuch string_contains(value, substring)
"abc" "b" prawda
"abc" "d" fałsz
"abc" "" prawda
"a.c" „.” prawda
"☃☃☃" "☃" prawda
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();
Go
snapshot := client.Pipeline().
	Collection("articles").
	Select(firestore.Fields(
		firestore.StringContains(firestore.FieldOf("body"), "Firestore").As("isFirestoreRelated"),
	)).
	Execute(ctx)

STRING_INDEX_OF

Składnia:

string_index_of[T <: STRING | BYTES](value: T, search: T) -> INT64

Opis:

Zwraca indeks (liczony od 0) pierwszego wystąpienia ciągu search w ciągu value.

  • Zwraca -1, jeśli nie znaleziono search.
  • Jeśli value jest wartością STRING, wynik jest mierzony w punktach kodowych Unicode. Jeśli jest to wartość BYTES, jest mierzona w bajtach.
  • Jeśli search jest pustą wartością STRING lub BYTES, wynik to 0.

Przykłady:

wartość szukaj string_index_of(value, search)
„hello world” "o" 4
„hello world” "l" 2
„hello world” "z" -1
"banana" "ana" 1
"abc" "" 0
b"abc" b"b" 1
"é" "é" 0
b"é" b"é" 0

TO_UPPER

Składnia:

to_upper[T <: STRING | BYTES](value: T) -> T

Opis:

Konwertuje wartość STRING lub BYTES na wielkie litery.

Jeśli bajt lub znak nie odpowiada małej literze UTF-8, jest przekazywany bez zmian.

Przykłady:

wartość 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();
Go
snapshot := client.Pipeline().
	Collection("authors").
	Select(firestore.Fields(
		firestore.ToUpper(firestore.FieldOf("name")).As("uppercaseName"),
	)).
	Execute(ctx)

TO_LOWER

Składnia:

to_lower[T <: STRING | BYTES](value: T) -> T

Opis:

Przekształca wartość STRING lub BYTES na małe litery.

Jeśli bajt lub znak nie odpowiada wielkiej literze UTF-8, jest przekazywany bez zmian.

Przykłady:

wartość 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();
Go
snapshot := client.Pipeline().
	Collection("authors").
	Select(firestore.Fields(
		firestore.Equal(firestore.ToLower(firestore.FieldOf("genre")), "fantasy").As("isFantasy"),
	)).
	Execute(ctx)

SUBSTRING

Składnia:

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

Opis:

Zwraca podłańcuch ciągu znaków input zaczynający się od position (indeks zaczyna się od 0) i zawierający maksymalnie length wpisów. Jeśli nie podano parametru length, zwraca podłańcuch od position do końca input.

  • Jeśli input jest wartością STRING, position i length są mierzone w punktach kodowych Unicode. Jeśli jest to wartość BYTES, jest mierzona w bajtach.

  • Jeśli position jest większy niż długość input, zwracany jest pusty podłańcuch. Jeśli suma position i length jest większa niż długość input, podłańcuch jest skracany do końca input.

  • Jeśli argument position jest ujemny, pozycja jest liczona od końca danych wejściowych. Jeśli ujemna wartość position jest większa niż rozmiar danych wejściowych, pozycja jest ustawiana na 0. Wartość length nie może być ujemna.

Przykłady:

Jeśli nie podano parametru length:

wprowadzanie danych position substring(input, position)
"abc" 0 "abc"
"abc" 1 "bc"
"abc" 3 ""
"abc" -1 "c"
b"abc" 1 b"bc"

Gdy podano parametr length:

wprowadzanie danych position długość 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();
Go
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

Składnia:

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

Opis:

Zwraca podane dane wejściowe w odwrotnej kolejności.

Znaki są rozdzielane punktami kodowymi Unicode, gdy dane wejściowe są wartością STRING, i bajtami, gdy dane wejściowe są wartością BYTES.

Przykłady:

wprowadzanie danych string_reverse(input)
"abc" "cba"
"a🌹b" "b🌹a"
„Witaj” "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();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.Reverse(firestore.FieldOf("name")).As("reversedName"),
	)).
	Execute(ctx)

STRING_REPEAT

Składnia:

string_repeat[T <: STRING | BYTES](input: T, repetitions: INT64) -> T

Opis:

Zwraca input powtórzony repetitions razy.

  • repetitions musi być nieujemną liczbą całkowitą.
  • Jeśli repetitions to 0, zwraca pustą wartość tego samego typu co input.
  • Jeśli wynik przekracza maksymalny dozwolony rozmiar (1 MB), zwracany jest błąd.

Przykłady:

wprowadzanie danych powtórzenia string_repeat(input, repetitions)
"foo" 3 "foofoofoo"
"foo" 0 ""
"a " 3 "a a a "
b"ab" 2 b"abab"
"é🦆" 2 „é🦆é🦆”

STRING_REPLACE_ALL

Składnia:

string_replace_all[T <: STRING | BYTES](input: T, find: T, replacement: T) -> T

Opis:

Zastępuje wszystkie nienakładające się wystąpienia find w input ciągiem replacement.

  • Wielkość liter ma znaczenie.
  • Jeśli parametr find jest pusty, nie są wprowadzane żadne zastąpienia.

Przykłady:

wprowadzanie danych znajdź wymiana, 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

Składnia:

string_replace_one[T <: STRING | BYTES](input: T, find: T, replacement: T) -> T

Opis:

Zastępuje pierwsze wystąpienie ciągu find w ciągu input ciągiem replacement.

  • Wielkość liter ma znaczenie.
  • Jeśli parametr find jest pusty, nie są wprowadzane żadne zastąpienia.

Przykłady:

wprowadzanie danych znajdź wymiana, string_replace_one(input, find, replacement)
"foobarfoo" "foo" "baz" "bazbarfoo"
"é" "é" "a" "a"
b"foobar" b"o" b"z" b"fzoobar"

TRIM

Składnia:

trim[T <: STRING | BYTES](input: T, values_to_trim: T) -> T
trim[T <: STRING | BYTES](input: T) -> T

Opis:

Usuwa określony zestaw znaków BYTES lub CHARS z początku i końca podanego ciągu input.

  • Jeśli nie podano argumentu values_to_trim, usuwa znaki odstępu.

Przykłady:

Jeśli nie podano parametru values_to_trim:

wprowadzanie danych 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"

Gdy podano parametr values_to_trim:

wprowadzanie danych wartości_do_przycięcia trim(input, values_to_trim)
"abcbfooaacb" "abc" "foo"
"abcdaabadbac" "abc" "daabad"
b"C1C2C3" b"C1" b"C2C3"
b"C1C2" "foo" błąd
"foo" b"C1" błąd

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();
Go
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.Trim(firestore.FieldOf("name")).As("whitespaceTrimmedName"),
	)).
	Execute(ctx)

LTRIM

Składnia:

ltrim[T <: STRING | BYTES](value: T, to_trim: T) -> T
ltrim[T <: STRING | BYTES](value: T) -> T

Opis:

Usuwa określony zestaw znaków BYTES lub CHARS z początku podanego ciągu value.

  • Jeśli nie podano argumentu to_trim, usuwa początkowe znaki odstępu.

Przykłady:

Jeśli nie podano parametru to_trim:

wartość ltrim(value)
" foo " "foo "
"foo" "foo"

Gdy podano parametr to_trim:

wartość to_trim ltrim(value, to_trim)
"aaabc" "a" "bc"
"abacaba" "ba" "caba"
"é" "é" ""

RTRIM

Składnia:

rtrim[T <: STRING | BYTES](value: T, to_trim: T) -> T
rtrim[T <: STRING | BYTES](value: T) -> T

Opis:

Usuwa określony zestaw znaków BYTES lub CHARS z końca podanego ciągu value.

  • Jeśli nie podano argumentu to_trim, usuwa końcowe znaki odstępu.

Przykłady:

Jeśli nie podano parametru to_trim:

wartość rtrim(value)
" foo " " foo"
"foo" "foo"

Gdy podano parametr to_trim:

wartość to_trim rtrim(value, to_trim)
"abccc" "c" "ab"
"abacaba" "ba" "abac"
"é" "é" ""

WYDZIEL

Składnia:

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

Opis:

Dzieli wartość STRING lub BYTES za pomocą separatora.

  • W przypadku STRING domyślnym ogranicznikiem jest przecinek ,. Separator jest traktowany jako pojedynczy ciąg znaków.

  • W przypadku BYTES musisz określić separator.

  • Podział na pusty separator daje tablicę punktów kodowych Unicode dla wartości STRING i tablicę BYTES dla wartości BYTES.

  • Podział pustego elementu STRING zwraca element ARRAY z jednym pustym elementem STRING.

Przykłady:

Jeśli nie podano parametru delimiter:

wprowadzanie danych split(input)
"foo,bar,foo" ["foo", "bar", "foo"]
"foo" ["foo"]
",foo," ["", "foo", ""]
"" [""]
b"C120C2C4" błąd

Gdy podano parametr delimiter:

wprowadzanie danych separator 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" błąd