原生模式下的 Cloud Firestore 企业版现已推出！了解详情。

स्ट्रिंग फ़ंक्शन

प्रीव्यू: Enterprise Edition के लिए, पाइपलाइन ऑपरेशन के साथ नेटिव मोड में Firestore पर "Pre-GA के तहत आने वाले प्रॉडक्ट और सुविधाओं से जुड़ी शर्तें" लागू होती हैं. ये शर्तें, सेवा की खास शर्तें पेज पर 'सेवा की सामान्य शर्तें' सेक्शन में दी गई हैं. इस सुविधा के लिए, निजी डेटा को प्रोसेस किया जा सकता है. इसके लिए, Cloud डेटा प्रोसेसिंग अडेंडम में दिए गए निर्देशों का पालन करें. हालांकि, यह Google Cloud को ऐक्सेस करने के लिए किए गए समझौते में बताई गई जवाबदेही और पाबंदियों के तहत किया जाएगा. Pre-GA के तहत आने वाली सुविधाएं, "जैसी हैं वैसी" ही उपलब्ध कराई जाती हैं. इसलिए, हो सकता है कि इनके लिए आपको सीमित सहायता मिले. ज़्यादा जानकारी के लिए, लॉन्च के चरणों की जानकारी देखें.

स्ट्रिंग फ़ंक्शन

नाम	ब्यौरा
`BYTE_LENGTH`	`STRING` या `BYTES` वैल्यू में मौजूद `BYTES` की संख्या दिखाता है
`CHAR_LENGTH`	किसी `STRING` वैल्यू में मौजूद यूनिकोड वर्णों की संख्या दिखाता है
`STARTS_WITH`	अगर कोई `STRING`, दिए गए प्रीफ़िक्स से शुरू होता है, तो `TRUE` दिखाता है
`ENDS_WITH`	अगर कोई `STRING` दिए गए पोस्टफ़िक्स पर खत्म होता है, तो `TRUE` दिखाता है
`LIKE`	अगर कोई `STRING` किसी पैटर्न से मैच होता है, तो `TRUE` दिखाता है
`REGEX_CONTAINS`	अगर कोई वैल्यू, रेगुलर एक्सप्रेशन से पूरी तरह या कुछ हद तक मैच करती है, तो यह फ़ंक्शन `TRUE` दिखाता है
`REGEX_MATCH`	अगर किसी वैल्यू का कोई हिस्सा रेगुलर एक्सप्रेशन से मैच करता है, तो `TRUE` दिखाता है
`STRING_CONCAT`	यह फ़ंक्शन, कई `STRING` को एक `STRING` में जोड़ता है
`STRING_CONTAINS`	अगर किसी वैल्यू में `TRUE` मौजूद है, तो `TRUE` दिखाता है`STRING`
`STRING_INDEX_OF`	यह फ़ंक्शन, `STRING` या `BYTES` वैल्यू की पहली बार दिखने वाली जगह का इंडेक्स दिखाता है. इंडेक्स की गिनती 0 से शुरू होती है.
`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

ब्यौरा:

यह फ़ंक्शन, STRING या BYTES वैल्यू में मौजूद BYTES की संख्या दिखाता है.

उदाहरण:

value	`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();test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("title").byteLength().as("titleByteLength")
  )
);test.firestore.js

Swift

let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("title").byteLength().as("titleByteLength")
  ])
  .execute()PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        field("title").byteLength().alias("titleByteLength")
    )
    .execute()DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("title").byteLength().alias("titleByteLength")
    )
    .execute();DocSnippets.java

Python

from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("title").byte_length().as_("titleByteLength"))
    .execute()
)firestore_pipelines.py

Java

Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(byteLength(field("title")).as("titleByteLength"))
        .execute()
        .get();PipelineSnippets.java

CHAR_LENGTH

सिंटैक्स:

char_length(value: STRING) -> INT64

ब्यौरा:

STRING वैल्यू में यूनिकोड कोड पॉइंट की संख्या दिखाता है.

उदाहरण:

value	`char_length(value)`
"abc"	3
"नमस्ते"	5
"दुनिया"	5

Node.js

const result = await db.pipeline()
  .collection("books")
  .select(
    field("title").charLength().as("titleCharLength")
  )
  .execute();test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("title").charLength().as("titleCharLength")
  )
);test.firestore.js

Swift

let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("title").charLength().as("titleCharLength")
  ])
  .execute()PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        field("title").charLength().alias("titleCharLength")
    )
    .execute()DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("title").charLength().alias("titleCharLength")
    )
    .execute();DocSnippets.java

Python

from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("title").char_length().as_("titleCharLength"))
    .execute()
)firestore_pipelines.py

Java

Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(charLength(field("title")).as("titleCharLength"))
        .execute()
        .get();PipelineSnippets.java

STARTS_WITH

सिंटैक्स:

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

ब्यौरा:

अगर value, prefix से शुरू होता है, तो TRUE दिखाता है.

उदाहरण:

value	उपसर्ग	`starts_with(value, prefix)`
"abc"	"a"	सही
"abc"	"b"	गलत
"abc"	""	सही

Node.js

const result = await db.pipeline()
  .collection("books")
  .select(
    field("title").startsWith("The")
      .as("needsSpecialAlphabeticalSort")
  )
  .execute();test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("title").startsWith("The")
      .as("needsSpecialAlphabeticalSort")
  )
);test.firestore.js

Swift

let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("title").startsWith("The")
      .as("needsSpecialAlphabeticalSort")
  ])
  .execute()PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        field("title").startsWith("The")
            .alias("needsSpecialAlphabeticalSort")
    )
    .execute()DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("title").startsWith("The")
            .alias("needsSpecialAlphabeticalSort")
    )
    .execute();DocSnippets.java

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()
)firestore_pipelines.py

Java

Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(startsWith(field("title"), "The").as("needsSpecialAlphabeticalSort"))
        .execute()
        .get();PipelineSnippets.java

ENDS_WITH

सिंटैक्स:

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

ब्यौरा:

अगर value के आखिर में postfix आता है, तो TRUE दिखाता है.

उदाहरण:

value	पोस्टफ़िक्स	`ends_with(value, postfix)`
"abc"	"c"	सही
"abc"	"b"	गलत
"abc"	""	सही

Node.js

const result = await db.pipeline()
  .collection("inventory/devices/laptops")
  .select(
    field("name").endsWith("16 inch")
      .as("16InLaptops")
  )
  .execute();test.firestore.js

Swift

let result = try await db.pipeline()
  .collection("inventory/devices/laptops")
  .select([
    Field("name").endsWith("16 inch")
      .as("16InLaptops")
  ])
  .execute()PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("inventory/devices/laptops")
    .select(
        field("name").endsWith("16 inch")
            .alias("16InLaptops")
    )
    .execute()DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("inventory/devices/laptops")
    .select(
        field("name").endsWith("16 inch")
            .alias("16InLaptops")
    )
    .execute();DocSnippets.java

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()
)firestore_pipelines.py

Java

Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("inventory/devices/laptops")
        .select(endsWith(field("name"), "16 inch").as("16InLaptops"))
        .execute()
        .get();PipelineSnippets.java

पसंद करें

सिंटैक्स:

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

ब्यौरा:

अगर value का मिलान pattern से होता है, तो TRUE दिखाता है.

उदाहरण:

value	पैटर्न	`like(value, pattern)`
"Firestore"	"Fire%"	सही
"Firestore"	"%store"	सही
"Datastore"	"Data_tore"	सही
"100%"	"100\%"	सही

Node.js

const result = await db.pipeline()
  .collection("books")
  .select(
    field("genre").like("%Fiction")
      .as("anyFiction")
  )
  .execute();test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("genre").like("%Fiction")
      .as("anyFiction")
  )
);test.firestore.js

Swift

let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("genre").like("%Fiction")
      .as("anyFiction")
  ])
  .execute()PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        field("genre").like("%Fiction")
            .alias("anyFiction")
    )
    .execute()DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("genre").like("%Fiction")
            .alias("anyFiction")
    )
    .execute();DocSnippets.java

Python

from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("genre").like("%Fiction").as_("anyFiction"))
    .execute()
)firestore_pipelines.py

Java

Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(like(field("genre"), "%Fiction").as("anyFiction"))
        .execute()
        .get();PipelineSnippets.java

REGEX_CONTAINS

सिंटैक्स:

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

ब्यौरा:

अगर value का कुछ हिस्सा pattern से मेल खाता है, तो TRUE दिखाता है. अगर pattern एक मान्य रेगुलर एक्सप्रेशन नहीं है, तो यह फ़ंक्शन error दिखाता है.

रेगुलर एक्सप्रेशन, re2 लाइब्रेरी के सिंटैक्स का पालन करते हैं.

उदाहरण:

value	पैटर्न	`regex_contains(value, pattern)`
"Firestore"	"आग"	सही
"Firestore"	"store$"	सही
"Firestore"	"data"	गलत

Node.js

const result = await db.pipeline()
  .collection("documents")
  .select(
    field("title").regexContains("Firestore (Enterprise|Standard)")
      .as("isFirestoreRelated")
  )
  .execute();test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("documents")
  .select(
    field("title").regexContains("Firestore (Enterprise|Standard)")
      .as("isFirestoreRelated")
  )
);test.firestore.js

Swift

let result = try await db.pipeline()
  .collection("documents")
  .select([
    Field("title").regexContains("Firestore (Enterprise|Standard)")
      .as("isFirestoreRelated")
  ])
  .execute()PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("documents")
    .select(
        field("title").regexContains("Firestore (Enterprise|Standard)")
            .alias("isFirestoreRelated")
    )
    .execute()DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("title").regexContains("Firestore (Enterprise|Standard)")
            .alias("isFirestoreRelated")
    )
    .execute();DocSnippets.java

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()
)firestore_pipelines.py

Java

Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(
            regexContains(field("title"), "Firestore (Enterprise|Standard)")
                .as("isFirestoreRelated"))
        .execute()
        .get();PipelineSnippets.java

REGEX_MATCH

सिंटैक्स:

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

ब्यौरा:

अगर value, pattern से पूरी तरह मैच होता है, तो TRUE दिखाता है. अगर pattern एक मान्य रेगुलर एक्सप्रेशन नहीं है, तो यह फ़ंक्शन error दिखाता है.

रेगुलर एक्सप्रेशन, re2 लाइब्रेरी के सिंटैक्स का पालन करते हैं.

उदाहरण:

value	पैटर्न	`regex_match(value, pattern)`
"Firestore"	"F.*store"	सही
"Firestore"	"आग"	गलत
"Firestore"	"^F.*e$"	सही

Node.js

const result = await db.pipeline()
  .collection("documents")
  .select(
    field("title").regexMatch("Firestore (Enterprise|Standard)")
      .as("isFirestoreExactly")
  )
  .execute();test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("documents")
  .select(
    field("title").regexMatch("Firestore (Enterprise|Standard)")
      .as("isFirestoreExactly")
  )
);test.firestore.js

Swift

let result = try await db.pipeline()
  .collection("documents")
  .select([
    Field("title").regexMatch("Firestore (Enterprise|Standard)")
      .as("isFirestoreExactly")
  ])
  .execute()PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("documents")
    .select(
        field("title").regexMatch("Firestore (Enterprise|Standard)")
            .alias("isFirestoreExactly")
    )
    .execute()DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("title").regexMatch("Firestore (Enterprise|Standard)")
            .alias("isFirestoreExactly")
    )
    .execute();DocSnippets.java

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()
)firestore_pipelines.py

Java

Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(
            regexMatch(field("title"), "Firestore (Enterprise|Standard)")
                .as("isFirestoreExactly"))
        .execute()
        .get();PipelineSnippets.java

STRING_CONCAT

सिंटैक्स:

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

ब्यौरा:

दो या उससे ज़्यादा STRING वैल्यू को एक साथ जोड़कर एक नतीजा दिखाता है.

उदाहरण:

आर्ग्युमेंट	`string_concat(values...)`
`()`	गड़बड़ी
`("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();test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("title").stringConcat(" by ", field("author"))
      .as("fullyQualifiedTitle")
  )
);test.firestore.js

Swift

let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("title").concat([" by ", Field("author")])
      .as("fullyQualifiedTitle")
  ])
  .execute()PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        field("title").concat(" by ", field("author"))
            .alias("fullyQualifiedTitle")
    )
    .execute()DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("title").concat(" by ", field("author"))
            .alias("fullyQualifiedTitle")
    )
    .execute();DocSnippets.java

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()
)firestore_pipelines.py

Java

Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(stringConcat(field("title"), " by ", field("author")).as("fullyQualifiedTitle"))
        .execute()
        .get();PipelineSnippets.java

STRING_CONTAINS

सिंटैक्स:

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

ब्यौरा:

इस फ़ंक्शन से यह पता चलता है कि value में लिटरल स्ट्रिंग substring मौजूद है या नहीं.

उदाहरण:

value	सबस्ट्रिंग	`string_contains(value, substring)`
"abc"	"b"	सही
"abc"	"d"	गलत
"abc"	""	सही
"a.c"	"."	सही
"☃☃☃"	"☃"	सही

Node.js

const result = await db.pipeline()
  .collection("articles")
  .select(
    field("body").stringContains("Firestore")
      .as("isFirestoreRelated")
  )
  .execute();test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("articles")
  .select(
    field("body").stringContains("Firestore")
      .as("isFirestoreRelated")
  )
);test.firestore.js

Swift

let result = try await db.pipeline()
  .collection("articles")
  .select([
    Field("body").stringContains("Firestore")
      .as("isFirestoreRelated")
  ])
  .execute()PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("articles")
    .select(
        field("body").stringContains("Firestore")
            .alias("isFirestoreRelated")
    )
    .execute()DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("articles")
    .select(
        field("body").stringContains("Firestore")
            .alias("isFirestoreRelated")
    )
    .execute();DocSnippets.java

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()
)firestore_pipelines.py

Java

Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("articles")
        .select(stringContains(field("body"), "Firestore").as("isFirestoreRelated"))
        .execute()
        .get();PipelineSnippets.java

STRING_INDEX_OF

सिंटैक्स:

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

ब्यौरा:

value में search के पहले इंस्टेंस का इंडेक्स दिखाता है. यह इंडेक्स 0 से शुरू होता है.

अगर search नहीं मिलता है, तो -1 दिखाता है.
अगर value कोई STRING वैल्यू है, तो नतीजे को यूनिकोड कोड पॉइंट में मापा जाता है. अगर यह BYTES वैल्यू है, तो इसे बाइट में मापा जाता है.
अगर search कोई खाली STRING या BYTES वैल्यू है, तो नतीजा 0 होता है.

उदाहरण:

value	खोजें	`string_index_of(value, search)`
"नमस्ते दुनिया"	"o"	4
"नमस्ते दुनिया"	"l"	2
"नमस्ते दुनिया"	"z"	-1
"केला"	"na"	2
"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 लोअरकेस अल्फ़ाबेटिक वर्ण से मेल नहीं खाता है, तो उसे बिना किसी बदलाव के पास कर दिया जाता है.

उदाहरण:

value	`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();test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("authors")
  .select(
    field("name").toUpper()
      .as("uppercaseName")
  )
);test.firestore.js

Swift

let result = try await db.pipeline()
  .collection("authors")
  .select([
    Field("name").toUpper()
      .as("uppercaseName")
  ])
  .execute()PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("authors")
    .select(
        field("name").toUpper()
            .alias("uppercaseName")
    )
    .execute()DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("authors")
    .select(
        field("name").toUpper()
            .alias("uppercaseName")
    )
    .execute();DocSnippets.java

Python

from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("authors")
    .select(Field.of("name").to_upper().as_("uppercaseName"))
    .execute()
)firestore_pipelines.py

Java

Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("authors")
        .select(toUpper(field("name")).as("uppercaseName"))
        .execute()
        .get();PipelineSnippets.java

TO_LOWER

सिंटैक्स:

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

ब्यौरा:

STRING या BYTES वैल्यू को छोटे अक्षरों में बदलता है.

अगर कोई बाइट या वर्ण, UTF-8 के बड़े अक्षरों वाले वर्ण से मेल नहीं खाता है, तो उसे बिना किसी बदलाव के पास कर दिया जाता है.

उदाहरण:

value	`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();test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("authors")
  .select(
    field("genre").toLower().equal("fantasy")
      .as("isFantasy")
  )
);test.firestore.js

Swift

let result = try await db.pipeline()
  .collection("authors")
  .select([
    Field("genre").toLower().equal("fantasy")
      .as("isFantasy")
  ])
  .execute()PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("authors")
    .select(
        field("genre").toLower().equal("fantasy")
            .alias("isFantasy")
    )
    .execute()DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("authors")
    .select(
        field("genre").toLower().equal("fantasy")
            .alias("isFantasy")
    )
    .execute();DocSnippets.java

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()
)firestore_pipelines.py

Java

Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("authors")
        .select(equal(toLower(field("genre")), "fantasy").as("isFantasy"))
        .execute()
        .get();PipelineSnippets.java

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 को यूनिकोड कोड पॉइंट में मापा जाता है. अगर यह BYTES वैल्यू है, तो इन्हें बाइट में मेज़र किया जाता है.
अगर position, input की लंबाई से ज़्यादा है, तो खाली सबस्ट्रिंग मिलती है. अगर position और length का योग, input की लंबाई से ज़्यादा है, तो सबस्ट्रिंग को input के आखिर तक काट दिया जाता है.
अगर position की वैल्यू नेगेटिव है, तो पोज़िशन को इनपुट के आखिर से लिया जाता है. अगर नेगेटिव position की वैल्यू, इनपुट के साइज़ से ज़्यादा है, तो पोज़िशन को शून्य पर सेट किया जाता है. length की वैल्यू, ज़ीरो (शून्य) से कम नहीं होनी चाहिए.

उदाहरण:

length की वैल्यू न देने पर:

इनपुट	जगह	`substring(input, position)`
"abc"	0	"abc"
"abc"	1	"bc"
"abc"	3	""
"abc"	-1	"c"
b"abc"	1	b"bc"

length की जानकारी देने पर:

इनपुट	जगह	लंबाई	`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();test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .where(field("title").startsWith("The "))
  .select(
    field("title").substring(4)
      .as("titleWithoutLeadingThe")
  )
);test.firestore.js

Swift

let result = try await db.pipeline()
  .collection("books")
  .where(Field("title").startsWith("The "))
  .select([
    Field("title").substring(position: 4)
      .as("titleWithoutLeadingThe")
  ])
  .execute()PipelineSnippets.swift

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()DocSnippets.kt

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();DocSnippets.java

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()
)firestore_pipelines.py

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();PipelineSnippets.java

STRING_REVERSE

सिंटैक्स:

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

ब्यौरा:

यह फ़ंक्शन, दिए गए इनपुट को उल्टे क्रम में दिखाता है.

जब इनपुट 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();test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("name").reverse().as("reversedName")
  )
);test.firestore.js

Swift

let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("name").reverse().as("reversedName")
  ])
  .execute()PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        field("name").reverse().alias("reversedName")
    )
    .execute()DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("name").reverse().alias("reversedName")
    )
    .execute();DocSnippets.java

Python

from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("name").string_reverse().as_("reversedName"))
    .execute()
)firestore_pipelines.py

Java

Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(reverse(field("name")).as("reversedName"))
        .execute()
        .get();PipelineSnippets.java

STRING_REPEAT

सिंटैक्स:

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

ब्यौरा:

यह फ़ंक्शन, input को repetitions बार दोहराकर दिखाता है.

repetitions की वैल्यू, शून्य या इससे ज़्यादा का पूर्णांक होना चाहिए.
अगर repetitions 0 है, तो input के टाइप की खाली वैल्यू दिखाता है.
अगर नतीजे का साइज़, तय सीमा (1 एमबी) से ज़्यादा होता है, तो गड़बड़ी का मैसेज दिखता है.

उदाहरण:

इनपुट	दोहराव	`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

ब्यौरा:

input में find के सभी नॉन-ओवरलैपिंग इंस्टेंस को 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

ब्यौरा:

input में, find के पहले इंस्टेंस को 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

ब्यौरा:

यह फ़ंक्शन, दी गई input के शुरू और आखिर से, तय किए गए BYTES या CHARS को हटाता है.

अगर कोई 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"	गड़बड़ी
"foo"	b"C1"	गड़बड़ी

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("name").trim().as("whitespaceTrimmedName")
  )
);test.firestore.js

Swift

let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("name").trim(" \n\t").as("whitespaceTrimmedName")
  ])
  .execute()PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        field("name").trim().alias("whitespaceTrimmedName")
    )
    .execute()DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("name").trim().alias("whitespaceTrimmedName")
    )
    .execute();DocSnippets.java

Python

from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("name").trim().as_("whitespaceTrimmedName"))
    .execute()
)firestore_pipelines.py

Java

Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(trim(field("name")).as("whitespaceTrimmedName"))
        .execute()
        .get();PipelineSnippets.java

LTRIM

सिंटैक्स:

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

ब्यौरा:

यह फ़ंक्शन, दिए गए value की शुरुआत से, तय किए गए BYTES या CHARS को हटाता है.

अगर to_trim नहीं दिया गया है, तो शुरुआती व्हाइटस्पेस कैरेक्टर हटा दिए जाते हैं.

उदाहरण:

to_trim की वैल्यू न देने पर:

value	`ltrim(value)`
" foo "	"foo "
"foo"	"foo"

to_trim की जानकारी देने पर:

value	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

ब्यौरा:

यह फ़ंक्शन, दिए गए value के आखिर से, तय किए गए BYTES या CHARS को हटाता है.

अगर to_trim नहीं दिया गया है, तो आखिर में मौजूद व्हाइटस्पेस कैरेक्टर हटा देता है.

उदाहरण:

to_trim की वैल्यू न देने पर:

value	`rtrim(value)`
" foo "	" foo"
"foo"	"foo"

to_trim की जानकारी देने पर:

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

SPLIT

सिंटैक्स:

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

ब्यौरा:

यह फ़ंक्शन, डीलिमिटर का इस्तेमाल करके STRING या BYTES वैल्यू को अलग-अलग हिस्सों में बांटता है.

STRING के लिए डिफ़ॉल्ट डीलिमिटर, कॉमा , होता है. डेलिमिटर को एक स्ट्रिंग के तौर पर माना जाता है.
BYTES के लिए, आपको डेलिमिटर तय करना होगा.
खाली डेलिमीटर के आधार पर स्प्लिट करने पर, STRING वैल्यू के लिए यूनिकोड कोडपॉइंट की एक श्रेणी और BYTES वैल्यू के लिए BYTES की एक श्रेणी मिलती है.
खाली STRING को स्प्लिट करने पर, एक खाली STRING वाला ARRAY मिलता है.

उदाहरण:

delimiter की वैल्यू न देने पर:

इनपुट	`split(input)`
"foo,bar,foo"	["foo", "bar", "foo"]
"foo"	["foo"]
",foo,"	["", "foo", ""]
""	[""]
b"C120C2C4"	गड़बड़ी

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"	गड़बड़ी