सभी फ़ंक्शन

Aggregate

सभी एग्रीगेट फ़ंक्शन का इस्तेमाल, aggregate(...) स्टेज में टॉप-लेवल एक्सप्रेशन के तौर पर किया जा सकता है.

नाम ब्यौरा
COUNT यह फ़ंक्शन, दस्तावेज़ों की संख्या दिखाता है.
COUNT_IF यह उन दस्तावेज़ों की संख्या दिखाता है जिनमें एक्सप्रेशन की वैल्यू TRUE होती है
COUNT_DISTINCT यह फ़ंक्शन, यूनीक और नॉन NULL वैल्यू की संख्या दिखाता है
SUM सभी NUMERIC वैल्यू का योग दिखाता है
AVERAGE NUMERIC की सभी वैल्यू का औसत दिखाता है
MINIMUM NULL के अलावा अन्य सबसे कम वैल्यू दिखाता है
MAXIMUM यह फ़ंक्शन, सबसे बड़ी नॉन-NULL वैल्यू दिखाता है
FIRST पहले दस्तावेज़ के लिए expression वैल्यू दिखाता है.
LAST यह फ़ंक्शन, आखिरी दस्तावेज़ के लिए expression वैल्यू दिखाता है.
ARRAY_AGG यह सभी इनपुट वैल्यू का ऐरे दिखाता है.
ARRAY_AGG_DISTINCT यह फ़ंक्शन, इनपुट की सभी अलग-अलग वैल्यू का ऐरे दिखाता है.

COUNT

सिंटैक्स:

count() -> INT64
count(expression: ANY) -> INT64

ब्यौरा:

यह फ़ंक्शन, पिछली स्टेज के उन दस्तावेज़ों की संख्या दिखाता है जिनमें expression की वैल्यू, NULL के अलावा कोई और वैल्यू होती है. अगर कोई expression नहीं दिया जाता है, तो यह पिछली स्टेज के दस्तावेज़ों की कुल संख्या दिखाता है.

Node.js
// Total number of books in the collection
const countOfAll = await db.pipeline()
  .collection("books")
  .aggregate(countAll().as("count"))
  .execute();

// Number of books with nonnull `ratings` field
const countField = await db.pipeline()
  .collection("books")
  .aggregate(field("ratings").count().as("count"))
  .execute();
test.firestore.js

Web

// Total number of books in the collection
const countOfAll = await execute(db.pipeline()
  .collection("books")
  .aggregate(countAll().as("count"))
);

// Number of books with nonnull `ratings` field
const countField = await execute(db.pipeline()
  .collection("books")
  .aggregate(field("ratings").count().as("count"))
);
test.firestore.js
Swift
// Total number of books in the collection
let countAll = try await db.pipeline()
  .collection("books")
  .aggregate([CountAll().as("count")])
  .execute()

// Number of books with nonnull `ratings` field
let countField = try await db.pipeline()
  .collection("books")
  .aggregate([Field("ratings").count().as("count")])
  .execute()
PipelineSnippets.swift

Kotlin

// Total number of books in the collection
val countAll = db.pipeline()
    .collection("books")
    .aggregate(AggregateFunction.countAll().alias("count"))
    .execute()

// Number of books with nonnull `ratings` field
val countField = db.pipeline()
    .collection("books")
    .aggregate(AggregateFunction.count("ratings").alias("count"))
    .execute()
DocSnippets.kt

Java

// Total number of books in the collection
Task<Pipeline.Snapshot> countAll = db.pipeline()
    .collection("books")
    .aggregate(AggregateFunction.countAll().alias("count"))
    .execute();

// Number of books with nonnull `ratings` field
Task<Pipeline.Snapshot> countField = db.pipeline()
    .collection("books")
    .aggregate(AggregateFunction.count("ratings").alias("count"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Count

# Total number of books in the collection
count_all = (
    client.pipeline().collection("books").aggregate(Count().as_("count")).execute()
)

# Number of books with nonnull `ratings` field
count_field = (
    client.pipeline()
    .collection("books")
    .aggregate(Count("ratings").as_("count"))
    .execute()
)
firestore_pipelines.py
Java
// Total number of books in the collection
Pipeline.Snapshot countAll =
    firestore.pipeline().collection("books").aggregate(countAll().as("count")).execute().get();

// Number of books with nonnull `ratings` field
Pipeline.Snapshot countField =
    firestore
        .pipeline()
        .collection("books")
        .aggregate(count("ratings").as("count"))
        .execute()
        .get();
PipelineSnippets.java

COUNT_IF

सिंटैक्स:

count_if(expression: BOOLEAN) -> INT64

ब्यौरा:

यह फ़ंक्शन, पिछली स्टेज के उन दस्तावेज़ों की संख्या दिखाता है जिनमें expression की वैल्यू TRUE है.

Node.js
const result = await db.pipeline()
  .collection("books")
  .aggregate(
    field("rating").greaterThan(4).countIf().as("filteredCount")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .aggregate(
    field("rating").greaterThan(4).countIf().as("filteredCount")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .aggregate([
    AggregateFunction("count_if", [Field("rating").greaterThan(4)]).as("filteredCount")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .aggregate(
        AggregateFunction.countIf(field("rating").greaterThan(4)).alias("filteredCount")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .aggregate(
        AggregateFunction.countIf(field("rating").greaterThan(4)).alias("filteredCount")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .aggregate(Field.of("rating").greater_than(4).count_if().as_("filteredCount"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .aggregate(countIf(field("rating").greaterThan(4)).as("filteredCount"))
        .execute()
        .get();
PipelineSnippets.java

COUNT_DISTINCT

सिंटैक्स:

count_distinct(expression: ANY) -> INT64

ब्यौरा:

यह फ़ंक्शन, expression की उन यूनीक वैल्यू की संख्या दिखाता है जो NULL और ABSENT नहीं हैं.

Node.js
const result = await db.pipeline()
  .collection("books")
  .aggregate(field("author").countDistinct().as("unique_authors"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .aggregate(field("author").countDistinct().as("unique_authors"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .aggregate([AggregateFunction("count_distinct", [Field("author")]).as("unique_authors")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .aggregate(AggregateFunction.countDistinct("author").alias("unique_authors"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .aggregate(AggregateFunction.countDistinct("author").alias("unique_authors"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .aggregate(Field.of("author").count_distinct().as_("unique_authors"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .aggregate(countDistinct("author").as("unique_authors"))
        .execute()
        .get();
PipelineSnippets.java

SUM

सिंटैक्स:

sum(expression: ANY) -> NUMBER

ब्यौरा:

यह फ़ंक्शन, संख्या वाली सभी वैल्यू का योग दिखाता है. इसमें, बिना संख्या वाली वैल्यू को शामिल नहीं किया जाता. अगर कोई भी वैल्यू NaN है, तो NaN दिखाता है.

आउटपुट का टाइप, सबसे बड़े इनपुट टाइप के जैसा ही होगा. हालांकि, इन मामलों में ऐसा नहीं होगा:

  • अगर किसी INTEGER को INTEGER के तौर पर नहीं दिखाया जा सकता, तो उसे DOUBLE में बदल दिया जाएगा.
Node.js
const result = await db.pipeline()
  .collection("cities")
  .aggregate(field("population").sum().as("totalPopulation"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("cities")
  .aggregate(field("population").sum().as("totalPopulation"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("cities")
  .aggregate([Field("population").sum().as("totalPopulation")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("cities")
    .aggregate(AggregateFunction.sum("population").alias("totalPopulation"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("cities")
    .aggregate(AggregateFunction.sum("population").alias("totalPopulation"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("cities")
    .aggregate(Field.of("population").sum().as_("totalPopulation"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("cities")
        .aggregate(sum("population").as("totalPopulation"))
        .execute()
        .get();
PipelineSnippets.java

औसत

सिंटैक्स:

average(expression: ANY) -> FLOAT64

ब्यौरा:

यह फ़ंक्शन, संख्या वाली सभी वैल्यू का औसत दिखाता है. इसमें बिना संख्या वाली वैल्यू को शामिल नहीं किया जाता. अगर कोई वैल्यू NaN है, तो NaN के तौर पर नतीजे दिखाता है. अगर कोई संख्यात्मक वैल्यू एग्रीगेट नहीं की गई है, तो NULL के तौर पर नतीजे दिखाता है.

आउटपुट का टाइप, इनपुट के टाइप जैसा ही होगा. हालांकि, इन मामलों में ऐसा नहीं होगा:

  • अगर किसी INTEGER को INTEGER के तौर पर नहीं दिखाया जा सकता, तो उसे DOUBLE में बदल दिया जाएगा.
Node.js
const result = await db.pipeline()
  .collection("cities")
  .aggregate(field("population").average().as("averagePopulation"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("cities")
  .aggregate(field("population").average().as("averagePopulation"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("cities")
  .aggregate([Field("population").average().as("averagePopulation")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("cities")
    .aggregate(AggregateFunction.average("population").alias("averagePopulation"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("cities")
    .aggregate(AggregateFunction.average("population").alias("averagePopulation"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("cities")
    .aggregate(Field.of("population").average().as_("averagePopulation"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("cities")
        .aggregate(average("population").as("averagePopulation"))
        .execute()
        .get();
PipelineSnippets.java

कम से कम

सिंटैक्स:

minimum(expression: ANY) -> ANY

ब्यौरा:

यह फ़ंक्शन, हर दस्तावेज़ का आकलन करने के बाद, expression की सबसे छोटी वैल्यू दिखाता है. हालांकि, यह वैल्यू NULL नहीं होनी चाहिए और न ही 'मौजूद नहीं है' के तौर पर मार्क की गई होनी चाहिए.

अगर NULL और 'मौजूद नहीं है' के अलावा कोई दूसरी वैल्यू नहीं है, तो NULL दिखता है. इसमें ऐसे मामले भी शामिल हैं जिनमें कोई दस्तावेज़ नहीं माना जाता.

अगर एक से ज़्यादा वैल्यू, सबसे कम वैल्यू के बराबर हैं, तो उनमें से कोई भी वैल्यू दिखाई जा सकती है. वैल्यू टाइप का क्रम, दस्तावेज़ में दिए गए क्रम के हिसाब से होता है.

Node.js
const result = await db.pipeline()
  .collection("books")
  .aggregate(field("price").minimum().as("minimumPrice"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .aggregate(field("price").minimum().as("minimumPrice"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .aggregate([Field("price").minimum().as("minimumPrice")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .aggregate(AggregateFunction.minimum("price").alias("minimumPrice"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .aggregate(AggregateFunction.minimum("price").alias("minimumPrice"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .aggregate(Field.of("price").minimum().as_("minimumPrice"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .aggregate(minimum("price").as("minimumPrice"))
        .execute()
        .get();
PipelineSnippets.java

ज़्यादा से ज़्यादा

सिंटैक्स:

maximum(expression: ANY) -> ANY

ब्यौरा:

यह फ़ंक्शन, हर दस्तावेज़ का आकलन करने पर, expression की सबसे बड़ी ऐसी वैल्यू दिखाता है जो NULL नहीं है और मौजूद है.

अगर NULL और 'मौजूद नहीं है' के अलावा कोई दूसरी वैल्यू नहीं है, तो NULL दिखता है. इसमें ऐसे मामले भी शामिल हैं जिनमें कोई दस्तावेज़ नहीं माना जाता.

अगर सबसे ज़्यादा बार दिखने वाली वैल्यू एक से ज़्यादा हैं, तो उनमें से कोई भी वैल्यू दिखाई जा सकती है. वैल्यू टाइप का क्रम, दस्तावेज़ में दिए गए क्रम के हिसाब से होता है.

Node.js
const result = await db.pipeline()
  .collection("books")
  .aggregate(field("price").maximum().as("maximumPrice"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .aggregate(field("price").maximum().as("maximumPrice"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .aggregate([Field("price").maximum().as("maximumPrice")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .aggregate(AggregateFunction.maximum("price").alias("maximumPrice"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .aggregate(AggregateFunction.maximum("price").alias("maximumPrice"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .aggregate(Field.of("price").maximum().as_("maximumPrice"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .aggregate(maximum("price").as("maximumPrice"))
        .execute()
        .get();
PipelineSnippets.java

FIRST

सिंटैक्स:

first(expression: ANY) -> ANY

ब्यौरा:

यह फ़ंक्शन, पहले दिखाए गए दस्तावेज़ के लिए expression की वैल्यू दिखाता है.

LAST

सिंटैक्स:

last(expression: ANY) -> ANY

ब्यौरा:

यह फ़ंक्शन, आखिरी बार दिखाए गए दस्तावेज़ के लिए expression की वैल्यू दिखाता है.

ARRAY_AGG

सिंटैक्स:

array_agg(expression: ANY) -> ARRAY<ANY>

ब्यौरा:

यह एक ऐसा ऐरे दिखाता है जिसमें हर दस्तावेज़ का आकलन करने पर, expression की सभी वैल्यू शामिल होती हैं.

अगर एक्सप्रेशन से कोई वैल्यू नहीं मिलती है, तो उसे NULL में बदल दिया जाता है.

आउटपुट ऐरे में एलिमेंट का क्रम स्थिर नहीं होता. इसलिए, इस पर भरोसा नहीं किया जाना चाहिए.

ARRAY_AGG_DISTINCT

सिंटैक्स:

array_agg_distinct(expression: ANY) -> ARRAY<ANY>

ब्यौरा:

यह हर दस्तावेज़ पर आकलन किए जाने पर, expression की सभी अलग-अलग वैल्यू वाला एक ऐरे दिखाता है.

अगर एक्सप्रेशन से कोई वैल्यू नहीं मिलती है, तो उसे NULL में बदल दिया जाता है.

आउटपुट ऐरे में एलिमेंट का क्रम स्थिर नहीं होता. इसलिए, इस पर भरोसा नहीं किया जाना चाहिए.

अंकगणित वाले फ़ंक्शन

Cloud Firestore में मौजूद सभी अंकगणितीय फ़ंक्शन, इस तरह काम करते हैं:

  • अगर इनपुट पैरामीटर में से कोई भी NULL है, तो यह फ़ंक्शन NULL दिखाता है.
  • अगर कोई भी आर्ग्युमेंट NaN है, तो यह फ़ंक्शन NaN दिखाता है.
  • अगर ओवरफ़्लो या अंडरफ़्लो होता है, तो यह फ़ंक्शन गड़बड़ी जनरेट करता है.

इसके अलावा, जब कोई अंकगणितीय फ़ंक्शन अलग-अलग टाइप के कई संख्यात्मक आर्ग्युमेंट लेता है (उदाहरण के लिए: add(5.0, 6)), तो Cloud Firestore आर्ग्युमेंट को सबसे बड़े इनपुट टाइप में बदल देता है. अगर सिर्फ़ INT32 इनपुट दिए जाते हैं, तो रिटर्न टाइप INT64 होगा.

नाम ब्यौरा
ABS किसी number की ऐब्सलूट वैल्यू दिखाता है
ADD x + y की वैल्यू दिखाता है
SUBTRACT x - y की वैल्यू दिखाता है
MULTIPLY x * y की वैल्यू दिखाता है
DIVIDE x / y की वैल्यू दिखाता है
MOD x / y को से भाग देने पर मिलने वाला शेषफल दिखाता है
CEIL किसी number की सीलिंग वैल्यू दिखाता है
FLOOR यह फ़ंक्शन, number की फ़्लोर वैल्यू दिखाता है
ROUND number को places दशमलव स्थानों तक पूर्णांक बनाता है
TRUNC यह फ़ंक्शन, number को places दशमलव स्थानों तक काटता है
POW base^exponent की वैल्यू दिखाता है
SQRT number का वर्गमूल दिखाता है
EXP यूलर की संख्या को exponent की घात में बढ़ाता है
LN किसी number का नैचुरल लॉगारिद्म दिखाता है
LOG किसी संख्या का लॉगारिद्म दिखाता है number
LOG10 10 के आधार पर number का लॉगरिद्म दिखाता है
RAND यह फ़ंक्शन, फ़्लोटिंग पॉइंट वाली कोई छद्म-यादृच्छिक संख्या दिखाता है

ABS

सिंटैक्स:

abs[N <: INT32 | INT64 | FLOAT64](number: N) -> N

ब्यौरा:

number की ऐब्सलूट वैल्यू दिखाता है.

  • जब फ़ंक्शन, INT32 या INT64 वैल्यू से ज़्यादा हो जाता है, तब यह गड़बड़ी दिखाता है.

उदाहरण:

नंबर abs(number)
10 10
-10 10
10 लाख 10 लाख
-0.0 0.0
10.5 10.5
-10.5 10.5
-231 [error]
-263 [error]

जोड़ें

सिंटैक्स:

add[N <: INT32 | INT64 | FLOAT64](x: N, y: N) -> N

ब्यौरा:

x + y की वैल्यू दिखाता है.

उदाहरण:

x साल add(x, y)
20 3 23
10.0 1 11.0
22.5 2.0 24.5
INT64.MAX 1 [error]
INT64.MIN -1 [error]
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("soldBooks").add(field("unsoldBooks")).as("totalBooks"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("soldBooks").add(field("unsoldBooks")).as("totalBooks"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("soldBooks").add(Field("unsoldBooks")).as("totalBooks")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(Expression.add(field("soldBooks"), field("unsoldBooks")).alias("totalBooks"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(Expression.add(field("soldBooks"), field("unsoldBooks")).alias("totalBooks"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("soldBooks").add(Field.of("unsoldBooks")).as_("totalBooks"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(add(field("soldBooks"), field("unsoldBooks")).as("totalBooks"))
        .execute()
        .get();
PipelineSnippets.java

SUBTRACT

सिंटैक्स:

subtract[N <: INT32 | INT64 | FLOAT64](x: N, y: N) -> N

ब्यौरा:

x - y की वैल्यू दिखाता है.

उदाहरण:

x साल subtract(x, y)
20 3 17
10.0 1 9.0
22.5 2.0 20.5
INT64.MAX -1 [error]
INT64.MIN 1 [error]
Node.js
const storeCredit = 7;
const result = await db.pipeline()
  .collection("books")
  .select(field("price").subtract(constant(storeCredit)).as("totalCost"))
  .execute();
test.firestore.js

Web

const storeCredit = 7;
const result = await execute(db.pipeline()
  .collection("books")
  .select(field("price").subtract(constant(storeCredit)).as("totalCost"))
);
test.firestore.js
Swift
let storeCredit = 7
let result = try await db.pipeline()
  .collection("books")
  .select([Field("price").subtract(Constant(storeCredit)).as("totalCost")])
  .execute()
PipelineSnippets.swift

Kotlin

val storeCredit = 7
val result = db.pipeline()
    .collection("books")
    .select(Expression.subtract(field("price"), storeCredit).alias("totalCost"))
    .execute()
DocSnippets.kt

Java

int storeCredit = 7;
Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(Expression.subtract(field("price"), storeCredit).alias("totalCost"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

store_credit = 7
result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("price").subtract(store_credit).as_("totalCost"))
    .execute()
)
firestore_pipelines.py
Java
int storeCredit = 7;
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(subtract(field("price"), storeCredit).as("totalCost"))
        .execute()
        .get();
PipelineSnippets.java

MULTIPLY

सिंटैक्स:

multiply[N <: INT32 | INT64 | FLOAT64](x: N, y: N) -> N

ब्यौरा:

x * y की वैल्यू दिखाता है.

उदाहरण:

x साल multiply(x, y)
20 3 60
10.0 1 10.0
22.5 2.0 45.0
INT64.MAX 2 [error]
INT64.MIN 2 [error]
FLOAT64.MAX FLOAT64.MAX +inf
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("price").multiply(field("soldBooks")).as("revenue"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("price").multiply(field("soldBooks")).as("revenue"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("price").multiply(Field("soldBooks")).as("revenue")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(Expression.multiply(field("price"), field("soldBooks")).alias("revenue"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(Expression.multiply(field("price"), field("soldBooks")).alias("revenue"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("price").multiply(Field.of("soldBooks")).as_("revenue"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(multiply(field("price"), field("soldBooks")).as("revenue"))
        .execute()
        .get();
PipelineSnippets.java

DIVIDE

सिंटैक्स:

divide[N <: INT32 | INT64 | FLOAT64](x: N, y: N) -> N

ब्यौरा:

x / y की वैल्यू दिखाता है. पूर्णांक भाग को छोटा कर दिया जाता है.

उदाहरण:

x साल divide(x, y)
20 3 6
10.0 3 3.333...
22.5 2 11.25
10 0 [error]
1.0 0.0 +inf
-1.0 0.0 -inf
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("ratings").divide(field("soldBooks")).as("reviewRate"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("ratings").divide(field("soldBooks")).as("reviewRate"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("ratings").divide(Field("soldBooks")).as("reviewRate")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(Expression.divide(field("ratings"), field("soldBooks")).alias("reviewRate"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(Expression.divide(field("ratings"), field("soldBooks")).alias("reviewRate"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("ratings").divide(Field.of("soldBooks")).as_("reviewRate"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(divide(field("ratings"), field("soldBooks")).as("reviewRate"))
        .execute()
        .get();
PipelineSnippets.java

MOD

सिंटैक्स:

mod[N <: INT32 | INT64 | FLOAT64](x: N, y: N) -> N

ब्यौरा:

x / y का शेषफल दिखाता है.

  • पूर्णांक टाइप (INT64) के लिए, y के शून्य होने पर error दिखाता है.
  • फ़्लोट टाइप (FLOAT64) के लिए NaN शून्य होने पर, NaN दिखाता है.y

उदाहरण:

x साल mod(x, y)
20 3 2
-10 3 -1
10 -3 1
-10 -3 -1
10 1 0
22.5 2 0.5
22.5 0.0 NaN
25 0 [error]
Node.js
const displayCapacity = 1000;
const result = await db.pipeline()
  .collection("books")
  .select(field("unsoldBooks").mod(constant(displayCapacity)).as("warehousedBooks"))
  .execute();
test.firestore.js

Web

const displayCapacity = 1000;
const result = await execute(db.pipeline()
  .collection("books")
  .select(field("unsoldBooks").mod(constant(displayCapacity)).as("warehousedBooks"))
);
test.firestore.js
Swift
let displayCapacity = 1000
let result = try await db.pipeline()
  .collection("books")
  .select([Field("unsoldBooks").mod(Constant(displayCapacity)).as("warehousedBooks")])
  .execute()
PipelineSnippets.swift

Kotlin

val displayCapacity = 1000
val result = db.pipeline()
    .collection("books")
    .select(Expression.mod(field("unsoldBooks"), displayCapacity).alias("warehousedBooks"))
    .execute()
DocSnippets.kt

Java

int displayCapacity = 1000;
Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(Expression.mod(field("unsoldBooks"), displayCapacity).alias("warehousedBooks"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

display_capacity = 1000
result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("unsoldBooks").mod(display_capacity).as_("warehousedBooks"))
    .execute()
)
firestore_pipelines.py
Java
int displayCapacity = 1000;
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(mod(field("unsoldBooks"), displayCapacity).as("warehousedBooks"))
        .execute()
        .get();
PipelineSnippets.java

CEIL

सिंटैक्स:

ceil[N <: INT32 | INT64 | FLOAT64](number: N) -> N

ब्यौरा:

यह फ़ंक्शन, सबसे छोटी पूर्णांक वैल्यू दिखाता है जो number से कम नहीं है.

उदाहरण:

नंबर ceil(number)
20 20
10 10
0 0
24L 24L
-0.4 -0.0
0.4 1.0
22.5 23.0
+inf +inf
-inf -inf
Node.js
const booksPerShelf = 100;
const result = await db.pipeline()
  .collection("books")
  .select(
    field("unsoldBooks").divide(constant(booksPerShelf)).ceil().as("requiredShelves")
  )
  .execute();
test.firestore.js

Web

const booksPerShelf = 100;
const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("unsoldBooks").divide(constant(booksPerShelf)).ceil().as("requiredShelves")
  )
);
test.firestore.js
Swift
let booksPerShelf = 100
let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("unsoldBooks").divide(Constant(booksPerShelf)).ceil().as("requiredShelves")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val booksPerShelf = 100
val result = db.pipeline()
    .collection("books")
    .select(
        Expression.divide(field("unsoldBooks"), booksPerShelf).ceil().alias("requiredShelves")
    )
    .execute()
DocSnippets.kt

Java

int booksPerShelf = 100;
Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        Expression.divide(field("unsoldBooks"), booksPerShelf).ceil().alias("requiredShelves")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

books_per_shelf = 100
result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("unsoldBooks")
        .divide(books_per_shelf)
        .ceil()
        .as_("requiredShelves")
    )
    .execute()
)
firestore_pipelines.py
Java
int booksPerShelf = 100;
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(ceil(divide(field("unsoldBooks"), booksPerShelf)).as("requiredShelves"))
        .execute()
        .get();
PipelineSnippets.java

FLOOR

सिंटैक्स:

floor[N <: INT32 | INT64 | FLOAT64](number: N) -> N

ब्यौरा:

यह फ़ंक्शन, सबसे बड़ी पूर्णांक वैल्यू दिखाता है जो number से ज़्यादा नहीं है.

उदाहरण:

नंबर floor(number)
20 20
10 10
0 0
2147483648 2147483648
-0.4 -1.0
0.4 0.0
22.5 22.0
+inf +inf
-inf -inf
Node.js
const result = await db.pipeline()
  .collection("books")
  .addFields(
    field("wordCount").divide(field("pages")).floor().as("wordsPerPage")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .addFields(
    field("wordCount").divide(field("pages")).floor().as("wordsPerPage")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .addFields([
    Field("wordCount").divide(Field("pages")).floor().as("wordsPerPage")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .addFields(
        Expression.divide(field("wordCount"), field("pages")).floor().alias("wordsPerPage")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .addFields(
        Expression.divide(field("wordCount"), field("pages")).floor().alias("wordsPerPage")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .add_fields(
        Field.of("wordCount").divide(Field.of("pages")).floor().as_("wordsPerPage")
    )
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .addFields(floor(divide(field("wordCount"), field("pages"))).as("wordsPerPage"))
        .execute()
        .get();
PipelineSnippets.java

ROUND

सिंटैक्स:

round[N <: INT32 | INT64 | FLOAT64 | DECIMAL128](number: N) -> N
round[N <: INT32 | INT64 | FLOAT64 | DECIMAL128](number: N, places: INT64) -> N

ब्यौरा:

number में से places अंकों को राउंड करता है. अगर places धनात्मक है, तो दशमलव बिंदु के दाईं ओर के अंकों को पूर्णांक में बदलता है. अगर यह ऋणात्मक है, तो दशमलव बिंदु के बाईं ओर के अंकों को पूर्णांक में बदलता है.

  • अगर सिर्फ़ number दिया गया है, तो यह फ़ंक्शन वैल्यू को निकटतम पूर्णांक में बदल देता है.
  • यह फ़ंक्शन, बीच की वैल्यू को शून्य से दूर वाली पूर्णांक संख्या में बदलता है.
  • अगर नेगेटिव places वैल्यू का इस्तेमाल करके राउंड करने पर ओवरफ़्लो होता है, तो error थ्रो किया जाता है.

उदाहरण:

नंबर स्थान round(number, places)
15.5 0 16.0
-15.5 0 -16.0
15 1 15
15 0 15
15 -1 20
15 -2 0
15.48924 1 15.5
231-1 -1 [error]
263-1L -1 [error]
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("soldBooks").multiply(field("price")).round().as("partialRevenue"))
  .aggregate(field("partialRevenue").sum().as("totalRevenue"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("soldBooks").multiply(field("price")).round().as("partialRevenue"))
  .aggregate(field("partialRevenue").sum().as("totalRevenue"))
  );
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("soldBooks").multiply(Field("price")).round().as("partialRevenue")])
  .aggregate([Field("partialRevenue").sum().as("totalRevenue")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(Expression.multiply(field("soldBooks"), field("price")).round().alias("partialRevenue"))
    .aggregate(AggregateFunction.sum("partialRevenue").alias("totalRevenue"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(Expression.multiply(field("soldBooks"), field("price")).round().alias("partialRevenue"))
    .aggregate(AggregateFunction.sum("partialRevenue").alias("totalRevenue"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("soldBooks")
        .multiply(Field.of("price"))
        .round()
        .as_("partialRevenue")
    )
    .aggregate(Field.of("partialRevenue").sum().as_("totalRevenue"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(round(multiply(field("soldBooks"), field("price"))).as("partialRevenue"))
        .aggregate(sum("partialRevenue").as("totalRevenue"))
        .execute()
        .get();
PipelineSnippets.java

TRUNC

सिंटैक्स:

trunc[N <: Number](number: N) -> N
trunc[N <: Number](number:  N, places: INT64) -> N

ब्यौरा:

number को places दशमलव स्थानों की तय संख्या तक काट-छांट करता है. अगर places धनात्मक है, तो दशमलव बिंदु के दाईं ओर के अंकों को काटता है. अगर यह ऋणात्मक है, तो दशमलव बिंदु के बाईं ओर के अंकों को काटता है.

  • अगर सिर्फ़ number दिया गया है, तो यह फ़ंक्शन, वैल्यू को शून्य की ओर ले जाकर सबसे नज़दीकी पूर्णांक में बदल देता है.
  • अगर नतीजे छोटे करने पर भी ओवरफ़्लो होता है, तो error दिखता है.

उदाहरण:

नंबर स्थान trunc(number, places)
15.5 0 15.0
-15.5 0 -15.0
15 1 15
15 0 15
15 -1 10
15 -2 0
15.48924 1 15.4
-15.48924 2 -15.48

POW

सिंटैक्स:

pow(base: FLOAT64, exponent: FLOAT64) -> FLOAT64

ब्यौरा:

base की पावर exponent की वैल्यू दिखाता है.

  • अगर base <= 0 और exponent नेगेटिव है, तो गड़बड़ी का मैसेज दिखाता है.

  • किसी भी exponent के लिए, pow(1, exponent) की वैल्यू 1 होती है.

  • किसी भी base के लिए, pow(base, 0) की वैल्यू 1 होती है.

उदाहरण:

बेस घातांक pow(base, exponent)
2 3 8.0
2 -3 0.125
+inf 0 1.0
1 +inf 1.0
-1 0.5 [error]
0 -1 [error]
Node.js
const googleplex = { latitude: 37.4221, longitude: 122.0853 };
const result = await db.pipeline()
  .collection("cities")
  .addFields(
    field("lat").subtract(constant(googleplex.latitude))
      .multiply(111 /* km per degree */)
      .pow(2)
      .as("latitudeDifference"),
    field("lng").subtract(constant(googleplex.longitude))
      .multiply(111 /* km per degree */)
      .pow(2)
      .as("longitudeDifference")
  )
  .select(
    field("latitudeDifference").add(field("longitudeDifference")).sqrt()
      // Inaccurate for large distances or close to poles
      .as("approximateDistanceToGoogle")
  )
  .execute();
test.firestore.js

Web

const googleplex = { latitude: 37.4221, longitude: 122.0853 };
const result = await execute(db.pipeline()
  .collection("cities")
  .addFields(
    field("lat").subtract(constant(googleplex.latitude))
      .multiply(111 /* km per degree */)
      .pow(2)
      .as("latitudeDifference"),
    field("lng").subtract(constant(googleplex.longitude))
      .multiply(111 /* km per degree */)
      .pow(2)
      .as("longitudeDifference")
  )
  .select(
    field("latitudeDifference").add(field("longitudeDifference")).sqrt()
      // Inaccurate for large distances or close to poles
      .as("approximateDistanceToGoogle")
  )
);
test.firestore.js
Swift
let googleplex = CLLocation(latitude: 37.4221, longitude: 122.0853)
let result = try await db.pipeline()
  .collection("cities")
  .addFields([
    Field("lat").subtract(Constant(googleplex.coordinate.latitude))
      .multiply(111 /* km per degree */)
      .pow(2)
      .as("latitudeDifference"),
    Field("lng").subtract(Constant(googleplex.coordinate.latitude))
      .multiply(111 /* km per degree */)
      .pow(2)
      .as("longitudeDifference")
  ])
  .select([
    Field("latitudeDifference").add(Field("longitudeDifference")).sqrt()
      // Inaccurate for large distances or close to poles
      .as("approximateDistanceToGoogle")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val googleplex = GeoPoint(37.4221, -122.0853)
val result = db.pipeline()
    .collection("cities")
    .addFields(
        field("lat").subtract(googleplex.latitude)
            .multiply(111 /* km per degree */)
            .pow(2)
            .alias("latitudeDifference"),
        field("lng").subtract(googleplex.longitude)
            .multiply(111 /* km per degree */)
            .pow(2)
            .alias("longitudeDifference")
    )
    .select(
        field("latitudeDifference").add(field("longitudeDifference")).sqrt()
            // Inaccurate for large distances or close to poles
            .alias("approximateDistanceToGoogle")
    )
    .execute()
DocSnippets.kt

Java

GeoPoint googleplex = new GeoPoint(37.4221, -122.0853);
Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("cities")
    .addFields(
        field("lat").subtract(googleplex.getLatitude())
            .multiply(111 /* km per degree */)
            .pow(2)
            .alias("latitudeDifference"),
        field("lng").subtract(googleplex.getLongitude())
            .multiply(111 /* km per degree */)
            .pow(2)
            .alias("longitudeDifference")
    )
    .select(
        field("latitudeDifference").add(field("longitudeDifference")).sqrt()
            // Inaccurate for large distances or close to poles
            .alias("approximateDistanceToGoogle")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

googleplexLat = 37.4221
googleplexLng = -122.0853
result = (
    client.pipeline()
    .collection("cities")
    .add_fields(
        Field.of("lat")
        .subtract(googleplexLat)
        .multiply(111)  # km per degree
        .pow(2)
        .as_("latitudeDifference"),
        Field.of("lng")
        .subtract(googleplexLng)
        .multiply(111)  # km per degree
        .pow(2)
        .as_("longitudeDifference"),
    )
    .select(
        Field.of("latitudeDifference")
        .add(Field.of("longitudeDifference"))
        .sqrt()
        # Inaccurate for large distances or close to poles
        .as_("approximateDistanceToGoogle")
    )
    .execute()
)
firestore_pipelines.py
Java
double googleplexLat = 37.4221;
double googleplexLng = -122.0853;
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("cities")
        .addFields(
            pow(multiply(subtract(field("lat"), googleplexLat), 111), 2)
                .as("latitudeDifference"),
            pow(multiply(subtract(field("lng"), googleplexLng), 111), 2)
                .as("longitudeDifference"))
        .select(
            sqrt(add(field("latitudeDifference"), field("longitudeDifference")))
                // Inaccurate for large distances or close to poles
                .as("approximateDistanceToGoogle"))
        .execute()
        .get();
PipelineSnippets.java

SQRT

सिंटैक्स:

sqrt[N <: FLOAT64 | DECIMAL128](number: N) -> N

ब्यौरा:

number का वर्गमूल दिखाता है.

  • अगर number की वैल्यू नेगेटिव है, तो यह फ़ंक्शन error दिखाता है.

उदाहरण:

नंबर sqrt(number)
25 5.0
12.002 3.464...
0.0 0.0
NaN NaN
+inf +inf
-inf [error]
x < 0 [error]
Node.js
const googleplex = { latitude: 37.4221, longitude: 122.0853 };
const result = await db.pipeline()
  .collection("cities")
  .addFields(
    field("lat").subtract(constant(googleplex.latitude))
      .multiply(111 /* km per degree */)
      .pow(2)
      .as("latitudeDifference"),
    field("lng").subtract(constant(googleplex.longitude))
      .multiply(111 /* km per degree */)
      .pow(2)
      .as("longitudeDifference")
  )
  .select(
    field("latitudeDifference").add(field("longitudeDifference")).sqrt()
      // Inaccurate for large distances or close to poles
      .as("approximateDistanceToGoogle")
  )
  .execute();
test.firestore.js

Web

const googleplex = { latitude: 37.4221, longitude: 122.0853 };
const result = await execute(db.pipeline()
  .collection("cities")
  .addFields(
    field("lat").subtract(constant(googleplex.latitude))
      .multiply(111 /* km per degree */)
      .pow(2)
      .as("latitudeDifference"),
    field("lng").subtract(constant(googleplex.longitude))
      .multiply(111 /* km per degree */)
      .pow(2)
      .as("longitudeDifference")
  )
  .select(
    field("latitudeDifference").add(field("longitudeDifference")).sqrt()
      // Inaccurate for large distances or close to poles
      .as("approximateDistanceToGoogle")
  )
);
test.firestore.js
Swift
let googleplex = CLLocation(latitude: 37.4221, longitude: 122.0853)
let result = try await db.pipeline()
  .collection("cities")
  .addFields([
    Field("lat").subtract(Constant(googleplex.coordinate.latitude))
      .multiply(111 /* km per degree */)
      .pow(2)
      .as("latitudeDifference"),
    Field("lng").subtract(Constant(googleplex.coordinate.latitude))
      .multiply(111 /* km per degree */)
      .pow(2)
      .as("longitudeDifference")
  ])
  .select([
    Field("latitudeDifference").add(Field("longitudeDifference")).sqrt()
      // Inaccurate for large distances or close to poles
      .as("approximateDistanceToGoogle")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val googleplex = GeoPoint(37.4221, -122.0853)
val result = db.pipeline()
    .collection("cities")
    .addFields(
        field("lat").subtract(googleplex.latitude)
            .multiply(111 /* km per degree */)
            .pow(2)
            .alias("latitudeDifference"),
        field("lng").subtract(googleplex.longitude)
            .multiply(111 /* km per degree */)
            .pow(2)
            .alias("longitudeDifference")
    )
    .select(
        field("latitudeDifference").add(field("longitudeDifference")).sqrt()
            // Inaccurate for large distances or close to poles
            .alias("approximateDistanceToGoogle")
    )
    .execute()
DocSnippets.kt

Java

GeoPoint googleplex = new GeoPoint(37.4221, -122.0853);
Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("cities")
    .addFields(
        field("lat").subtract(googleplex.getLatitude())
            .multiply(111 /* km per degree */)
            .pow(2)
            .alias("latitudeDifference"),
        field("lng").subtract(googleplex.getLongitude())
            .multiply(111 /* km per degree */)
            .pow(2)
            .alias("longitudeDifference")
    )
    .select(
        field("latitudeDifference").add(field("longitudeDifference")).sqrt()
            // Inaccurate for large distances or close to poles
            .alias("approximateDistanceToGoogle")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

googleplexLat = 37.4221
googleplexLng = -122.0853
result = (
    client.pipeline()
    .collection("cities")
    .add_fields(
        Field.of("lat")
        .subtract(googleplexLat)
        .multiply(111)  # km per degree
        .pow(2)
        .as_("latitudeDifference"),
        Field.of("lng")
        .subtract(googleplexLng)
        .multiply(111)  # km per degree
        .pow(2)
        .as_("longitudeDifference"),
    )
    .select(
        Field.of("latitudeDifference")
        .add(Field.of("longitudeDifference"))
        .sqrt()
        # Inaccurate for large distances or close to poles
        .as_("approximateDistanceToGoogle")
    )
    .execute()
)
firestore_pipelines.py
Java
double googleplexLat = 37.4221;
double googleplexLng = -122.0853;
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("cities")
        .addFields(
            pow(multiply(subtract(field("lat"), googleplexLat), 111), 2)
                .as("latitudeDifference"),
            pow(multiply(subtract(field("lng"), googleplexLng), 111), 2)
                .as("longitudeDifference"))
        .select(
            sqrt(add(field("latitudeDifference"), field("longitudeDifference")))
                // Inaccurate for large distances or close to poles
                .as("approximateDistanceToGoogle"))
        .execute()
        .get();
PipelineSnippets.java

EXP

सिंटैक्स:

exp(exponent: FLOAT64) -> FLOAT64

ब्यौरा:

यूलर की संख्या की घात exponent का मान दिखाता है. इसे नैचुरल एक्सपोनेंशियल फ़ंक्शन भी कहा जाता है.

उदाहरण:

घातांक exp(exponent)
0.0 1.0
10 e^10 (FLOAT64)
+inf +inf
-inf 0
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("rating").exp().as("expRating"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("rating").exp().as("expRating"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("rating").exp().as("expRating")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(field("rating").exp().alias("expRating"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("rating").exp().alias("expRating"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("rating").exp().as_("expRating"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(exp(field("rating")).as("expRating"))
        .execute()
        .get();
PipelineSnippets.java

LN

सिंटैक्स:

ln(number: FLOAT64) -> FLOAT64

ब्यौरा:

number का नैचुरल लॉगारिद्म दिखाता है. यह फ़ंक्शन log(number) के बराबर होता है.

उदाहरण:

नंबर ln(number)
1 0.0
2L 0.693...
1.0 0.0
e (FLOAT64) 1.0
-inf NaN
+inf +inf
x <= 0 [error]
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("rating").ln().as("lnRating"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("rating").ln().as("lnRating"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("rating").ln().as("lnRating")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(field("rating").ln().alias("lnRating"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("rating").ln().alias("lnRating"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("rating").ln().as_("lnRating"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(ln(field("rating")).as("lnRating"))
        .execute()
        .get();
PipelineSnippets.java

LOG

सिंटैक्स:

log(number: FLOAT64, base: FLOAT64) -> FLOAT64
log(number: FLOAT64) -> FLOAT64

ब्यौरा:

base के हिसाब से number का लॉगारिद्म दिखाता है.

  • अगर सिर्फ़ number दिया गया है, तो base के आधार पर number का लॉगारिद्म दिखाता है. यह ln(number) के बराबर होता है.

उदाहरण:

नंबर बेस log(number, base)
100 10 2.0
-inf Numeric NaN
Numeric. +inf NaN
number <= 0 Numeric [error]
Numeric base <= 0 [error]
Numeric 1.0 [error]

LOG10

सिंटैक्स:

log10(x: FLOAT64) -> FLOAT64

ब्यौरा:

10 के आधार पर number का लॉगारिद्म दिखाता है.

उदाहरण:

नंबर log10(number)
100 2.0
-inf NaN
+inf +inf
x <= 0 [error]

RAND

सिंटैक्स:

rand() -> FLOAT64

ब्यौरा:

यह फ़ंक्शन, 0.0 (शामिल) और 1.0 (शामिल नहीं) के बीच का कोई फ़्लोटिंग पॉइंट नंबर दिखाता है. यह नंबर, छद्म-यादृच्छिक तरीके से चुना जाता है.

ऐरे फ़ंक्शन

नाम ब्यौरा
ARRAY यह एक ARRAY दिखाता है. इसमें हर इनपुट आर्ग्युमेंट के लिए एक एलिमेंट होता है
ARRAY_CONCAT यह फ़ंक्शन, एक से ज़्यादा ऐरे को एक ही ARRAY में जोड़ता है
ARRAY_CONTAINS अगर दिए गए ARRAY में कोई वैल्यू मौजूद है, तो TRUE दिखाता है
ARRAY_CONTAINS_ALL अगर सभी वैल्यू ARRAY में मौजूद हैं, तो TRUE दिखाता है
ARRAY_CONTAINS_ANY अगर ARRAY में कोई भी वैल्यू मौजूद है, तो TRUE दिखाता है
ARRAY_FILTER यह फ़ंक्शन, ARRAY से उन एलिमेंट को हटा देता है जो किसी शर्त को पूरा नहीं करते
ARRAY_FIRST किसी ARRAY में मौजूद पहला एलिमेंट दिखाता है
ARRAY_FIRST_N किसी ARRAY में मौजूद पहले n एलिमेंट दिखाता है
ARRAY_GET ARRAY में मौजूद किसी इंडेक्स पर मौजूद एलिमेंट दिखाता है
ARRAY_INDEX_OF इस फ़ंक्शन से, ARRAY में किसी वैल्यू की पहली बार दिखने का इंडेक्स मिलता है
ARRAY_INDEX_OF_ALL ARRAY में किसी वैल्यू के सभी इंडेक्स दिखाता है
ARRAY_LENGTH यह फ़ंक्शन, ARRAY में मौजूद एलिमेंट की संख्या दिखाता है
ARRAY_LAST यह फ़ंक्शन, ARRAY में मौजूद आखिरी एलिमेंट दिखाता है
ARRAY_LAST_N यह फ़ंक्शन, ARRAY में मौजूद आखिरी n एलिमेंट दिखाता है
ARRAY_REVERSE यह फ़ंक्शन, ARRAY में मौजूद एलिमेंट का क्रम उलट देता है
ARRAY_SLICE ARRAY का स्लाइस दिखाता है
ARRAY_TRANSFORM यह ARRAY में मौजूद एलिमेंट में बदलाव करता है. इसके लिए, हर एलिमेंट पर एक्सप्रेशन लागू किया जाता है
MAXIMUM ARRAY एट्रिब्यूट की सबसे बड़ी वैल्यू दिखाता है
MAXIMUM_N ARRAY में मौजूद n सबसे बड़ी वैल्यू दिखाता है
MINIMUM ARRAY में मौजूद सबसे छोटी वैल्यू दिखाता है
MINIMUM_N n में मौजूद सबसे छोटी वैल्यू दिखाता है ARRAY
SUM यह ARRAY में मौजूद सभी NUMERIC वैल्यू का योग दिखाता है.
JOIN यह ARRAY में मौजूद एलिमेंट को जोड़कर, STRING वैल्यू बनाता है.

ARRAY

सिंटैक्स:

array(values: ANY...) -> ARRAY

ब्यौरा:

यह दिए गए एलिमेंट से एक अरे बनाता है.

  • अगर कोई आर्ग्युमेंट मौजूद नहीं है, तो नतीजे के तौर पर मिले ऐरे में उसे NULL से बदल दिया जाता है.

उदाहरण:

वैल्यू array(values)
() []
(1, 2, 3) [1, 2, 3]
("a", 1, true) ["a", 1, true]
(1, null) [1, null]
(1, [2, 3]) [1, [2, 3]]

ARRAY_CONCAT

सिंटैक्स:

array_concat(arrays: ARRAY...) -> ARRAY

ब्यौरा:

यह फ़ंक्शन, दो या उससे ज़्यादा अरे को एक ही ARRAY में जोड़ता है.

उदाहरण:

ऐरे array_concat(arrays)
([1, 2], [3, 4]) [1, 2, 3, 4]
(["a", "b"], ["c"]) ["a", "b", "c"]
([1], [2], [3]) [1, 2, 3]
([], [1, 2]) [1, 2]
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("genre").arrayConcat([field("subGenre")]).as("allGenres"))
  .execute();
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("genre").arrayConcat([Field("subGenre")]).as("allGenres")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(field("genre").arrayConcat(field("subGenre")).alias("allGenres"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("genre").arrayConcat(field("subGenre")).alias("allGenres"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("genre").array_concat(Field.of("subGenre")).as_("allGenres"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(arrayConcat(field("genre"), field("subGenre")).as("allGenres"))
        .execute()
        .get();
PipelineSnippets.java

ARRAY_CONTAINS

सिंटैक्स:

array_contains(array: ARRAY, value: ANY) -> BOOLEAN

ब्यौरा:

अगर array में value मौजूद है, तो TRUE दिखाता है. ऐसा न होने पर, FALSE दिखाता है.

उदाहरण:

कलेक्शन value array_contains(array, value)
[1, 2, 3] 2 सही
[[1, 2], [3]] [1, 2] सही
[1, null] शून्य सही
"abc" कोई भी गड़बड़ी
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("genre").arrayContains(constant("mystery")).as("isMystery"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("genre").arrayContains(constant("mystery")).as("isMystery"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("genre").arrayContains(Constant("mystery")).as("isMystery")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(field("genre").arrayContains("mystery").alias("isMystery"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("genre").arrayContains("mystery").alias("isMystery"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("genre").array_contains("mystery").as_("isMystery"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(arrayContains(field("genre"), "mystery").as("isMystery"))
        .execute()
        .get();
PipelineSnippets.java

ARRAY_CONTAINS_ALL

सिंटैक्स:

array_contains_all(array: ARRAY, search_values: ARRAY) -> BOOLEAN

ब्यौरा:

अगर सभी search_values, array में मौजूद हैं, तो TRUE दिखाता है. ऐसा न होने पर, FALSE दिखाता है.

उदाहरण:

कलेक्शन search_values array_contains_all(array, search_values)
[1, 2, 3] [1, 2] सही
[1, 2, 3] [1, 4] गलत
[1, null] [अमान्य] सही
[NaN] [NaN] सही
[] [] सही
[1, 2, 3] [] सही
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(
    field("genre")
      .arrayContainsAll([constant("fantasy"), constant("adventure")])
      .as("isFantasyAdventure")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("genre")
      .arrayContainsAll([constant("fantasy"), constant("adventure")])
      .as("isFantasyAdventure")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("genre")
      .arrayContainsAll([Constant("fantasy"), Constant("adventure")])
      .as("isFantasyAdventure")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        field("genre")
            .arrayContainsAll(listOf("fantasy", "adventure"))
            .alias("isFantasyAdventure")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("genre")
            .arrayContainsAll(Arrays.asList("fantasy", "adventure"))
            .alias("isFantasyAdventure")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("genre")
        .array_contains_all(["fantasy", "adventure"])
        .as_("isFantasyAdventure")
    )
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            arrayContainsAll(field("genre"), Arrays.asList("fantasy", "adventure"))
                .as("isFantasyAdventure"))
        .execute()
        .get();
PipelineSnippets.java

ARRAY_CONTAINS_ANY

सिंटैक्स:

array_contains_any(array: ARRAY, search_values: ARRAY) -> BOOLEAN

ब्यौरा:

अगर search_values में से कोई भी वैल्यू array में मिलती है, तो यह फ़ंक्शन TRUE दिखाता है. ऐसा न होने पर, यह FALSE दिखाता है.

उदाहरण:

कलेक्शन search_values array_contains_any(array, search_values)
[1, 2, 3] [4, 1] सही
[1, 2, 3] [4, 5] गलत
[1, 2, null] [अमान्य] सही
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(
    field("genre")
      .arrayContainsAny([constant("fantasy"), constant("nonfiction")])
      .as("isMysteryOrFantasy")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("genre")
      .arrayContainsAny([constant("fantasy"), constant("nonfiction")])
      .as("isMysteryOrFantasy")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("genre")
      .arrayContainsAny([Constant("fantasy"), Constant("nonfiction")])
      .as("isMysteryOrFantasy")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        field("genre")
            .arrayContainsAny(listOf("fantasy", "nonfiction"))
            .alias("isMysteryOrFantasy")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("genre")
            .arrayContainsAny(Arrays.asList("fantasy", "nonfiction"))
            .alias("isMysteryOrFantasy")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("genre")
        .array_contains_any(["fantasy", "nonfiction"])
        .as_("isMysteryOrFantasy")
    )
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            arrayContainsAny(field("genre"), Arrays.asList("fantasy", "nonfiction"))
                .as("isMysteryOrFantasy"))
        .execute()
        .get();
PipelineSnippets.java

ARRAY_FILTER

सिंटैक्स:

array_filter(array: ARRAY, predicate: (ANY) -> BOOLEAN) -> ARRAY

ब्यौरा:

predicate एक्सप्रेशन का इस्तेमाल करके, array को फ़िल्टर करता है. साथ ही, सिर्फ़ उन एलिमेंट के साथ एक नई अरे दिखाता है जो प्रेडिकेट को पूरा करते हैं.

  • array में मौजूद हर एलिमेंट के लिए, predicate का आकलन किया जाता है. अगर यह true दिखाता है, तो एलिमेंट को नतीजे में शामिल किया जाता है. अगर यह false या null दिखाता है, तो इसे शामिल नहीं किया जाता.
  • अगर predicate की वैल्यू, बूलियन या शून्य नहीं है, तो फ़ंक्शन एक गड़बड़ी दिखाता है.

उदाहरण:

कलेक्शन प्रीडिकेट array_filter(array, predicate)
[1, 2, 3] x -> x > 1 [2, 3]
[1, null, 3] x -> x > 1 [3]
["a", "b", "c"] x -> x != "b" ["a", "c"]
[] x -> true []

ARRAY_GET

सिंटैक्स:

array_get(array: ARRAY, index: INT64) -> ANY

ब्यौरा:

यह array में मौजूद, शून्य पर आधारित इंडेक्स index पर मौजूद एलिमेंट दिखाता है.

  • अगर index की वैल्यू नेगेटिव है, तो ऐरे के आखिर से एलिमेंट ऐक्सेस किए जाते हैं. इसमें -1 आखिरी एलिमेंट होता है.
  • अगर array, ARRAY टाइप का नहीं है और null नहीं है, तो गड़बड़ी दिखाता है.
  • अगर index तय सीमा से बाहर है, तो फ़ंक्शन 'मौजूद नहीं है' वैल्यू दिखाता है.
  • अगर index, INT64 टाइप का नहीं है, तो फ़ंक्शन गड़बड़ी दिखाता है.

उदाहरण:

कलेक्शन इंडेक्स array_get(array, index)
[1, 2, 3] 0 1
[1, 2, 3] -1 3
[1, 2, 3] 3 अनुपस्थित
[1, 2, 3] -4 अनुपस्थित
"abc" 0 गड़बड़ी
शून्य 0 शून्य
Array "a" गड़बड़ी
Array 2.0 गड़बड़ी

ARRAY_LENGTH

सिंटैक्स:

array_length(array: ARRAY) -> INT64

ब्यौरा:

array में मौजूद एलिमेंट की संख्या दिखाता है.

उदाहरण:

कलेक्शन array_length(array)
[1, 2, 3] 3
[] 0
[1, 1, 1] 3
[1, null] 2
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("genre").arrayLength().as("genreCount"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("genre").arrayLength().as("genreCount"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("genre").arrayLength().as("genreCount")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(field("genre").arrayLength().alias("genreCount"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("genre").arrayLength().alias("genreCount"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("genre").array_length().as_("genreCount"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(arrayLength(field("genre")).as("genreCount"))
        .execute()
        .get();
PipelineSnippets.java

ARRAY_REVERSE

सिंटैक्स:

array_reverse(array: ARRAY) -> ARRAY

ब्यौरा:

यह दिए गए array को उलट देता है.

उदाहरण:

कलेक्शन array_reverse(array)
[1, 2, 3] [3, 2, 1]
["a", "b"] ["b", "a"]
[1, 2, 2, 3] [3, 2, 2, 1]
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(arrayReverse(field("genre")).as("reversedGenres"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("genre").arrayReverse().as("reversedGenres"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("genre").arrayReverse().as("reversedGenres")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(field("genre").arrayReverse().alias("reversedGenres"))
    .execute()
DocSnippets.kt
 
    
Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("genre").arrayReverse().alias("reversedGenres"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("genre").array_reverse().as_("reversedGenres"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(arrayReverse(field("genre")).as("reversedGenres"))
        .execute()
        .get();
PipelineSnippets.java

ARRAY_FIRST

सिंटैक्स:

array_first(array: ARRAY) -> ANY

ब्यौरा:

array में मौजूद पहला एलिमेंट दिखाता है. यह array_get(array, 0) के बराबर है.

  • अगर array खाली है, तो 'मौजूद नहीं है' वैल्यू दिखाता है.

उदाहरण:

कलेक्शन array_first(array)
[1, 2, 3] 1
[] अनुपस्थित

ARRAY_FIRST_N

सिंटैक्स:

array_first_n(array: ARRAY, n: INT64) -> ARRAY

ब्यौरा:

array के पहले n एलिमेंट दिखाता है. यह array_slice(array, 0, n) के बराबर है.

  • अगर n नेगेटिव है, तो गड़बड़ी का मैसेज दिखता है.

उदाहरण:

कलेक्शन n array_first_n(array, n)
[1, 2, 3, 4, 5] 3 [1, 2, 3]
[1, 2] 3 [1, 2]
[1, 2, 3] 0 []

ARRAY_INDEX_OF

सिंटैक्स:

array_index_of(array: ARRAY, value: ANY) -> INT64

ब्यौरा:

array में value के पहले इंस्टेंस का इंडेक्स दिखाता है. यह इंडेक्स 0 से शुरू होता है. अगर value नहीं मिलता है, तो -1 दिखाता है.

उदाहरण:

कलेक्शन value array_index_of(array, value)
[1, 2, 3, 2] 2 1
[1, 2, 3] 4 -1
[1, null, 3] शून्य 1

ARRAY_INDEX_OF_ALL

सिंटैक्स:

array_index_of_all(array: ARRAY, value: ANY) -> ARRAY<INT64>

ब्यौरा:

यह फ़ंक्शन, एक कैटगरी दिखाता है. इसमें array में मौजूद value की सभी घटनाओं के इंडेक्स होते हैं. ये इंडेक्स, 0 से शुरू होते हैं. अगर value नहीं मिलता है, तो [] दिखाता है.

उदाहरण:

कलेक्शन value array_index_of_all(array, value)
[1, 2, 3, 2] 2 [1, 3]
[1, 2, 3] 4 []
[1, null, 3, null] शून्य [1, 3]

ARRAY_LAST

सिंटैक्स:

array_last(array: ARRAY) -> ANY

ब्यौरा:

array में मौजूद आखिरी एलिमेंट दिखाता है. यह array_get(array, -1) के बराबर है.

  • अगर array खाली है, तो 'मौजूद नहीं है' वैल्यू दिखाता है.

उदाहरण:

कलेक्शन array_last(array)
[1, 2, 3] 3
[] अनुपस्थित

ARRAY_LAST_N

सिंटैक्स:

array_last_n(array: ARRAY, n: INT64) -> ARRAY

ब्यौरा:

यह फ़ंक्शन, n के आखिरी n एलिमेंट दिखाता है.array

  • अगर n नेगेटिव है, तो गड़बड़ी का मैसेज दिखता है.

उदाहरण:

कलेक्शन n array_last_n(array, n)
[1, 2, 3, 4, 5] 3 [3, 4, 5]
[1, 2] 3 [1, 2]
[1, 2, 3] 0 []

ARRAY_SLICE

सिंटैक्स:

array_slice(array: ARRAY, offset: INT64, length: INT64) -> ARRAY

ब्यौरा:

यह फ़ंक्शन, array का सबसेट दिखाता है. यह 0 पर आधारित इंडेक्स offset से शुरू होता है और इसमें length एलिमेंट शामिल होते हैं.

  • अगर offset नेगेटिव है, तो इससे पता चलता है कि ऐरे के आखिर से शुरू होने वाली पोज़िशन, -1 है.
  • अगर length की वैल्यू, offset के बाद ऐरे में बचे हुए एलिमेंट की संख्या से ज़्यादा है, तो नतीजा ऐरे के आखिर तक दिखता है.
  • length की वैल्यू, ज़ीरो (शून्य) से कम नहीं होनी चाहिए. ऐसा न होने पर, गड़बड़ी का मैसेज दिखता है.

उदाहरण:

कलेक्शन ऑफ़सेट लंबाई array_slice(array, offset, length)
[1, 2, 3, 4, 5] 1 3 [2, 3, 4]
[1, 2, 3, 4, 5] -2 2 [4, 5]
[1, 2, 3] 1 5 [2, 3]
[1, 2, 3] 3 2 []

ARRAY_TRANSFORM

सिंटैक्स:

array_transform(array: ARRAY, expression: (ANY) -> ANY) -> ARRAY
array_transform(array: ARRAY, expression: (ANY, INT64) -> ANY) -> ARRAY

ब्यौरा:

यह फ़ंक्शन, array में मौजूद हर एलिमेंट पर expression लागू करके उसे बदलता है. इसके बाद, बदले गए एलिमेंट वाली नई श्रेणी दिखाता है. आउटपुट ऐरे का साइज़ हमेशा इनपुट ऐरे के साइज़ के बराबर होगा.

  • expression, यूनेरी फ़ंक्शन element -> result या बाइनरी फ़ंक्शन (element, index) -> result हो सकता है.
  • अगर expression यूनेरी है, तो इसे array के हर एलिमेंट के साथ कॉल किया जाता है.
  • अगर expression बाइनरी है, तो इसे array के हर एलिमेंट और उसके 0 पर आधारित इंडेक्स के साथ कॉल किया जाता है.

उदाहरण:

कलेक्शन एक्सप्रेशन array_transform(array, expression)
[1, 2, 3] x -> x * 2 [2, 4, 6]
[1, 2, 3] x -> x + 1 [2, 3, 4]
[10, 20] (x, i) -> x + i [10, 21]
[] x -> 1 []

ज़्यादा से ज़्यादा

सिंटैक्स:

maximum(array: ARRAY) -> ANY

ब्यौरा:

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

  • तुलना करते समय, NULL वैल्यू को अनदेखा कर दिया जाता है.
  • अगर array खाली है या इसमें सिर्फ़ NULL वैल्यू हैं, तो NULL दिखाता है.

उदाहरण:

कलेक्शन maximum(array)
[1, 5, 2] 5
[1, null, 5] 5
["a", "c", "b"] "c"
[null, null] शून्य
[] शून्य

MAXIMUM_N

सिंटैक्स:

maximum_n(array: ARRAY, n: INT64) -> ARRAY

ब्यौरा:

यह फ़ंक्शन, array में मौजूद n सबसे बड़ी वैल्यू का अरे दिखाता है. यह अरे, घटते क्रम में होता है.

  • NULL वैल्यू को अनदेखा किया जाता है.
  • अगर n नेगेटिव है, तो गड़बड़ी का मैसेज दिखता है.

उदाहरण:

कलेक्शन n maximum_n(array, n)
[1, 5, 2, 4, 3] 3 [5, 4, 3]
[1, null, 5] 3 [5, 1]

कम से कम

सिंटैक्स:

minimum(array: ARRAY) -> ANY

ब्यौरा:

array में मौजूद सबसे छोटी वैल्यू दिखाता है.

  • तुलना करते समय, NULL वैल्यू को अनदेखा कर दिया जाता है.
  • अगर array खाली है या इसमें सिर्फ़ NULL वैल्यू हैं, तो NULL दिखाता है.

उदाहरण:

कलेक्शन minimum(array)
[1, 5, 2] 1
[5, null, 1] 1
["a", "c", "b"] "a"
[null, null] शून्य
[] शून्य

MINIMUM_N

सिंटैक्स:

minimum_n(array: ARRAY, n: INT64) -> ARRAY

ब्यौरा:

यह फ़ंक्शन, array में मौजूद n सबसे छोटी वैल्यू का एक ऐसा कलेक्शन दिखाता है जिसमें वैल्यू बढ़ते क्रम में होती हैं.

  • NULL वैल्यू को अनदेखा किया जाता है.
  • अगर n नेगेटिव है, तो गड़बड़ी का मैसेज दिखता है.

उदाहरण:

कलेक्शन n minimum_n(array, n)
[1, 5, 2, 4, 3] 3 [1, 2, 3]
[5, null, 1] 3 [1, 5]

SUM

सिंटैक्स:

sum(array: ARRAY) -> INT64 | FLOAT64

ब्यौरा:

यह ARRAY में मौजूद सभी NUMERIC वैल्यू का योग दिखाता है.

  • ऐरे में मौजूद नॉन-न्यूमेरिक वैल्यू को अनदेखा किया जाता है.
  • अगर ऐरे में मौजूद कोई भी संख्यात्मक वैल्यू NaN है, तो फ़ंक्शन NaN दिखाता है.
  • रिटर्न टाइप, ऐरे में मौजूद सबसे बड़े न्यूमेरिक टाइप से तय होता है: INT64 < FLOAT64.
  • अगर फ़्लोटिंग पॉइंट वैल्यू को जोड़ने से पहले 64-बिट पूर्णांक ओवरफ़्लो हो जाता है, तो गड़बड़ी वाला मान दिखता है. अगर फ़्लोटिंग पॉइंट वैल्यू को जोड़ा जाता है, तो ओवरफ़्लो होने पर नतीजा +/- इनफ़िनिटी होगा.
  • अगर ऐरे में कोई भी संख्या मौजूद नहीं है, तो फ़ंक्शन NULL दिखाता है.

उदाहरण:

कलेक्शन sum(array)
[1, 2, 3] 6L
[1L, 2L, 3L] 6L
[2000000000, 2000000000] 4000000000L
[10, 20.5] 30.5
[1, "a", 2] 3L
[INT64.MAX_VALUE, 1] गड़बड़ी
[INT64.MAX_VALUE, 1, -1.0] गड़बड़ी
[INT64.MAX_VALUE, 1.0] 9.223372036854776e+18

JOIN

सिंटैक्स:

join[T <: STRING | BYTES](array: ARRAY<T>, delimiter: T) -> STRING
join[T <: STRING | BYTES](array: ARRAY<T>, delimiter: T, null_text: T) -> STRING

ब्यौरा:

array में मौजूद एलिमेंट को जोड़कर, STRING के तौर पर दिखाता है. array, STRING या BYTES डेटा टाइप का हो सकता है.

  • array, delimiter, और null_text में मौजूद सभी एलिमेंट एक ही तरह के होने चाहिए. वे सभी STRING या BYTES होने चाहिए.
  • अगर null_text दिया गया है, तो array में मौजूद NULL की सभी वैल्यू को null_text से बदल दिया जाता है.
  • अगर null_text नहीं दिया गया है, तो array में मौजूद NULL वैल्यू को नतीजे से हटा दिया जाता है.

उदाहरण:

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

कलेक्शन डेलिमिटर join(array, delimiter)
["a", "b", "c"] "," "a,b,c"
["a", null, "c"] "," "a,c"
[b'a', b'b', b'c'] b',' b'a,b,c'
["a", b'c'] "," गड़बड़ी
["a", "c"] b',' गड़बड़ी
[b'a', b'c'] "," गड़बड़ी

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

कलेक्शन डेलिमिटर null_text join(array, delimiter, null_text)
["a", null, "c"] "," "MISSING" "a,MISSING,c"
[b'a', null, b'c'] b',' b'NULL' b'a,NULL,c'
[null, "b", null] "," "MISSING" "MISSING,b,MISSING"
[b'a', null, null] b',' b'NULL' b'a,NULL,NULL'
["a", null] "," b'N' गड़बड़ी
[b'a', null] b',' "N" गड़बड़ी

तुलना करने वाले फ़ंक्शन

नाम ब्यौरा
EQUAL तुलना करना
GREATER_THAN तुलना में ज़्यादा
GREATER_THAN_OR_EQUAL इससे ज़्यादा या इसके बराबर तुलना
LESS_THAN तुलना के लिए इस्तेमाल किए जाने वाले ऑपरेटर से कम
LESS_THAN_OR_EQUAL इससे कम या इसके बराबर तुलना
NOT_EQUAL तुलना में बराबर नहीं है
CMP सामान्य तुलना

बराबर

सिंटैक्स:

equal(x: ANY, y: ANY) -> BOOLEAN

उदाहरण:

x y equal(x, y)
1L 1L TRUE
1.0 1L TRUE
-1.0 1L FALSE
NaN NaN TRUE
NULL NULL TRUE
NULL ABSENT FALSE

ब्यौरा:

अगर x और y बराबर हैं, तो TRUE दिखाता है. अगर बराबर नहीं हैं, तो FALSE दिखाता है.

Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("rating").equal(5).as("hasPerfectRating"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("rating").equal(5).as("hasPerfectRating"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("rating").equal(5).as("hasPerfectRating")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(field("rating").equal(5).alias("hasPerfectRating"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("rating").equal(5).alias("hasPerfectRating"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("rating").equal(5).as_("hasPerfectRating"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(equal(field("rating"), 5).as("hasPerfectRating"))
        .execute()
        .get();
PipelineSnippets.java

GREATER_THAN

सिंटैक्स:

greater_than(x: ANY, y: ANY) -> BOOLEAN

ब्यौरा:

अगर x का मान y से ज़्यादा है, तो TRUE दिखाता है. अगर ऐसा नहीं है, तो FALSE दिखाता है.

अगर x और y की तुलना नहीं की जा सकती, तो FALSE दिखाता है.

उदाहरण:

x y greater_than(x, y)
1L 0.0 TRUE
1L 1L FALSE
1L 2L FALSE
"foo" 0L FALSE
0L "foo" FALSE
NaN 0L FALSE
0L NaN FALSE
NULL NULL FALSE
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("rating").greaterThan(4).as("hasHighRating"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("rating").greaterThan(4).as("hasHighRating"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("rating").greaterThan(4).as("hasHighRating")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(field("rating").greaterThan(4).alias("hasHighRating"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("rating").greaterThan(4).alias("hasHighRating"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("rating").greater_than(4).as_("hasHighRating"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(greaterThan(field("rating"), 4).as("hasHighRating"))
        .execute()
        .get();
PipelineSnippets.java

GREATER_THAN_OR_EQUAL

सिंटैक्स:

greater_than_or_equal(x: ANY, y: ANY) -> BOOLEAN

ब्यौरा:

अगर x का मान y से ज़्यादा या इसके बराबर है, तो TRUE दिखाता है. अगर ऐसा नहीं है, तो FALSE दिखाता है.

अगर x और y की तुलना नहीं की जा सकती, तो FALSE दिखाता है.

उदाहरण:

x y greater_than_or_equal(x, y)
1L 0.0 TRUE
1L 1L TRUE
1L 2L FALSE
"foo" 0L FALSE
0L "foo" FALSE
NaN 0L FALSE
0L NaN FALSE
NULL NULL TRUE
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("published").greaterThanOrEqual(1900).as("publishedIn20thCentury"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("published").greaterThanOrEqual(1900).as("publishedIn20thCentury"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("published").greaterThanOrEqual(1900).as("publishedIn20thCentury")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(field("published").greaterThanOrEqual(1900).alias("publishedIn20thCentury"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("published").greaterThanOrEqual(1900).alias("publishedIn20thCentury"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("published")
        .greater_than_or_equal(1900)
        .as_("publishedIn20thCentury")
    )
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(greaterThanOrEqual(field("published"), 1900).as("publishedIn20thCentury"))
        .execute()
        .get();
PipelineSnippets.java

LESS_THAN

सिंटैक्स:

less_than(x: ANY, y: ANY) -> BOOLEAN

ब्यौरा:

अगर x का मान y से कम है, तो TRUE दिखाता है. अगर x का मान y से कम नहीं है, तो FALSE दिखाता है.

अगर x और y की तुलना नहीं की जा सकती, तो FALSE दिखाता है.

उदाहरण:

x y less_than(x, y)
1L 0.0 FALSE
1L 1L FALSE
1L 2L TRUE
"foo" 0L FALSE
0L "foo" FALSE
NaN 0L FALSE
0L NaN FALSE
NULL NULL FALSE
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("published").lessThan(1923).as("isPublicDomainProbably"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("published").lessThan(1923).as("isPublicDomainProbably"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("published").lessThan(1923).as("isPublicDomainProbably")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(field("published").lessThan(1923).alias("isPublicDomainProbably"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("published").lessThan(1923).alias("isPublicDomainProbably"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("published").less_than(1923).as_("isPublicDomainProbably"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(lessThan(field("published"), 1923).as("isPublicDomainProbably"))
        .execute()
        .get();
PipelineSnippets.java

LESS_THAN_OR_EQUAL

सिंटैक्स:

less_than_or_equal(x: ANY, y: ANY) -> BOOLEAN

ब्यौरा:

अगर x का मान y से कम या इसके बराबर है, तो TRUE दिखाता है. अगर ऐसा नहीं है, तो FALSE दिखाता है.

अगर x और y की तुलना नहीं की जा सकती, तो FALSE दिखाता है.

उदाहरण:

x y less_than(x, y)
1L 0.0 FALSE
1L 1L TRUE
1L 2L TRUE
"foo" 0L FALSE
0L "foo" FALSE
NaN 0L FALSE
0L NaN FALSE
NULL NULL TRUE
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("rating").lessThanOrEqual(2).as("hasBadRating"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("rating").lessThanOrEqual(2).as("hasBadRating"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("rating").lessThanOrEqual(2).as("hasBadRating")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(field("rating").lessThanOrEqual(2).alias("hasBadRating"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("rating").lessThanOrEqual(2).alias("hasBadRating"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("rating").less_than_or_equal(2).as_("hasBadRating"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(lessThanOrEqual(field("rating"), 2).as("hasBadRating"))
        .execute()
        .get();
PipelineSnippets.java

NOT_EQUAL

सिंटैक्स:

not_equal(x: ANY, y: ANY) -> BOOLEAN

ब्यौरा:

अगर x, y के बराबर नहीं है, तो TRUE दिखाता है. अगर x, y के बराबर है, तो FALSE दिखाता है.

उदाहरण:

x y not_equal(x, y)
1L 1L FALSE
1.0 1L FALSE
-1.0 1L TRUE
NaN 0L TRUE
NaN NaN FALSE
NULL NULL FALSE
NULL ABSENT TRUE
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("title").notEqual("1984").as("not1984"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("title").notEqual("1984").as("not1984"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("title").notEqual("1984").as("not1984")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(field("title").notEqual("1984").alias("not1984"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("title").notEqual("1984").alias("not1984"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("title").not_equal("1984").as_("not1984"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(notEqual(field("title"), "1984").as("not1984"))
        .execute()
        .get();
PipelineSnippets.java

CMP

सिंटैक्स:

cmp(x: ANY, y: ANY) -> Int64

ब्यौरा:

x और y की तुलना करता है और यह जानकारी देता है:

  • 1L, अगर x का मान y से ज़्यादा है.
  • -1L अगर x, y से कम है.
  • अन्य मामलों में 0L.

तुलना करने वाले अन्य फ़ंक्शन के उलट, cmp(...) फ़ंक्शन सभी टाइप के लिए काम करता है. यह sort(...) स्टेज में इस्तेमाल किए गए क्रम के हिसाब से काम करता है. अलग-अलग टाइप की वैल्यू को किस क्रम में लगाया जाता है, यह जानने के लिए वैल्यू टाइप का क्रम देखें.

उदाहरण:

x y cmp(x, y)
1L 1L 0L
1.0 1L 0L
-1.0 1L -1L
42.5D "foo" -1L
NULL NULL 0L
NULL ABSENT 0L

फ़ंक्शन डीबग करना

नाम ब्यौरा
EXISTS अगर वैल्यू मौजूद नहीं है, तो TRUE दिखाता है
IS_ABSENT अगर वैल्यू मौजूद नहीं है, तो TRUE दिखाता है
IF_ABSENT अगर वैल्यू मौजूद नहीं है, तो उसे एक्सप्रेशन से बदलता है
IS_ERROR यह फ़ंक्शन, किसी गड़बड़ी का पता लगाता है और यह देखता है कि क्या गड़बड़ी को अंडरलाइंग एक्सप्रेशन से थ्रो किया गया है
IF_ERROR अगर वैल्यू में कोई गड़बड़ी हुई है, तो उसे एक्सप्रेशन से बदलता है
ERROR यह फ़ंक्शन, जांच को खत्म कर देता है और दिए गए मैसेज के साथ गड़बड़ी दिखाता है

EXISTS

सिंटैक्स:

exists(value: ANY) -> BOOLEAN

ब्यौरा:

अगर value मौजूद नहीं है, तो TRUE दिखाता है.

उदाहरण:

value exists(value)
0L TRUE
"foo" TRUE
NULL TRUE
ABSENT FALSE
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("rating").exists().as("hasRating"))
  .execute();
test.firestore.js

Web

उदाहरण:

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("rating").exists().as("hasRating"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("rating").exists().as("hasRating")])
  .execute()
PipelineSnippets.swift

Kotlin

उदाहरण:

val result = db.pipeline()
    .collection("books")
    .select(field("rating").exists().alias("hasRating"))
    .execute()
DocSnippets.kt

Java

उदाहरण:

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("rating").exists().alias("hasRating"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("rating").exists().as_("hasRating"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(exists(field("rating")).as("hasRating"))
        .execute()
        .get();
PipelineSnippets.java

IS_ABSENT

सिंटैक्स:

is_absent(value: ANY) -> BOOLEAN

ब्यौरा:

अगर value मौजूद नहीं है, तो TRUE दिखाता है. अगर value मौजूद है, तो FALSE दिखाता है. इनपुट में मौजूद नहीं हैं वे वैल्यू होती हैं जो इनपुट में मौजूद नहीं होती हैं. जैसे, दस्तावेज़ का कोई फ़ील्ड मौजूद नहीं है.

उदाहरण:

value is_absent(value)
0L FALSE
"foo" FALSE
NULL FALSE
ABSENT TRUE

IF_ABSENT

सिंटैक्स:

if_absent(value: ANY, replacement: ANY) -> ANY

ब्यौरा:

अगर value मौजूद नहीं है, तो replacement का आकलन करता है और उसे दिखाता है. ऐसा न होने पर, value दिखाता है.

उदाहरण:

value replacement if_absent(value, replacement)
5 ली॰ 0L 5 ली॰
NULL 0L NULL
ABSENT 0L 0L

IS_ERROR

सिंटैक्स:

is_error(try: ANY) -> BOOLEAN

ब्यौरा:

अगर try का आकलन करते समय कोई गड़बड़ी होती है, तो TRUE दिखाता है. अन्य मामलों में, FALSE दिखाता है.

IF_ERROR

सिंटैक्स:

if_error(try: ANY, catch: ANY) -> ANY

ब्यौरा:

अगर try का आकलन करते समय कोई गड़बड़ी होती है, तो replacement का आकलन करता है और उसे दिखाता है. ऐसा न होने पर, try की हल की गई वैल्यू दिखाता है.

गड़बड़ी

सिंटैक्स:

error(message: STRING) -> ANY

ब्यौरा:

error फ़ंक्शन को एक्ज़ीक्यूट करने की वजह से, पाइपलाइन को एक्ज़ीक्यूट करने में गड़बड़ी हुई. दी गई message को गड़बड़ी में शामिल किया गया है.

उदाहरण:

cond res switch_on(cond, res, error("no condition matched"))
TRUE 1L 1L
FALSE 1L ERROR ("no condition matched")

रेफ़रंस फ़ंक्शन

REFERENCE टाइप, डेटाबेस में मौजूद अन्य दस्तावेज़ों (या अन्य डेटाबेस) के लिए "पॉइंटर" के तौर पर काम करता है. क्वेरी को लागू करने के दौरान, इस टाइप में बदलाव करने के लिए यहां दिए गए फ़ंक्शन इस्तेमाल किए जा सकते हैं.

नाम ब्यौरा
COLLECTION_ID यह फ़ंक्शन, दिए गए रेफ़रंस में मौजूद लीफ़ कलेक्शन का आईडी दिखाता है
DOCUMENT_ID यह फ़ंक्शन, दिए गए रेफ़रंस में मौजूद दस्तावेज़ का आईडी दिखाता है
PARENT पेरेंट रेफ़रंस दिखाता है
REFERENCE_SLICE यह फ़ंक्शन, दिए गए रेफ़रंस से सेगमेंट का सबसेट दिखाता है

COLLECTION_ID

सिंटैक्स:

collection_id(ref: REFERENCE) -> STRING

ब्यौरा:

यह फ़ंक्शन, दिए गए REFERENCE का लीफ़ कलेक्शन आईडी दिखाता है.

उदाहरण:

ref collection_id(ref)
users/user1 "users"
users/user1/posts/post1 "posts"

DOCUMENT_ID

सिंटैक्स:

document_id(ref: REFERENCE) -> ANY

ब्यौरा:

यह फ़ंक्शन, दिए गए REFERENCE का दस्तावेज़ आईडी दिखाता है.

उदाहरण:

ref document_id(ref)
users/user1 "user1"
users/user1/posts/post1 "post1"

माता-पिता

सिंटैक्स:

parent(ref: REFERENCE) -> REFERENCE

ब्यौरा:

यह फ़ंक्शन, दिए गए रेफ़रंस का पैरंट REFERENCE दिखाता है. अगर रेफ़रंस पहले से ही रूट रेफ़रंस है, तो यह NULL दिखाता है.

उदाहरण:

ref parent(ref)
/ NULL
users/user1 /
users/user1/posts/post1 users/user1

REFERENCE_SLICE

सिंटैक्स:

reference_slice(ref: REFERENCE, offset: INT, length: INT) -> REFERENCE

ब्यौरा:

REFERENCE, (collection_id, document_id) टपल की सूची होती है. इससे array_slice(...) की तरह, उस सूची को देखा जा सकता है.

यह एक नया REFERENCE दिखाता है, जो दिए गए ref के सेगमेंट का सबसेट होता है.

  • offset: स्लाइस का शुरुआती इंडेक्स (0 से शुरू होने वाला). अगर यह नेगेटिव है, तो यह रेफ़रंस के आखिर से ऑफ़सेट होता है.
  • length: स्लाइस में शामिल किए जाने वाले सेगमेंट की संख्या.

उदाहरण:

ref offset length reference_slice(ref, offset, length)
a/1/b/2/c/3 1L 2L b/2/c/3
a/1/b/2/c/3 0L 2L a/1/b/2
a/1/b/2/c/3 -2L 2L c/3

लॉजिकल फ़ंक्शन

नाम ब्यौरा
AND लॉजिकल AND फ़ंक्शन लागू करता है
OR लॉजिकल OR फ़ंक्शन लागू करता है
XOR लॉजिकल XOR फ़ंक्शन लागू करता है
NOT लॉजिकल NOT फ़ंक्शन का इस्तेमाल करता है
NOR लॉजिकल NOR फ़ंक्शन लागू करता है
CONDITIONAL यह फ़ंक्शन, कंडिशनल एक्सप्रेशन के आधार पर आकलन करता है.
IF_NULL पहली नॉन-नल वैल्यू दिखाता है
SWITCH_ON कई शर्तों के आधार पर ब्रांच का आकलन
EQUAL_ANY यह फ़ंक्शन जांच करता है कि कोई वैल्यू, किसी कलेक्शन में मौजूद किसी एलिमेंट के बराबर है या नहीं
NOT_EQUAL_ANY यह फ़ंक्शन, यह जांच करता है कि कोई वैल्यू, किसी कलेक्शन में मौजूद किसी भी एलिमेंट के बराबर नहीं है
MAXIMUM यह फ़ंक्शन, वैल्यू के सेट में मौजूद सबसे बड़ी वैल्यू दिखाता है
MINIMUM यह फ़ंक्शन, वैल्यू के किसी सेट में मौजूद सबसे छोटी वैल्यू दिखाता है

और

सिंटैक्स:

and(x: BOOLEAN...) -> BOOLEAN

ब्यौरा:

यह फ़ंक्शन, दो या उससे ज़्यादा बूलियन वैल्यू का लॉजिकल AND दिखाता है.

अगर दी गई किसी भी वैल्यू के ABSENT या NULL होने की वजह से, नतीजा नहीं निकाला जा सकता, तो NULL दिखाता है.

उदाहरण:

x y and(x, y)
TRUE TRUE TRUE
FALSE TRUE FALSE
NULL TRUE NULL
ABSENT TRUE NULL
NULL FALSE FALSE
FALSE ABSENT FALSE
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(
    and(field("rating").greaterThan(4), field("price").lessThan(10))
      .as("under10Recommendation")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    and(field("rating").greaterThan(4), field("price").lessThan(10))
      .as("under10Recommendation")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([
    (Field("rating").greaterThan(4) && Field("price").lessThan(10))
      .as("under10Recommendation")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        Expression.and(field("rating").greaterThan(4),
          field("price").lessThan(10))
            .alias("under10Recommendation")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        Expression.and(
            field("rating").greaterThan(4),
            field("price").lessThan(10)
        ).alias("under10Recommendation")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field, And

result = (
    client.pipeline()
    .collection("books")
    .select(
        And(
            Field.of("rating").greater_than(4), Field.of("price").less_than(10)
        ).as_("under10Recommendation")
    )
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            and(greaterThan(field("rating"), 4), lessThan(field("price"), 10))
                .as("under10Recommendation"))
        .execute()
        .get();
PipelineSnippets.java

या

सिंटैक्स:

or(x: BOOLEAN...) -> BOOLEAN

ब्यौरा:

यह फ़ंक्शन, दो या उससे ज़्यादा बूलियन वैल्यू का लॉजिकल OR दिखाता है.

अगर दी गई किसी भी वैल्यू के ABSENT या NULL होने की वजह से, नतीजा नहीं निकाला जा सकता, तो NULL दिखाता है.

उदाहरण:

x y or(x, y)
TRUE TRUE TRUE
FALSE TRUE TRUE
NULL TRUE TRUE
ABSENT TRUE TRUE
NULL FALSE NULL
FALSE ABSENT NULL
Node.js
const result = await db.pipeline()
  .collection("books")
  .select(
    or(field("genre").equal("Fantasy"), field("tags").arrayContains("adventure"))
      .as("matchesSearchFilters")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    or(field("genre").equal("Fantasy"), field("tags").arrayContains("adventure"))
      .as("matchesSearchFilters")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([
    (Field("genre").equal("Fantasy") || Field("tags").arrayContains("adventure"))
      .as("matchesSearchFilters")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        Expression.or(field("genre").equal("Fantasy"),
          field("tags").arrayContains("adventure"))
            .alias("matchesSearchFilters")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        Expression.or(
            field("genre").equal("Fantasy"),
            field("tags").arrayContains("adventure")
        ).alias("matchesSearchFilters")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field, And, Or

result = (
    client.pipeline()
    .collection("books")
    .select(
        Or(
            Field.of("genre").equal("Fantasy"),
            Field.of("tags").array_contains("adventure"),
        ).as_("matchesSearchFilters")
    )
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            or(equal(field("genre"), "Fantasy"), arrayContains(field("tags"), "adventure"))
                .as("matchesSearchFilters"))
        .execute()
        .get();
PipelineSnippets.java

XOR

सिंटैक्स:

xor(x: BOOLEAN...) -> BOOLEAN

ब्यौरा:

यह फ़ंक्शन, दो या उससे ज़्यादा बूलियन वैल्यू का लॉजिकल XOR दिखाता है.

अगर दी गई वैल्यू में से कोई भी वैल्यू ABSENT या NULL है, तो यह फ़ंक्शन NULL दिखाता है.

उदाहरण:

x y xor(x, y)
TRUE TRUE FALSE
FALSE FALSE FALSE
FALSE TRUE TRUE
NULL TRUE NULL
ABSENT TRUE NULL
NULL FALSE NULL
FALSE ABSENT NULL
Node.js
const result = await execute(db.pipeline()
  .collection("books")
  .select(
    xor(field("tags").arrayContains("magic"), field("tags").arrayContains("nonfiction"))
      .as("matchesSearchFilters")
  )
);
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    xor(field("tags").arrayContains("magic"), field("tags").arrayContains("nonfiction"))
      .as("matchesSearchFilters")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([
    (Field("tags").arrayContains("magic") ^ Field("tags").arrayContains("nonfiction"))
      .as("matchesSearchFilters")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        Expression.xor(field("tags").arrayContains("magic"),
          field("tags").arrayContains("nonfiction"))
            .alias("matchesSearchFilters")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        Expression.xor(
            field("tags").arrayContains("magic"),
            field("tags").arrayContains("nonfiction")
        ).alias("matchesSearchFilters")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field, Xor

result = (
    client.pipeline()
    .collection("books")
    .select(
        Xor(
            [
                Field.of("tags").array_contains("magic"),
                Field.of("tags").array_contains("nonfiction"),
            ]
        ).as_("matchesSearchFilters")
    )
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            xor(
                    arrayContains(field("tags"), "magic"),
                    arrayContains(field("tags"), "nonfiction"))
                .as("matchesSearchFilters"))
        .execute()
        .get();
PipelineSnippets.java

NOR

सिंटैक्स:

nor(x: BOOLEAN...) -> BOOLEAN

ब्यौरा:

दो या उससे ज़्यादा बूलियन वैल्यू का लॉजिकल NOR दिखाता है.

अगर दी गई किसी भी वैल्यू के ABSENT या NULL होने की वजह से, नतीजा नहीं निकाला जा सकता, तो NULL दिखाता है.

उदाहरण:

x y nor(x, y)
TRUE TRUE FALSE
FALSE TRUE FALSE
FALSE FALSE TRUE
NULL TRUE FALSE
ABSENT TRUE FALSE
NULL FALSE NULL
FALSE ABSENT NULL

नहीं

सिंटैक्स:

not(x: BOOLEAN) -> BOOLEAN

ब्यौरा:

यह फ़ंक्शन, किसी बूलियन वैल्यू का लॉजिकल NOT दिखाता है.

Node.js
const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("tags").arrayContains("nonfiction").not()
      .as("isFiction")
  )
);
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("tags").arrayContains("nonfiction").not()
      .as("isFiction")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([
    (!Field("tags").arrayContains("nonfiction"))
      .as("isFiction")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        Expression.not(
            field("tags").arrayContains("nonfiction")
        ).alias("isFiction")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        Expression.not(
            field("tags").arrayContains("nonfiction")
        ).alias("isFiction")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field, Not

result = (
    client.pipeline()
    .collection("books")
    .select(Not(Field.of("tags").array_contains("nonfiction")).as_("isFiction"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(not(arrayContains(field("tags"), "nonfiction")).as("isFiction"))
        .execute()
        .get();
PipelineSnippets.java

CONDITIONAL

सिंटैक्स:

conditional(condition: BOOLEAN, true_case: ANY, false_case: ANY) -> ANY

ब्यौरा:

true_case का आकलन करता है और अगर condition की वैल्यू TRUE होती है, तो true_case दिखाता है.

इस फ़ंक्शन से, स्थिति का आकलन किया जाता है. अगर स्थिति FALSE, NULL या ABSENT वैल्यू में बदलती है, तो यह फ़ंक्शन false_case वैल्यू दिखाता है.

उदाहरण:

condition true_case false_case conditional(condition, true_case, false_case)
TRUE 1L 0L 1L
FALSE 1L 0L 0L
NULL 1L 0L 0L
ABSENT 1L 0L 0L
Node.js
const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("tags").arrayConcat([
      field("pages").greaterThan(100)
        .conditional(constant("longRead"), constant("shortRead"))
    ]).as("extendedTags")
  )
);
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("tags").arrayConcat([
      field("pages").greaterThan(100)
        .conditional(constant("longRead"), constant("shortRead"))
    ]).as("extendedTags")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("tags").arrayConcat([
      ConditionalExpression(
        Field("pages").greaterThan(100),
        then: Constant("longRead"),
        else: Constant("shortRead")
      )
    ]).as("extendedTags")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        field("tags").arrayConcat(
            Expression.conditional(
                field("pages").greaterThan(100),
                constant("longRead"),
                constant("shortRead")
            )
        ).alias("extendedTags")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("tags").arrayConcat(
            Expression.conditional(
                field("pages").greaterThan(100),
                constant("longRead"),
                constant("shortRead")
            )
        ).alias("extendedTags")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import (
    Field,
    Constant,
    Conditional,
)

result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("tags")
        .array_concat(
            Conditional(
                Field.of("pages").greater_than(100),
                Constant.of("longRead"),
                Constant.of("shortRead"),
            )
        )
        .as_("extendedTags")
    )
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            arrayConcat(
                    field("tags"),
                    conditional(
                        greaterThan(field("pages"), 100),
                        constant("longRead"),
                        constant("shortRead")))
                .as("extendedTags"))
        .execute()
        .get();
PipelineSnippets.java

IF_NULL

सिंटैक्स:

if_null(expr: ANY, replacement: ANY) -> ANY

ब्यौरा:

अगर NULL नहीं है, तो expr दिखाता है. अगर NULL है, तो replacement का आकलन करके उसे दिखाता है. अगर expr का इस्तेमाल किया जाता है, तो replacement एक्सप्रेशन का आकलन नहीं किया जाता.

उदाहरण:

expr replacement if_null(expr, replacement)
1L 2L 1L
NULL 2L 2L
ABSENT 2L ABSENT

SWITCH_ON

सिंटैक्स:

switch_on(cond1: BOOLEAN, res1: ANY, cond2: BOOLEAN, res2: ANY, ..., [default: ANY]) -> ANY

ब्यौरा:

यह फ़ंक्शन, शर्तों की एक सीरीज़ का आकलन करता है और पहली TRUE शर्त से जुड़ा नतीजा दिखाता है. अगर कोई भी शर्त TRUE के तौर पर नहीं दिखती है, तो default वैल्यू दिखाई जाती है. हालांकि, ऐसा तब होता है, जब वैल्यू दी गई हो. अगर default वैल्यू नहीं दी जाती है, तो कोई अन्य शर्त TRUE के तौर पर नहीं आंकी जाने पर गड़बड़ी का मैसेज दिखता है.

default वैल्यू देने के लिए, इसे आखिरी तर्क के तौर पर पास करें, ताकि तर्कों की संख्या विषम हो.

उदाहरण:

x switch_on(eq(x, 1L), "one", eq(x, 2L), "two", "other")
1L "one"
2L "दो"
3L "अन्य"

EQUAL_ANY

सिंटैक्स:

equal_any(value: ANY, search_space: ARRAY) -> BOOLEAN

ब्यौरा:

अगर value, search_space कलेक्शन में मौजूद है, तो TRUE दिखाता है.

उदाहरण:

value search_space equal_any(value, search_space)
0L [1L, 2L, 3L] FALSE
2L [1L, 2L, 3L] TRUE
NULL [1L, 2L, 3L] FALSE
NULL [1L, NULL] TRUE
ABSENT [1L, NULL] FALSE
NaN [1L, NaN, 3L] TRUE
Node.js
const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("genre").equalAny(["Science Fiction", "Psychological Thriller"])
      .as("matchesGenreFilters")
  )
);
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("genre").equalAny(["Science Fiction", "Psychological Thriller"])
      .as("matchesGenreFilters")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("genre").equalAny(["Science Fiction", "Psychological Thriller"])
      .as("matchesGenreFilters")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        field("genre").equalAny(listOf("Science Fiction", "Psychological Thriller"))
            .alias("matchesGenreFilters")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("genre").equalAny(Arrays.asList("Science Fiction", "Psychological Thriller"))
            .alias("matchesGenreFilters")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("genre")
        .equal_any(["Science Fiction", "Psychological Thriller"])
        .as_("matchesGenreFilters")
    )
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            equalAny(field("genre"), Arrays.asList("Science Fiction", "Psychological Thriller"))
                .as("matchesGenreFilters"))
        .execute()
        .get();
PipelineSnippets.java

NOT_EQUAL_ANY

सिंटैक्स:

not_equal_any(value: ANY, search_space: ARRAY) -> BOOLEAN

ब्यौरा:

अगर search_space अरे में value मौजूद नहीं है, तो TRUE दिखाता है.

उदाहरण:

value search_space not_equal_any(value, search_space)
0L [1L, 2L, 3L] TRUE
2L [1L, 2L, 3L] FALSE
NULL [1L, 2L, 3L] TRUE
NULL [1L, NULL] FALSE
ABSENT [1L, NULL] TRUE
NaN [1L, NaN, 3L] FALSE
Node.js
const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("author").notEqualAny(["George Orwell", "F. Scott Fitzgerald"])
      .as("byExcludedAuthors")
  )
);
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("author").notEqualAny(["George Orwell", "F. Scott Fitzgerald"])
      .as("byExcludedAuthors")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("author").notEqualAny(["George Orwell", "F. Scott Fitzgerald"])
      .as("byExcludedAuthors")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        field("author").notEqualAny(listOf("George Orwell", "F. Scott Fitzgerald"))
            .alias("byExcludedAuthors")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("author").notEqualAny(Arrays.asList("George Orwell", "F. Scott Fitzgerald"))
            .alias("byExcludedAuthors")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("author")
        .not_equal_any(["George Orwell", "F. Scott Fitzgerald"])
        .as_("byExcludedAuthors")
    )
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            notEqualAny(field("author"), Arrays.asList("George Orwell", "F. Scott Fitzgerald"))
                .as("byExcludedAuthors"))
        .execute()
        .get();
PipelineSnippets.java

ज़्यादा से ज़्यादा

सिंटैक्स:

maximum(x: ANY...) -> ANY
maximum(x: ARRAY) -> ANY

ब्यौरा:

यह फ़ंक्शन, वैल्यू की सीरीज़ x में मौजूद सबसे बड़ी वैल्यू दिखाता है. हालांकि, यह NULL और ABSENT वैल्यू को छोड़कर सबसे बड़ी वैल्यू दिखाता है.

अगर NULL और ABSENT के अलावा कोई दूसरी वैल्यू नहीं है, तो NULL दिखता है.

अगर सबसे ज़्यादा बार दिखने वाली वैल्यू एक से ज़्यादा हैं, तो उनमें से कोई भी वैल्यू दिखाई जा सकती है. वैल्यू टाइप का क्रम, दस्तावेज़ में दिए गए क्रम के हिसाब से होता है.

उदाहरण:

x y maximum(x, y)
FALSE TRUE TRUE
FALSE -10L -10L
0.0 -5L 0.0
"foo" "bar" "foo"
"foo" ["foo"] ["foo"]
ABSENT ABSENT NULL
NULL NULL NULL
Node.js
const result = await execute(db.pipeline()
  .collection("books")
  .aggregate(field("price").maximum().as("maximumPrice"))
);
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .aggregate(field("price").maximum().as("maximumPrice"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("rating").logicalMaximum([1]).as("flooredRating")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        field("rating").logicalMaximum(1).alias("flooredRating")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("rating").logicalMaximum(1).alias("flooredRating")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("rating").logical_maximum(1).as_("flooredRating"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(logicalMaximum(field("rating"), 1).as("flooredRating"))
        .execute()
        .get();
PipelineSnippets.java

कम से कम

सिंटैक्स:

minimum(x: ANY...) -> ANY
minimum(x: ARRAY) -> ANY

ब्यौरा:

यह फ़ंक्शन, वैल्यू की सीरीज़ x में मौजूद सबसे छोटी ऐसी वैल्यू दिखाता है जो न तो NULL हो और न ही ABSENT.

अगर NULL और ABSENT के अलावा कोई दूसरी वैल्यू नहीं है, तो NULL दिखता है.

अगर एक से ज़्यादा वैल्यू, सबसे कम वैल्यू के बराबर हैं, तो उनमें से कोई भी वैल्यू दिखाई जा सकती है. वैल्यू टाइप का क्रम, दस्तावेज़ में दिए गए क्रम के हिसाब से होता है.

उदाहरण:

x y minimum(x, y)
FALSE TRUE FALSE
FALSE -10L FALSE
0.0 -5L -5L
"foo" "bar" "bar"
"foo" ["foo"] "foo"
ABSENT ABSENT NULL
NULL NULL NULL
Node.js
const result = await execute(db.pipeline()
  .collection("books")
  .aggregate(field("price").minimum().as("minimumPrice"))
);
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .aggregate(field("price").minimum().as("minimumPrice"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("rating").logicalMinimum([5]).as("cappedRating")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        field("rating").logicalMinimum(5).alias("cappedRating")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("rating").logicalMinimum(5).alias("cappedRating")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("rating").logical_minimum(5).as_("cappedRating"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(logicalMinimum(field("rating"), 5).as("cappedRating"))
        .execute()
        .get();
PipelineSnippets.java

मैप फ़ंक्शन

नाम ब्यौरा
MAP यह फ़ंक्शन, की-वैल्यू पेयर की सीरीज़ से मैप वैल्यू बनाता है
MAP_GET यह फ़ंक्शन, दी गई कुंजी के लिए मैप में मौजूद वैल्यू दिखाता है
MAP_SET अपडेट की गई कुंजियों की सीरीज़ के साथ मैप की कॉपी दिखाता है
MAP_REMOVE यह फ़ंक्शन, मैप की एक कॉपी दिखाता है. इसमें कुंजियों की सीरीज़ हटा दी जाती है
MAP_MERGE यह फ़ंक्शन, मैप की सीरीज़ को एक साथ मर्ज करता है.
CURRENT_CONTEXT मौजूदा कॉन्टेक्स्ट को मैप के तौर पर दिखाता है.
MAP_KEYS यह फ़ंक्शन, किसी मैप में मौजूद सभी कुंजियों का ऐरे दिखाता है.
MAP_VALUES यह फ़ंक्शन, मैप में मौजूद सभी वैल्यू का ऐरे दिखाता है.
MAP_ENTRIES यह फ़ंक्शन, मैप के की-वैल्यू पेयर का ऐरे दिखाता है.

मानचित्र

सिंटैक्स:

map(key: STRING, value: ANY, ...) -> MAP

ब्यौरा:

यह फ़ंक्शन, की-वैल्यू पेयर की सीरीज़ से मैप बनाता है.

MAP_GET

सिंटैक्स:

map_get(map: ANY, key: STRING) -> ANY

ब्यौरा:

यह फ़ंक्शन, दी गई कुंजी के लिए मैप में मौजूद वैल्यू दिखाता है. अगर मैप में key मौजूद नहीं है या map आर्ग्युमेंट MAP नहीं है, तो ABSENT वैल्यू दिखाता है.

Node.js
const result = await db.pipeline()
  .collection("books")
  .select(
    field("awards").mapGet("pulitzer").as("hasPulitzerAward")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("awards").mapGet("pulitzer").as("hasPulitzerAward")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("awards").mapGet("pulitzer").as("hasPulitzerAward")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        field("awards").mapGet("pulitzer").alias("hasPulitzerAward")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("awards").mapGet("pulitzer").alias("hasPulitzerAward")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("awards").map_get("pulitzer").as_("hasPulitzerAward"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(mapGet(field("awards"), "pulitzer").as("hasPulitzerAward"))
        .execute()
        .get();
PipelineSnippets.java

MAP_SET

सिंटैक्स:

map_set(map: MAP, key: STRING, value: ANY, ...) -> MAP

ब्यौरा:

यह फ़ंक्शन, map की कॉपी दिखाता है. इसमें कुंजी-वैल्यू पेयर की सीरीज़ से अपडेट किया गया कॉन्टेंट होता है.

अगर दी गई वैल्यू मौजूद नहीं है, तो मैप से उससे जुड़ी कुंजी हटा दी जाती है.

अगर map आर्ग्युमेंट MAP नहीं है, तो यह फ़ंक्शन मौजूद न होने वाला मान दिखाता है.

MAP_REMOVE

सिंटैक्स:

map_remove(map: MAP, key: STRING...) -> MAP

ब्यौरा:

यह फ़ंक्शन, map वैल्यू की कॉपी दिखाता है. इसमें से कई कुंजियां हटा दी जाती हैं.

MAP_MERGE

सिंटैक्स:

map_merge(maps: MAP...) -> MAP

यह फ़ंक्शन, दो या उससे ज़्यादा मैप के कॉन्टेंट को मर्ज करता है. अगर एक से ज़्यादा मैप में अलग-अलग वैल्यू हैं, तो सबसे बाद वाली वैल्यू का इस्तेमाल किया जाता है.

CURRENT_CONTEXT

सिंटैक्स:

current_context() -> MAP

यह फ़ंक्शन, एक ऐसा मैप दिखाता है जिसमें मौजूदा पॉइंट ऑफ़ एक्ज़ीक्यूशन में मौजूद सभी फ़ील्ड शामिल होते हैं.

MAP_KEYS

सिंटैक्स:

map_keys(map: MAP) -> ARRAY<STRING>

ब्यौरा:

यह फ़ंक्शन, map वैल्यू की सभी कुंजियों वाला एक ऐरे दिखाता है.

MAP_VALUES

सिंटैक्स:

map_values(map: MAP) -> ARRAY<ANY>

ब्यौरा:

यह फ़ंक्शन, map एट्रिब्यूट की सभी वैल्यू वाला एक ऐरे दिखाता है.

MAP_ENTRIES

सिंटैक्स:

map_entries(map: MAP) -> ARRAY<MAP>

ब्यौरा:

यह फ़ंक्शन, map वैल्यू में मौजूद सभी कुंजी-वैल्यू पेयर वाला एक ऐरे दिखाता है.

हर की-वैल्यू पेयर, दो एंट्री वाले मैप के तौर पर होगा: k और v.

उदाहरण:

map map_entries(map)
{} []
{"foo" : 2L} [{"k": "foo", "v" : 2L}]
{"foo" : "bar", "bar" : "foo"} [{"k": "foo", "v" : "bar" }, {"k" : "bar", "v": "foo"}]

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

नाम ब्यौरा
BYTE_LENGTH STRING या BYTES वैल्यू में मौजूद BYTES की संख्या दिखाता है
CHAR_LENGTH किसी STRING वैल्यू में मौजूद यूनिकोड वर्णों की संख्या दिखाता है
STARTS_WITH अगर कोई TRUE, दिए गए प्रीफ़िक्स से शुरू होता है, तो TRUE दिखाता हैSTRING
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" गड़बड़ी

टाइमस्टैंप फ़ंक्शन

नाम ब्यौरा
CURRENT_TIMESTAMP यह अनुरोध के समय के हिसाब से TIMESTAMP जनरेट करता है.
TIMESTAMP_TRUNC यह फ़ंक्शन, किसी TIMESTAMP को दिए गए लेवल के मुताबिक बदल देता है.
UNIX_MICROS_TO_TIMESTAMP यह फ़ंक्शन, 1970-01-01 00:00:00 UTC के बाद से अब तक के माइक्रोसेकंड की संख्या को TIMESTAMP में बदलता है
UNIX_MILLIS_TO_TIMESTAMP यह फ़ंक्शन, 1970-01-01 00:00:00 UTC के बाद से अब तक के मिलीसेकंड की संख्या को TIMESTAMP में बदलता है
UNIX_SECONDS_TO_TIMESTAMP यह फ़ंक्शन, 1970-01-01 00:00:00 UTC के बाद से गुज़रे सेकंड की संख्या को TIMESTAMP में बदलता है
TIMESTAMP_ADD यह फ़ंक्शन, TIMESTAMP में समयावधि जोड़ता है
TIMESTAMP_SUB यह फ़ंक्शन, TIMESTAMP में से समयावधि घटाता है
TIMESTAMP_TO_UNIX_MICROS किसी TIMESTAMP को 1970-01-01 00:00:00 UTC के बाद के माइक्रोसेकंड की संख्या में बदलता है
TIMESTAMP_TO_UNIX_MILLIS यह TIMESTAMP को 1970-01-01 00:00:00 UTC के बाद से अब तक के मिलीसेकंड की संख्या में बदलता है
TIMESTAMP_TO_UNIX_SECONDS यह TIMESTAMP को 1970-01-01 00:00:00 UTC के बाद से सेकंड की संख्या में बदलता है
TIMESTAMP_DIFF यह फ़ंक्शन, दो TIMESTAMP के बीच, तय किए गए unit इंटरवल की पूरी संख्या दिखाता है.
TIMESTAMP_EXTRACT यह फ़ंक्शन, TIMESTAMP से कोई खास part (जैसे, साल, महीना, दिन) निकालता है.

CURRENT_TIMESTAMP

सिंटैक्स:

current_timestamp() -> TIMESTAMP

ब्यौरा:

अनुरोध के समय input की शुरुआत का टाइमस्टैंप मिलता है. इसे 1970-01-01 00:00:00 UTC के बाद से माइक्रोसेकंड की संख्या के तौर पर समझा जाता है.

यह क्वेरी में स्थिर होता है. इसे कई बार कॉल करने पर भी, इसकी वैल्यू हमेशा एक जैसी रहती है.

TIMESTAMP_TRUNC

सिंटैक्स:

timestamp_trunc(timestamp: TIMESTAMP, granularity: STRING[, timezone: STRING]) -> TIMESTAMP

ब्यौरा:

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

granularity आर्ग्युमेंट एक स्ट्रिंग होना चाहिए और इनमें से कोई एक होना चाहिए:

  • microsecond
  • millisecond
  • second
  • minute
  • hour
  • day
  • week
  • week([weekday])
  • month
  • quarter
  • year
  • isoyear

अगर timezone आर्ग्युमेंट दिया गया है, तो तारीख को छोटा करने की प्रोसेस, दिए गए टाइमज़ोन के कैलेंडर की सीमाओं के हिसाब से होगी. उदाहरण के लिए, दिन के हिसाब से तारीख को छोटा करने पर, दिए गए टाइमज़ोन के हिसाब से तारीख को रात 12 बजे पर छोटा कर दिया जाएगा. ट्रंकेट करने के दौरान, डेलाइट सेविंग टाइम का ध्यान रखा जाएगा.

अगर timezone नहीं दिया गया है, तो UTC कैलेंडर की सीमाओं के आधार पर काटा जाएगा.

timezone आर्ग्युमेंट, tz डेटाबेस से किसी टाइमज़ोन का स्ट्रिंग फ़ॉर्मैट होना चाहिए. उदाहरण के लिए, America/New_York. GMT से ऑफ़सेट तय करके, कस्टम टाइम ऑफ़सेट का भी इस्तेमाल किया जा सकता है.

उदाहरण:

timestamp granularity timezone timestamp_trunc(timestamp, granularity, timezone)
2000-01-01 10:20:30:123456 यूटीसी "दूसरा" नहीं दिया गया 2001-01-01 10:20:30 यूटीसी
31-05-1997 04:30:30 यूटीसी "day" नहीं दिया गया 1997-05-31 00:00:00 यूटीसी
31-05-1997 04:30:30 यूटीसी "day" "America/Los_Angeles" 1997-05-30 07:00:00 यूटीसी
16-03-2001 04:00:00 यूटीसी "week(friday) नहीं दिया गया 16-03-2001 00:00:00 यूटीसी
23-03-2001 04:00:00 यूटीसी "week(friday) "America/Los_Angeles" 23-03-2001 17:00:00 यूटीसी
2026-01-24 20:00:00 यूटीसी "महीना" "GMT+06:32:43" 2026-01-01T06:32:43 यूटीसी

UNIX_MICROS_TO_TIMESTAMP

सिंटैक्स:

unix_micros_to_timestamp(input: INT64) -> TIMESTAMP

ब्यौरा:

यह input (1970-01-01 00:00:00 UTC के बाद के माइक्रोसेकंड की संख्या के तौर पर इंटरप्रेट किया जाता है) को TIMESTAMP में बदलता है. अगर input को मान्य TIMESTAMP में नहीं बदला जा सकता, तो error दिखाता है.

उदाहरण:

input unix_micros_to_timestamp(input)
0L 1970-01-01 00:00:00 यूटीसी
400123456L 1970-01-01 00:06:40.123456 यूटीसी
-1000000L 1969-12-31 23:59:59 यूटीसी
Node.js
const result = await db.pipeline()
  .collection("documents")
  .select(
    field("createdAtMicros").unixMicrosToTimestamp().as("createdAtString")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("documents")
  .select(
    field("createdAtMicros").unixMicrosToTimestamp().as("createdAtString")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("documents")
  .select([
    Field("createdAtMicros").unixMicrosToTimestamp().as("createdAtString")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("documents")
    .select(
        field("createdAtMicros").unixMicrosToTimestamp().alias("createdAtString")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("createdAtMicros").unixMicrosToTimestamp().alias("createdAtString")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("documents")
    .select(
        Field.of("createdAtMicros")
        .unix_micros_to_timestamp()
        .as_("createdAtString")
    )
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(unixMicrosToTimestamp(field("createdAtMicros")).as("createdAtString"))
        .execute()
        .get();
PipelineSnippets.java

UNIX_MILLIS_TO_TIMESTAMP

सिंटैक्स:

unix_millis_to_timestamp(input: INT64) -> TIMESTAMP

ब्यौरा:

यह फ़ंक्शन, input (जिसे 1970-01-01 00:00:00 UTC के बाद के मिलीसेकंड की संख्या के तौर पर इंटरप्रेट किया जाता है) को TIMESTAMP में बदलता है. अगर input को मान्य TIMESTAMP में नहीं बदला जा सकता, तो error दिखाता है.

उदाहरण:

input unix_millis_to_timestamp(input)
0L 1970-01-01 00:00:00 यूटीसी
4000123L 1970-01-01 01:06:40.123 यूटीसी
-1000000L 1969-12-31 23:43:20 यूटीसी
Node.js
const result = await db.pipeline()
  .collection("documents")
  .select(
    field("createdAtMillis").unixMillisToTimestamp().as("createdAtString")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("documents")
  .select(
    field("createdAtMillis").unixMillisToTimestamp().as("createdAtString")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("documents")
  .select([
    Field("createdAtMillis").unixMillisToTimestamp().as("createdAtString")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("documents")
    .select(
        field("createdAtMillis").unixMillisToTimestamp().alias("createdAtString")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("createdAtMillis").unixMillisToTimestamp().alias("createdAtString")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("documents")
    .select(
        Field.of("createdAtMillis")
        .unix_millis_to_timestamp()
        .as_("createdAtString")
    )
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(unixMillisToTimestamp(field("createdAtMillis")).as("createdAtString"))
        .execute()
        .get();
PipelineSnippets.java

UNIX_SECONDS_TO_TIMESTAMP

सिंटैक्स:

unix_seconds_to_timestamp(input: INT64) -> TIMESTAMP

ब्यौरा:

यह input (1970-01-01 00:00:00 UTC के बाद के सेकंड की संख्या के तौर पर इंटरप्रेट किया जाता है) को TIMESTAMP में बदलता है. अगर input को मान्य TIMESTAMP में नहीं बदला जा सकता, तो error दिखाता है.

उदाहरण:

input unix_seconds_to_timestamp(input)
0L 1970-01-01 00:00:00 यूटीसी
60L 1970-01-01 00:01:00 यूटीसी
-300L 1969-12-31 23:55:00 यूटीसी
Node.js
const result = await db.pipeline()
  .collection("documents")
  .select(
    field("createdAtSeconds").unixSecondsToTimestamp().as("createdAtString")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("documents")
  .select(
    field("createdAtSeconds").unixSecondsToTimestamp().as("createdAtString")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("documents")
  .select([
    Field("createdAtSeconds").unixSecondsToTimestamp().as("createdAtString")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("documents")
    .select(
        field("createdAtSeconds").unixSecondsToTimestamp().alias("createdAtString")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("createdAtSeconds").unixSecondsToTimestamp().alias("createdAtString")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("documents")
    .select(
        Field.of("createdAtSeconds")
        .unix_seconds_to_timestamp()
        .as_("createdAtString")
    )
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(unixSecondsToTimestamp(field("createdAtSeconds")).as("createdAtString"))
        .execute()
        .get();
PipelineSnippets.java

TIMESTAMP_ADD

सिंटैक्स:

timestamp_add(timestamp: TIMESTAMP, unit: STRING, amount: INT64) -> TIMESTAMP

ब्यौरा:

timestamp से unit का amount जोड़ता है. amount आर्ग्युमेंट नेगेटिव हो सकता है. इस मामले में, यह TIMESTAMP_SUB के बराबर होता है.

unit आर्ग्युमेंट एक स्ट्रिंग होना चाहिए और इनमें से कोई एक होना चाहिए:

  • microsecond
  • millisecond
  • second
  • minute
  • hour
  • day

अगर टाइमस्टैंप, TIMESTAMP रेंज में नहीं आता है, तो यह फ़ंक्शन गड़बड़ी दिखाता है.

उदाहरण:

timestamp unit amount timestamp_add(timestamp, unit, amount)
2025-02-20 00:00:00 यूटीसी "minute" 2L 2025-02-20 00:02:00 यूटीसी
2025-02-20 00:00:00 यूटीसी "घंटा" -4L 2025-02-19 20:00:00 यूटीसी
2025-02-20 00:00:00 यूटीसी "day" 5 ली॰ 25-02-2025 00:00:00 यूटीसी
Node.js
const result = await db.pipeline()
  .collection("documents")
  .select(
    field("createdAt").timestampAdd("day", 3653).as("expiresAt")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("documents")
  .select(
    field("createdAt").timestampAdd("day", 3653).as("expiresAt")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("documents")
  .select([
    Field("createdAt").timestampAdd(3653, .day).as("expiresAt")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("documents")
    .select(
        field("createdAt")
          .timestampAdd("day", 3653)
          .alias("expiresAt")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("createdAt").timestampAdd("day", 3653).alias("expiresAt")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("documents")
    .select(Field.of("createdAt").timestamp_add("day", 3653).as_("expiresAt"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(timestampAdd(field("createdAt"), "day", 3653).as("expiresAt"))
        .execute()
        .get();
PipelineSnippets.java

TIMESTAMP_SUB

सिंटैक्स:

timestamp_sub(timestamp: TIMESTAMP, unit: STRING, amount: INT64) -> TIMESTAMP

ब्यौरा:

timestamp में से unit का amount घटाता है. amount आर्ग्युमेंट की वैल्यू नेगेटिव हो सकती है. इस मामले में, यह TIMESTAMP_ADD के बराबर होता है.

unit आर्ग्युमेंट एक स्ट्रिंग होना चाहिए और इनमें से कोई एक होना चाहिए:

  • microsecond
  • millisecond
  • second
  • minute
  • hour
  • day

अगर टाइमस्टैंप, TIMESTAMP रेंज में नहीं आता है, तो यह फ़ंक्शन गड़बड़ी दिखाता है.

उदाहरण:

timestamp unit amount timestamp_sub(timestamp, unit, amount)
04-07-2026 00:00:00 यूटीसी "minute" 40L 2026-07-03 23:20:00 यूटीसी
04-07-2026 00:00:00 यूटीसी "घंटा" -24L 05-07-2026 00:00:00 यूटीसी
04-07-2026 00:00:00 यूटीसी "day" 3L 2026-07-01 00:00:00 यूटीसी
Node.js
const result = await db.pipeline()
  .collection("documents")
  .select(
    field("expiresAt").timestampSubtract("day", 14).as("sendWarningTimestamp")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("documents")
  .select(
    field("expiresAt").timestampSubtract("day", 14).as("sendWarningTimestamp")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("documents")
  .select([
    Field("expiresAt").timestampSubtract(14, .day).as("sendWarningTimestamp")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("documents")
    .select(
        field("expiresAt")
          .timestampSubtract("day", 14)
          .alias("sendWarningTimestamp")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("expiresAt").timestampSubtract("day", 14).alias("sendWarningTimestamp")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("documents")
    .select(
        Field.of("expiresAt")
        .timestamp_subtract("day", 14)
        .as_("sendWarningTimestamp")
    )
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(timestampSubtract(field("expiresAt"), "day", 14).as("sendWarningTimestamp"))
        .execute()
        .get();
PipelineSnippets.java

TIMESTAMP_TO_UNIX_MICROS

सिंटैक्स:

timestamp_to_unix_micros(input: TIMESTAMP) -> INT64

ब्यौरा:

यह input को 1970-01-01 00:00:00 UTC के बाद से अब तक के माइक्रोसेकंड की संख्या में बदलता है. यह माइक्रोसेकंड की शुरुआत में राउंड डाउन करके, ज़्यादा सटीक वैल्यू को छोटा करता है.

उदाहरण:

input timestamp_to_unix_micros(input)
1970-01-01 00:00:00 यूटीसी 0L
1970-01-01 00:06:40.123456 यूटीसी 400123456L
1969-12-31 23:59:59 यूटीसी -1000000L
Node.js
const result = await db.pipeline()
  .collection("documents")
  .select(
    field("dateString").timestampToUnixMicros().as("unixMicros")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("documents")
  .select(
    field("dateString").timestampToUnixMicros().as("unixMicros")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("documents")
  .select([
    Field("dateString").timestampToUnixMicros().as("unixMicros")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("documents")
    .select(
        field("dateString").timestampToUnixMicros().alias("unixMicros")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("dateString").timestampToUnixMicros().alias("unixMicros")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("documents")
    .select(Field.of("dateString").timestamp_to_unix_micros().as_("unixMicros"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(timestampToUnixMicros(field("dateString")).as("unixMicros"))
        .execute()
        .get();
PipelineSnippets.java

TIMESTAMP_TO_UNIX_MILLIS

सिंटैक्स:

timestamp_to_unix_millis(input: TIMESTAMP) -> INT64

ब्यौरा:

यह input को 1970-01-01 00:00:00 UTC के बाद से मिलीसेकंड की संख्या में बदलता है. यह मिलीसेकंड की शुरुआत में राउंड डाउन करके, ज़्यादा सटीक लेवल को छोटा करता है.

उदाहरण:

input timestamp_to_unix_millis(input)
1970-01-01 00:00:00 यूटीसी 0L
1970-01-01 01:06:40.123 यूटीसी 4000123L
1969-12-31 23:43:20 -1000000L
Node.js
const result = await db.pipeline()
  .collection("documents")
  .select(
    field("dateString").timestampToUnixMillis().as("unixMillis")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("documents")
  .select(
    field("dateString").timestampToUnixMillis().as("unixMillis")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("documents")
  .select([
    Field("dateString").timestampToUnixMillis().as("unixMillis")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("documents")
    .select(
        field("dateString").timestampToUnixMillis().alias("unixMillis")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("dateString").timestampToUnixMillis().alias("unixMillis")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("documents")
    .select(Field.of("dateString").timestamp_to_unix_millis().as_("unixMillis"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(timestampToUnixMillis(field("dateString")).as("unixMillis"))
        .execute()
        .get();
PipelineSnippets.java

TIMESTAMP_TO_UNIX_SECONDS

सिंटैक्स:

timestamp_to_unix_seconds(input: TIMESTAMP) -> INT64

ब्यौरा:

यह फ़ंक्शन, input को 1970-01-01 00:00:00 UTC के बाद से गुज़रे सेकंड की संख्या में बदलता है. यह सेकंड की शुरुआत में राउंड डाउन करके, ज़्यादा सटीक वैल्यू को छोटा करता है.

उदाहरण:

input timestamp_to_unix_seconds(input)
1970-01-01 00:00:00 यूटीसी 0L
1970-01-01 00:01:00 यूटीसी 60L
1969-12-31 23:55:00 यूटीसी -300L
Node.js
const result = await db.pipeline()
  .collection("documents")
  .select(
    field("dateString").timestampToUnixSeconds().as("unixSeconds")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("documents")
  .select(
    field("dateString").timestampToUnixSeconds().as("unixSeconds")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("documents")
  .select([
    Field("dateString").timestampToUnixSeconds().as("unixSeconds")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("documents")
    .select(
        field("dateString").timestampToUnixSeconds().alias("unixSeconds")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("documents")
    .select(
        field("dateString").timestampToUnixSeconds().alias("unixSeconds")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("documents")
    .select(Field.of("dateString").timestamp_to_unix_seconds().as_("unixSeconds"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("documents")
        .select(timestampToUnixSeconds(field("dateString")).as("unixSeconds"))
        .execute()
        .get();
PipelineSnippets.java

TIMESTAMP_DIFF

सिंटैक्स:

timestamp_diff(end: TIMESTAMP, start: TIMESTAMP, unit: STRING) -> INT64

ब्यौरा:

यह फ़ंक्शन, दो TIMESTAMP के बीच, तय किए गए unit इंटरवल की पूरी संख्या दिखाता है.

  • अगर end, start से पहले की तारीख है, तो यह फ़ंक्शन नेगेटिव वैल्यू दिखाता है.
  • यह फ़ंक्शन, किसी भी फ़्रैक्शनल यूनिट को छोटा करता है. उदाहरण के लिए, timestamp_diff("2021-01-01 00:00:01", "2021-01-01 00:00:00", "minute") से, नतीजे के तौर पर 0 मिलता है.

unit आर्ग्युमेंट एक स्ट्रिंग होना चाहिए और इनमें से कोई एक होना चाहिए:

  • microsecond
  • millisecond
  • second
  • minute
  • hour
  • day

उदाहरण:

end start unit timestamp_diff(end, start, unit)
04-07-2026 00:01:00 यूटीसी 04-07-2026 00:00:00 यूटीसी "दूसरा" 60L
04-07-2026 00:00:00 यूटीसी 05-07-2026 00:00:00 यूटीसी "day" -1L
2026-07-04 00:00:59 यूटीसी 04-07-2026 00:00:00 यूटीसी "minute" 0L

TIMESTAMP_EXTRACT

सिंटैक्स:

timestamp_extract(timestamp: TIMESTAMP, part: STRING[, timezone: STRING]) -> INT64

ब्यौरा:

timestamp से किसी खास part (जैसे, साल, महीना, दिन) को निकालता है.

part आर्ग्युमेंट एक स्ट्रिंग होना चाहिए और इनमें से कोई एक होना चाहिए:

  • microsecond
  • millisecond
  • second
  • minute
  • hour
  • day
  • dayofweek: यह वैल्यू की जानकारी देता है, जो 1 (रविवार) से 7 (शनिवार) के बीच होती है.
  • dayofyear
  • week: यह साल के हफ़्ते की संख्या दिखाता है. साल के पहले रविवार से इसकी गिनती शुरू होती है.
  • week([weekday]): यह साल के हफ़्ते की संख्या दिखाता है. इसकी शुरुआत, बताई गई weekday से होती है.
  • month
  • quarter
  • year
  • isoweek: यह ISO 8601 के हिसाब से हफ़्ते की संख्या दिखाता है.
  • isoyear: यह ISO 8601 के हिसाब से हफ़्ते की संख्या वाला साल दिखाता है.

अगर timezone आर्ग्युमेंट दिया जाता है, तो एक्सट्रैक्शन, दिए गए टाइमज़ोन के कैलेंडर के हिसाब से होगा. डेटा निकालते समय, डेलाइट सेविंग टाइम का ध्यान रखा जाएगा.

अगर timezone नहीं दिया गया है, तो जानकारी UTC के आधार पर निकाली जाएगी.

timezone आर्ग्युमेंट, टाइमज़ोन डेटाबेस से किसी टाइमज़ोन का स्ट्रिंग रिप्रेजेंटेशन होना चाहिए. उदाहरण के लिए, America/New_York. GMT से ऑफ़सेट तय करके, कस्टम टाइम ऑफ़सेट का इस्तेमाल भी किया जा सकता है.

उदाहरण:

timestamp part timezone timestamp_extract(timestamp, part, timezone)
2025-02-20 10:20:30 यूटीसी "year" नहीं दिया गया 2025
2025-02-20 10:20:30 यूटीसी "day" नहीं दिया गया 20
2025-12-31 23:59:59 यूटीसी "year" "Asia/Tokyo" 2026

टाइप फ़ंक्शन

नाम ब्यौरा
TYPE STRING के तौर पर वैल्यू का टाइप दिखाता है.
IS_TYPE अगर वैल्यू, तय किए गए टाइप से मेल खाती है, तो true दिखाता है.

प्रकार

सिंटैक्स:

type(input: ANY) -> STRING

ब्यौरा:

input टाइप का स्ट्रिंग वर्शन दिखाता है.

अगर कोई वैल्यू मौजूद नहीं है, तो NULL दिखाता है.

उदाहरण:

input type(input)
NULL "null"
सही "बूलियन"
1 "int32"
-3L "int64"
3.14 "float64"
01-01-2024T00:00:00Z यूटीसी "टाइमस्टैंप"
"foo" "स्ट्रिंग"
b"foo" "बाइट"
[1, 2] "array"
{"a": 1} "map"
path("c/d") "रेफ़रंस"
vector([1.0, 2.0]) "vector"
ABSENT NULL

क्लाइंट के उदाहरण

Node.js
const result = await db.pipeline()
  .collection("books")
  .select(field("title").notEqual("1984").as("not1984"))
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("title").notEqual("1984").as("not1984"))
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("title").notEqual("1984").as("not1984")])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(field("title").notEqual("1984").alias("not1984"))
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("title").notEqual("1984").alias("not1984"))
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("title").not_equal("1984").as_("not1984"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(notEqual(field("title"), "1984").as("not1984"))
        .execute()
        .get();
PipelineSnippets.java

IS_TYPE

सिंटैक्स:

is_type(input: ANY, type: STRING) -> BOOLEAN

ब्यौरा:

अगर input, तय किए गए type से मेल खाता है, तो true दिखाता है. ऐसा न होने पर, false दिखाता है. अगर input मौजूद नहीं है, तो NULL दिखाता है.

type के लिए इन स्ट्रिंग का इस्तेमाल किया जा सकता है:

  • "null"
  • "boolean"
  • "int32"
  • "int64"
  • "float64"
  • "decimal128"
  • "number"
  • "timestamp"
  • "string"
  • "bytes"
  • "array"
  • "map"
  • "reference"
  • "vector"
  • "geo_point"
  • "max_key"
  • "min_key"
  • "object_id"
  • "regex"
  • "bson_timestamp"

उदाहरण:

input type is_type(input, type)
NULL "null" सही
सही "बूलियन" सही
3.14 "float64" सही
"foo" "स्ट्रिंग" सही
b"foo" "स्ट्रिंग" गलत
[1, 2] "array" सही
{"a": 1} "map" सही
vector([1.0, 2.0]) "vector" सही
ABSENT "स्ट्रिंग" NULL
"bar" "अन्य" गड़बड़ी

वेक्टर फ़ंक्शन

नाम ब्यौरा
COSINE_DISTANCE यह फ़ंक्शन, दो वेक्टर के बीच की कोसाइन दूरी दिखाता है
DOT_PRODUCT यह फ़ंक्शन, दो वेक्टर के बीच के डॉट प्रॉडक्ट को दिखाता है
EUCLIDEAN_DISTANCE यह फ़ंक्शन, दो वेक्टर के बीच की यूक्लिडियन दूरी दिखाता है
MANHATTAN_DISTANCE यह फ़ंक्शन, दो वेक्टर के बीच की मैनहैटन दूरी दिखाता है
VECTOR_LENGTH यह फ़ंक्शन, किसी वेक्टर में मौजूद एलिमेंट की संख्या दिखाता है

COSINE_DISTANCE

सिंटैक्स:

cosine_distance(x: VECTOR, y: VECTOR) -> FLOAT64

ब्यौरा:

यह फ़ंक्शन, x और y के बीच की कोसाइन दूरी दिखाता है.

Node.js
const sampleVector = [0.0, 1, 2, 3, 4, 5];
const result = await db.pipeline()
  .collection("books")
  .select(
    field("embedding").cosineDistance(sampleVector).as("cosineDistance")
  )
  .execute();
test.firestore.js

Web

const sampleVector = [0.0, 1, 2, 3, 4, 5];
const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("embedding").cosineDistance(sampleVector).as("cosineDistance")));
test.firestore.js
Swift
let sampleVector = [0.0, 1, 2, 3, 4, 5]
let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("embedding").cosineDistance(sampleVector).as("cosineDistance")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val sampleVector = doubleArrayOf(0.0, 1.0, 2.0, 3.0, 4.0, 5.0)
val result = db.pipeline()
    .collection("books")
    .select(
        field("embedding").cosineDistance(sampleVector).alias("cosineDistance")
    )
    .execute()
DocSnippets.kt

Java

double[] sampleVector = {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("embedding").cosineDistance(sampleVector).alias("cosineDistance")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field
from google.cloud.firestore_v1.vector import Vector

sample_vector = Vector([0.0, 1.0, 2.0, 3.0, 4.0, 5.0])
result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("embedding").cosine_distance(sample_vector).as_("cosineDistance")
    )
    .execute()
)
firestore_pipelines.py
Java
double[] sampleVector = new double[] {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(cosineDistance(field("embedding"), sampleVector).as("cosineDistance"))
        .execute()
        .get();
PipelineSnippets.java

DOT_PRODUCT

सिंटैक्स:

dot_product(x: VECTOR, y: VECTOR) -> FLOAT64

ब्यौरा:

x और y का डॉट प्रॉडक्ट दिखाता है.

Node.js
const sampleVector = [0.0, 1, 2, 3, 4, 5];
const result = await db.pipeline()
  .collection("books")
  .select(
    field("embedding").dotProduct(sampleVector).as("dotProduct")
  )
  .execute();
test.firestore.js

Web

const sampleVector = [0.0, 1, 2, 3, 4, 5];
const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("embedding").dotProduct(sampleVector).as("dotProduct")
  )
);
test.firestore.js
Swift
let sampleVector = [0.0, 1, 2, 3, 4, 5]
let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("embedding").dotProduct(sampleVector).as("dotProduct")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val sampleVector = doubleArrayOf(0.0, 1.0, 2.0, 3.0, 4.0, 5.0)
val result = db.pipeline()
    .collection("books")
    .select(
        field("embedding").dotProduct(sampleVector).alias("dotProduct")
    )
    .execute()
DocSnippets.kt

Java

double[] sampleVector = {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("embedding").dotProduct(sampleVector).alias("dotProduct")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field
from google.cloud.firestore_v1.vector import Vector

sample_vector = Vector([0.0, 1.0, 2.0, 3.0, 4.0, 5.0])
result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("embedding").dot_product(sample_vector).as_("dotProduct"))
    .execute()
)
firestore_pipelines.py
Java
double[] sampleVector = new double[] {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(dotProduct(field("embedding"), sampleVector).as("dotProduct"))
        .execute()
        .get();
PipelineSnippets.java

EUCLIDEAN_DISTANCE

सिंटैक्स:

euclidean_distance(x: VECTOR, y: VECTOR) -> FLOAT64

ब्यौरा:

यह फ़ंक्शन, x और y के बीच की यूक्लिडियन दूरी का हिसाब लगाता है.

Node.js
const sampleVector = [0.0, 1, 2, 3, 4, 5];
const result = await db.pipeline()
  .collection("books")
  .select(
    field("embedding").euclideanDistance(sampleVector).as("euclideanDistance")
  )
  .execute();
test.firestore.js

Web

const sampleVector = [0.0, 1, 2, 3, 4, 5];
const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("embedding").euclideanDistance(sampleVector).as("euclideanDistance")
  )
);
test.firestore.js
Swift
let sampleVector = [0.0, 1, 2, 3, 4, 5]
let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("embedding").euclideanDistance(sampleVector).as("euclideanDistance")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val sampleVector = doubleArrayOf(0.0, 1.0, 2.0, 3.0, 4.0, 5.0)
val result = db.pipeline()
    .collection("books")
    .select(
        field("embedding").euclideanDistance(sampleVector).alias("euclideanDistance")
    )
    .execute()
DocSnippets.kt

Java

double[] sampleVector = {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("embedding").euclideanDistance(sampleVector).alias("euclideanDistance")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field
from google.cloud.firestore_v1.vector import Vector

sample_vector = Vector([0.0, 1.0, 2.0, 3.0, 4.0, 5.0])
result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("embedding")
        .euclidean_distance(sample_vector)
        .as_("euclideanDistance")
    )
    .execute()
)
firestore_pipelines.py
Java
double[] sampleVector = new double[] {0.0, 1.0, 2.0, 3.0, 4.0, 5.0};
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(euclideanDistance(field("embedding"), sampleVector).as("euclideanDistance"))
        .execute()
        .get();
PipelineSnippets.java

MANHATTAN_DISTANCE

सिंटैक्स:

manhattan_distance(x: VECTOR, y: VECTOR) -> FLOAT64

ब्यौरा:

यह फ़ंक्शन, x और y के बीच की मैनहैटन दूरी का हिसाब लगाता है.

VECTOR_LENGTH

सिंटैक्स:

vector_length(vector: VECTOR) -> INT64

ब्यौरा:

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

Node.js
const result = await db.pipeline()
  .collection("books")
  .select(
    field("embedding").vectorLength().as("vectorLength")
  )
  .execute();
test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("embedding").vectorLength().as("vectorLength")
  )
);
test.firestore.js
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("embedding").vectorLength().as("vectorLength")
  ])
  .execute()
PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        field("embedding").vectorLength().alias("vectorLength")
    )
    .execute()
DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("embedding").vectorLength().alias("vectorLength")
    )
    .execute();
DocSnippets.java
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("embedding").vector_length().as_("vectorLength"))
    .execute()
)
firestore_pipelines.py
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(vectorLength(field("embedding")).as("vectorLength"))
        .execute()
        .get();
PipelineSnippets.java