Funzioni di stringa

Funzioni stringa

Nome Descrizione
BYTE_LENGTH Restituisce il numero di BYTES in un valore STRING o BYTES
CHAR_LENGTH Restituisce il numero di caratteri Unicode in un valore STRING
STARTS_WITH Restituisce TRUE se STRING inizia con un prefisso specificato
ENDS_WITH Restituisce TRUE se un STRING termina con un suffisso specificato
LIKE Restituisce TRUE se un STRING corrisponde a un pattern
REGEX_CONTAINS Restituisce TRUE se un valore corrisponde parzialmente o completamente a un'espressione regolare
REGEX_FIND Restituisce la prima sottostringa che corrisponde a un'espressione regolare o NULL se non esiste alcuna corrispondenza.
REGEX_FIND_ALL Restituisce un array di tutte le sottostringhe che corrispondono a un'espressione regolare o un array vuoto se non ci sono corrispondenze.
REGEX_MATCH Restituisce TRUE se una parte di un valore corrisponde a un'espressione regolare
STRING_CONCAT Concatena più STRING in un STRING
STRING_CONTAINS Restituisce TRUE se un valore contiene un STRING
STRING_INDEX_OF Restituisce l'indice in base 0 della prima occorrenza di un valore STRING o BYTES.
TO_UPPER Converte un valore STRING o BYTES in lettere maiuscole.
TO_LOWER Converte un valore STRING o BYTES in minuscolo.
SUBSTRING Recupera una sottostringa di un valore STRING o BYTES.
STRING_REVERSE Inverte un valore STRING o BYTES.
STRING_REPEAT Ripete un valore STRING o BYTES un numero specificato di volte.
STRING_REPLACE_ALL Sostituisce tutte le occorrenze di un valore STRING o BYTES.
STRING_REPLACE_ONE Sostituisce la prima occorrenza di un valore STRING o BYTES.
TRIM Rimuove i caratteri iniziali e finali da un valore STRING o BYTES.
LTRIM Taglia i caratteri iniziali da un valore STRING o BYTES.
RTRIM Rimuove i caratteri finali da un valore STRING o BYTES.
SPLIT Suddivide un valore STRING o BYTES in un array.

BYTE_LENGTH

Sintassi:

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

Descrizione:

Restituisce il numero di BYTES in un valore STRING o BYTES.

Esempi:

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

CHAR_LENGTH

Sintassi:

char_length(value: STRING) -> INT64

Descrizione:

Restituisce il numero di punti di codice Unicode nel valore STRING.

Esempi:

valore char_length(value)
"abc" 3
"ciao" 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();
Vai
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.CharLength(firestore.FieldOf("title")).As("titleCharLength"),
	)).
	Execute(ctx)

STARTS_WITH

Sintassi:

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

Descrizione:

Restituisce TRUE se value inizia con prefix.

Esempi:

valore prefisso 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();
Vai
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.StartsWith(firestore.FieldOf("title"), "The").As("needsSpecialAlphabeticalSort"),
	)).
	Execute(ctx)

ENDS_WITH

Sintassi:

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

Descrizione:

Restituisce TRUE se value termina con postfix.

Esempi:

valore 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();
Vai
snapshot := client.Pipeline().
	Collection("inventory/devices/laptops").
	Select(firestore.Fields(
		firestore.EndsWith(firestore.FieldOf("name"), "16 inch").As("`Laptops16in`"),
	)).
	Execute(ctx)

MI PIACE

Sintassi:

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

Descrizione:

Restituisce TRUE se value corrisponde a pattern.

Esempi:

valore motivo 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();
Vai
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.Like(firestore.FieldOf("genre"), "%Fiction").As("anyFiction"),
	)).
	Execute(ctx)

REGEX_CONTAINS

Sintassi:

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

Descrizione:

Restituisce TRUE se una parte di value corrisponde a regexp. Se regexp non è un'espressione regolare valida, questa funzione restituisce un error.

L'argomento regexp può anche essere un valore REGEX creato utilizzando regex("pattern", "options"). Questo formato ti consente di fornire opzioni di espressioni regolari insieme al pattern. Le opzioni supportate sono:

  • i: corrispondenza senza distinzione tra maiuscole e minuscole.
  • m: modalità multilinea (^ e $ corrispondono all'inizio o alla fine delle righe).
  • s: modalità Dotall (. corrisponde alle nuove righe).

Se regexp è un STRING, non vengono applicate opzioni oltre a quelle incorporate nel pattern stesso (ad es. (?i)).

Le espressioni regolari seguono la sintassi della libreria re2.

Esempi:

valore regexp regex_contains(value, regexp)
"Firestore" "Fuoco" 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();
Vai
snapshot := client.Pipeline().
	Collection("documents").
	Select(firestore.Fields(
		firestore.RegexContains(firestore.FieldOf("title"), "Firestore (Enterprise|Standard)").As("isFirestoreRelated"),
	)).
	Execute(ctx)

REGEX_FIND

Sintassi:

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

Descrizione:

Restituisce la prima sottostringa in value che corrisponde a regexp o NULL se non esiste alcuna corrispondenza. Se regexp non è un'espressione regolare valida, questa funzione restituisce un error.

L'argomento regexp può anche essere un valore REGEX creato utilizzando regex("pattern", "options"). Questo formato ti consente di fornire opzioni di espressioni regolari insieme al pattern. Le opzioni supportate sono:

  • i: corrispondenza senza distinzione tra maiuscole e minuscole.
  • m: modalità multilinea (^ e $ corrispondono all'inizio o alla fine delle righe).
  • s: modalità Dotall (. corrisponde alle nuove righe).

Se regexp è un STRING, non vengono applicate opzioni oltre a quelle incorporate nel pattern stesso (ad es. (?i)).

Le espressioni regolari seguono la sintassi della libreria re2.

Esempi:

valore 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

Sintassi:

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

Descrizione:

Restituisce un array di tutte le sottostringhe in value che corrispondono a regexp o un array vuoto se non sono presenti corrispondenze. Se regexp non è un'espressione regolare valida, questa funzione restituisce un error.

L'argomento regexp può anche essere un valore REGEX creato utilizzando regex("pattern", "options"). Questo formato ti consente di fornire opzioni di espressioni regolari insieme al pattern. Le opzioni supportate sono:

  • i: corrispondenza senza distinzione tra maiuscole e minuscole.
  • m: modalità multilinea (^ e $ corrispondono all'inizio o alla fine delle righe).
  • s: modalità Dotall (. corrisponde alle nuove righe).

Se regexp è un STRING, non vengono applicate opzioni oltre a quelle incorporate nel pattern stesso (ad es. (?i)).

Le espressioni regolari seguono la sintassi della libreria re2.

Esempi:

valore regexp regex_find_all(value, regexp)
"one two three two" "one" ["one"]
"one TWO three Two" regex("two", "i") ["TWO", "Two"]
"one two three two" regex("TWO", "") []

REGEX_MATCH

Sintassi:

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

Descrizione:

Restituisce TRUE se value corrisponde completamente a regexp. Se regexp non è un'espressione regolare valida, questa funzione restituisce error.

L'argomento regexp può anche essere un valore REGEX creato utilizzando regex("pattern", "options"). Questo formato ti consente di fornire opzioni di espressioni regolari insieme al pattern. Le opzioni supportate sono:

  • i: corrispondenza senza distinzione tra maiuscole e minuscole.
  • m: modalità multilinea (^ e $ corrispondono all'inizio o alla fine delle righe).
  • s: modalità Dotall (. corrisponde alle nuove righe).

Se regexp è un STRING, non vengono applicate opzioni oltre a quelle incorporate nel pattern stesso (ad es. (?i)).

Le espressioni regolari seguono la sintassi della libreria re2.

Esempi:

valore regexp regex_match(value, regexp)
"Firestore" "F.*store" true
"Firestore" "Fuoco" 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();
Vai
snapshot := client.Pipeline().
	Collection("documents").
	Select(firestore.Fields(
		firestore.RegexMatch(firestore.FieldOf("title"), "Firestore (Enterprise|Standard)").As("isFirestoreExactly"),
	)).
	Execute(ctx)

STRING_CONCAT

Sintassi:

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

Descrizione:

Concatena due o più valori STRING in un unico risultato.

Esempi:

argomenti string_concat(values...)
() errore
("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();
Vai
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.StringConcat(firestore.FieldOf("title"), " by ", firestore.FieldOf("author")).As("fullyQualifiedTitle"),
	)).
	Execute(ctx)

STRING_CONTAINS

Sintassi:

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

Descrizione:

Controlla se value contiene la stringa letterale substring.

Esempi:

valore 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();
Vai
snapshot := client.Pipeline().
	Collection("articles").
	Select(firestore.Fields(
		firestore.StringContains(firestore.FieldOf("body"), "Firestore").As("isFirestoreRelated"),
	)).
	Execute(ctx)

STRING_INDEX_OF

Sintassi:

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

Descrizione:

Restituisce l'indice a base 0 della prima occorrenza di search in value.

  • Restituisce -1 se search non viene trovato.
  • Se value è un valore STRING, il risultato viene misurato in punti di codice Unicode. Se si tratta di un valore BYTES, viene misurato in byte.
  • Se search è un valore STRING o BYTES vuoto, il risultato è 0.

Esempi:

valore search 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

Sintassi:

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

Descrizione:

Converte un valore STRING o BYTES in lettere maiuscole.

Se un byte o un carattere non corrisponde a un carattere alfabetico minuscolo UTF-8, viene trasmesso invariato.

Esempi:

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

TO_LOWER

Sintassi:

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

Descrizione:

Converte un valore STRING o BYTES in minuscolo.

Se un byte o un carattere non corrisponde a un carattere alfabetico maiuscolo UTF-8, viene trasmesso invariato.

Esempi:

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

SUBSTRING

Sintassi:

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

Descrizione:

Restituisce una sottostringa di input a partire da position (indice in base zero) e include fino a length voci. Se non viene fornito length, restituisce la sottostringa da position alla fine di input.

  • Se input è un valore STRING, position e length vengono misurati in punti di codice Unicode. Se si tratta di un valore BYTES, vengono misurati in byte.

  • Se position è maggiore della lunghezza di input, viene restituita una sottostringa vuota. Se position più length è maggiore della lunghezza di input, la sottostringa viene troncata alla fine di input.

  • Se position è negativo, la posizione viene presa dalla fine dell'input. Se il valore negativo di position è maggiore della dimensione dell'input, la posizione viene impostata su zero. length non deve essere un valore negativo.

Esempi:

Quando length non viene fornito:

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

Quando viene fornito length:

immissione position lunghezza 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();
Vai
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

Sintassi:

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

Descrizione:

Restituisce l'input fornito in ordine inverso.

I caratteri sono delineati da punti di codice Unicode quando l'input è un valore STRING e da byte quando l'input è un valore BYTES.

Esempi:

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

STRING_REPEAT

Sintassi:

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

Descrizione:

Restituisce input ripetuto repetitions volte.

  • repetitions deve essere un numero intero non negativo.
  • Se repetitions è 0, restituisce un valore vuoto dello stesso tipo di input.
  • Se il risultato supera le dimensioni massime consentite (1 MB), viene restituito un errore.

Esempi:

immissione ripetizioni string_repeat(input, repetitions)
"foo" 3 "foofoofoo"
"foo" 0 ""
"a " 3 "a a a "
b"ab" 2 b"abab"
"é🦆" 2 "é🦆é🦆"

STRING_REPLACE_ALL

Sintassi:

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

Descrizione:

Sostituisce tutte le occorrenze non sovrapposte di find in input con replacement.

  • Le corrispondenze sono sensibili alle maiuscole.
  • Se find è vuoto, non vengono eseguite sostituzioni.

Esempi:

immissione find replacement 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

Sintassi:

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

Descrizione:

Sostituisce la prima occorrenza di find in input con replacement.

  • Le corrispondenze sono sensibili alle maiuscole.
  • Se find è vuoto, non vengono eseguite sostituzioni.

Esempi:

immissione find replacement string_replace_one(input, find, replacement)
"foobarfoo" "foo" "baz" "bazbarfoo"
"é" "é" "a" "a"
b"foobar" b"o" b"z" b"fzoobar"

TRIM

Sintassi:

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

Descrizione:

Rimuove un insieme specificato di BYTES o CHARS dall'inizio e dalla fine del valore input fornito.

  • Se non viene fornito alcun values_to_trim, rimuove gli spazi vuoti.

Esempi:

Quando values_to_trim non viene fornito:

immissione 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"

Quando viene fornito values_to_trim:

immissione values_to_trim trim(input, values_to_trim)
"abcbfooaacb" "abc" "foo"
"abcdaabadbac" "abc" "daabad"
b"C1C2C3" b"C1" b"C2C3"
b"C1C2" "foo" errore
"foo" b"C1" errore

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

LTRIM

Sintassi:

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

Descrizione:

Rimuove un insieme specificato di BYTES o CHARS dall'inizio della stringa value fornita.

  • Se to_trim non viene fornito, rimuove gli spazi vuoti iniziali.

Esempi:

Quando to_trim non viene fornito:

valore ltrim(value)
" foo " "foo "
"foo" "foo"

Quando viene fornito to_trim:

valore to_trim ltrim(value, to_trim)
"aaabc" "a" "bc"
"abacaba" "ba" "caba"
"é" "é" ""

RTRIM

Sintassi:

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

Descrizione:

Rimuove un insieme specificato di BYTES o CHARS dalla fine del valore value fornito.

  • Se to_trim non viene fornito, rimuove gli spazi vuoti finali.

Esempi:

Quando to_trim non viene fornito:

valore rtrim(value)
" foo " " foo"
"foo" "foo"

Quando viene fornito to_trim:

valore to_trim rtrim(value, to_trim)
"abccc" "c" "ab"
"abacaba" "ba" "abac"
"é" "é" ""

DIVIDI

Sintassi:

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

Descrizione:

Suddivide un valore STRING o BYTES utilizzando un delimitatore.

  • Per STRING il delimitatore predefinito è la virgola ,. Il delimitatore viene trattato come una singola stringa.

  • Per BYTES, devi specificare un delimitatore.

  • La suddivisione in base a un delimitatore vuoto produce un array di punti di codice Unicode per i valori STRING e un array di BYTES per i valori BYTES.

  • La suddivisione di un STRING vuoto restituisce un ARRAY con un singolo STRING vuoto.

Esempi:

Quando delimiter non viene fornito:

immissione split(input)
"foo,bar,foo" ["foo", "bar", "foo"]
"foo" ["foo"]
",foo," ["", "foo", ""]
"" [""]
b"C120C2C4" errore

Quando viene fornito delimiter:

immissione delimitatore 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" errore