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();
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")) );
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()
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()
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();
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() )
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();
जाएं
// Total number of books in the collection countAll, err := client.Pipeline().Collection("books"). Aggregate(firestore.Accumulators(firestore.CountAll().As("count"))). Execute(ctx).Results().GetAll() if err != nil { fmt.Fprintf(w, "GetAll failed: %v", err) return err } // Number of books with nonnull `ratings` field countField, err := client.Pipeline(). Collection("books"). Aggregate(firestore.Accumulators(firestore.Count("ratings").As("count"))). Execute(ctx).Results().GetAll() if err != nil { fmt.Fprintf(w, "GetAll failed: %v", err) return err }
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();
Web
const result = await execute(db.pipeline() .collection("books") .aggregate( field("rating").greaterThan(4).countIf().as("filteredCount") ) );
Swift
let result = try await db.pipeline() .collection("books") .aggregate([ AggregateFunction("count_if", [Field("rating").greaterThan(4)]).as("filteredCount") ]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .aggregate( AggregateFunction.countIf(field("rating").greaterThan(4)).alias("filteredCount") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .aggregate( AggregateFunction.countIf(field("rating").greaterThan(4)).alias("filteredCount") ) .execute();
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() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .aggregate(countIf(field("rating").greaterThan(4)).as("filteredCount")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Aggregate(firestore.Accumulators( firestore.CountIf(firestore.FieldOf("rating").GreaterThan(4)).As("filteredCount"), )). Execute(ctx)
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();
Web
const result = await execute(db.pipeline() .collection("books") .aggregate(field("author").countDistinct().as("unique_authors")) );
Swift
let result = try await db.pipeline() .collection("books") .aggregate([AggregateFunction("count_distinct", [Field("author")]).as("unique_authors")]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .aggregate(AggregateFunction.countDistinct("author").alias("unique_authors")) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .aggregate(AggregateFunction.countDistinct("author").alias("unique_authors")) .execute();
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() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .aggregate(countDistinct("author").as("unique_authors")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Aggregate(firestore.Accumulators( firestore.CountDistinct("author").As("unique_authors"), )). Execute(ctx)
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();
Web
const result = await execute(db.pipeline() .collection("cities") .aggregate(field("population").sum().as("totalPopulation")) );
Swift
let result = try await db.pipeline() .collection("cities") .aggregate([Field("population").sum().as("totalPopulation")]) .execute()
Kotlin
val result = db.pipeline() .collection("cities") .aggregate(AggregateFunction.sum("population").alias("totalPopulation")) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("cities") .aggregate(AggregateFunction.sum("population").alias("totalPopulation")) .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field result = ( client.pipeline() .collection("cities") .aggregate(Field.of("population").sum().as_("totalPopulation")) .execute() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("cities") .aggregate(sum("population").as("totalPopulation")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("cities"). Aggregate(firestore.Accumulators( firestore.Sum("population").As("totalPopulation"), )). Execute(ctx)
औसत
सिंटैक्स:
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();
Web
const result = await execute(db.pipeline() .collection("cities") .aggregate(field("population").average().as("averagePopulation")) );
Swift
let result = try await db.pipeline() .collection("cities") .aggregate([Field("population").average().as("averagePopulation")]) .execute()
Kotlin
val result = db.pipeline() .collection("cities") .aggregate(AggregateFunction.average("population").alias("averagePopulation")) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("cities") .aggregate(AggregateFunction.average("population").alias("averagePopulation")) .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field result = ( client.pipeline() .collection("cities") .aggregate(Field.of("population").average().as_("averagePopulation")) .execute() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("cities") .aggregate(average("population").as("averagePopulation")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("cities"). Aggregate(firestore.Accumulators( firestore.Average("population").As("averagePopulation"), )). Execute(ctx)
MINIMUM
सिंटैक्स:
minimum(expression: ANY) -> ANY
ब्यौरा:
यह फ़ंक्शन, हर दस्तावेज़ का आकलन करने पर, expression की सबसे छोटी ऐसी वैल्यू दिखाता है जो NULL और मौजूद नहीं है के तौर पर मार्क नहीं की गई है.
अगर कोई भी वैल्यू NULL या मौजूद नहीं है, तो NULL दिखता है. इसमें ऐसे मामले भी शामिल हैं जिनमें कोई दस्तावेज़ नहीं माना जाता.
अगर एक से ज़्यादा वैल्यू, कम से कम वैल्यू के बराबर हैं, तो उनमें से कोई भी वैल्यू दिखाई जा सकती है. वैल्यू टाइप का क्रम, दस्तावेज़ में दिए गए क्रम के मुताबिक होता है.
Node.js
const result = await db.pipeline() .collection("books") .aggregate(field("price").minimum().as("minimumPrice")) .execute();
Web
const result = await execute(db.pipeline() .collection("books") .aggregate(field("price").minimum().as("minimumPrice")) );
Swift
let result = try await db.pipeline() .collection("books") .aggregate([Field("price").minimum().as("minimumPrice")]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .aggregate(AggregateFunction.minimum("price").alias("minimumPrice")) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .aggregate(AggregateFunction.minimum("price").alias("minimumPrice")) .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field result = ( client.pipeline() .collection("books") .aggregate(Field.of("price").minimum().as_("minimumPrice")) .execute() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .aggregate(minimum("price").as("minimumPrice")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Aggregate(firestore.Accumulators( firestore.Minimum("price").As("minimumPrice"), )). Execute(ctx)
MAXIMUM
सिंटैक्स:
maximum(expression: ANY) -> ANY
ब्यौरा:
यह फ़ंक्शन, हर दस्तावेज़ का आकलन करने पर, expression की सबसे बड़ी ऐसी वैल्यू दिखाता है जो NULL नहीं है और मौजूद है.
अगर कोई भी वैल्यू NULL या मौजूद नहीं है, तो NULL दिखता है. इसमें ऐसे मामले भी शामिल हैं जिनमें कोई दस्तावेज़ नहीं माना जाता.
अगर सबसे बड़ी वैल्यू एक से ज़्यादा हैं, तो उनमें से कोई भी वैल्यू दिखाई जा सकती है. वैल्यू टाइप का क्रम, दस्तावेज़ में दिए गए क्रम के मुताबिक होता है.
Node.js
const result = await db.pipeline() .collection("books") .aggregate(field("price").maximum().as("maximumPrice")) .execute();
Web
const result = await execute(db.pipeline() .collection("books") .aggregate(field("price").maximum().as("maximumPrice")) );
Swift
let result = try await db.pipeline() .collection("books") .aggregate([Field("price").maximum().as("maximumPrice")]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .aggregate(AggregateFunction.maximum("price").alias("maximumPrice")) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .aggregate(AggregateFunction.maximum("price").alias("maximumPrice")) .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field result = ( client.pipeline() .collection("books") .aggregate(Field.of("price").maximum().as_("maximumPrice")) .execute() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .aggregate(maximum("price").as("maximumPrice")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Aggregate(firestore.Accumulators( firestore.Maximum("price").As("maximumPrice"), )). Execute(ctx)
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दिखाता है. - अगर ओवरफ़्लो या अंडरफ़्लो होता है, तो यह फ़ंक्शन गड़बड़ी जनरेट करता है.
Cloud Firestore, संख्यात्मक टाइप को बड़ा करने की सुविधा देता है. यह सुविधा, इस क्रम के हिसाब से काम करती है: INT32 < INT64 < FLOAT64 < DECIMAL128. जब कोई अंकगणितीय फ़ंक्शन, अलग-अलग टाइप के कई संख्यात्मक आर्ग्युमेंट लेता है (उदाहरण के लिए, add(5.0D, 6L)), तो छोटे टाइप के आर्ग्युमेंट को ऑपरेंड में मौजूद सबसे बड़े टाइप में बदल दिया जाता है. पिछले उदाहरण में, 6L को 6.0D तक बढ़ाया गया है. इससे एक्सप्रेशन, FLOAT64 टाइप दिखाता है.
INT64 -> FLOAT64 से मिलने वाली वैल्यू में, सबसे कम अहम बिट्स की जानकारी नहीं होती. इसलिए, इससे सटीक जानकारी नहीं मिलती. इससे मिलने वाली वैल्यू, मूल पूर्णांक वैल्यू का राउंड किया गया वर्शन होगा. इसके लिए, IEEE 754 के राउंड-टू-नियरेस्ट मोड का इस्तेमाल किया जाएगा.
| नाम | ब्यौरा |
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 |
| 10L | 10L |
| -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();
Web
const result = await execute(db.pipeline() .collection("books") .select(field("soldBooks").add(field("unsoldBooks")).as("totalBooks")) );
Swift
let result = try await db.pipeline() .collection("books") .select([Field("soldBooks").add(Field("unsoldBooks")).as("totalBooks")]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select(Expression.add(field("soldBooks"), field("unsoldBooks")).alias("totalBooks")) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select(Expression.add(field("soldBooks"), field("unsoldBooks")).alias("totalBooks")) .execute();
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() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(add(field("soldBooks"), field("unsoldBooks")).as("totalBooks")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.Add(firestore.FieldOf("soldBooks"), firestore.FieldOf("unsoldBooks")).As("totalBooks"), )). Execute(ctx)
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();
Web
const storeCredit = 7; const result = await execute(db.pipeline() .collection("books") .select(field("price").subtract(constant(storeCredit)).as("totalCost")) );
Swift
let storeCredit = 7 let result = try await db.pipeline() .collection("books") .select([Field("price").subtract(Constant(storeCredit)).as("totalCost")]) .execute()
Kotlin
val storeCredit = 7 val result = db.pipeline() .collection("books") .select(Expression.subtract(field("price"), storeCredit).alias("totalCost")) .execute()
Java
int storeCredit = 7; Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select(Expression.subtract(field("price"), storeCredit).alias("totalCost")) .execute();
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() )
Java
int storeCredit = 7; Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(subtract(field("price"), storeCredit).as("totalCost")) .execute() .get();
जाएं
storeCredit := 7 snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.Subtract(firestore.FieldOf("price"), storeCredit).As("totalCost"), )). Execute(ctx)
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();
Web
const result = await execute(db.pipeline() .collection("books") .select(field("price").multiply(field("soldBooks")).as("revenue")) );
Swift
let result = try await db.pipeline() .collection("books") .select([Field("price").multiply(Field("soldBooks")).as("revenue")]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select(Expression.multiply(field("price"), field("soldBooks")).alias("revenue")) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select(Expression.multiply(field("price"), field("soldBooks")).alias("revenue")) .execute();
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() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(multiply(field("price"), field("soldBooks")).as("revenue")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.Multiply(firestore.FieldOf("price"), firestore.FieldOf("soldBooks")).As("revenue"), )). Execute(ctx)
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();
Web
const result = await execute(db.pipeline() .collection("books") .select(field("ratings").divide(field("soldBooks")).as("reviewRate")) );
Swift
let result = try await db.pipeline() .collection("books") .select([Field("ratings").divide(Field("soldBooks")).as("reviewRate")]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select(Expression.divide(field("ratings"), field("soldBooks")).alias("reviewRate")) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select(Expression.divide(field("ratings"), field("soldBooks")).alias("reviewRate")) .execute();
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() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(divide(field("ratings"), field("soldBooks")).as("reviewRate")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.Divide(firestore.FieldOf("ratings"), firestore.FieldOf("soldBooks")).As("reviewRate"), )). Execute(ctx)
MOD
सिंटैक्स:
mod[N <: INT32 | INT64 | FLOAT64](x: N, y: N) -> N
ब्यौरा:
x / y का शेषफल दिखाता है.
- पूर्णांक टाइप (
INT64) के लिए,yकी वैल्यू शून्य होने पर, यह फ़ंक्शनerrorदिखाता है. - फ़्लोट टाइप (
FLOAT64) के लिए,yशून्य होने परNaNदिखाता है.
उदाहरण:
| 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();
Web
const displayCapacity = 1000; const result = await execute(db.pipeline() .collection("books") .select(field("unsoldBooks").mod(constant(displayCapacity)).as("warehousedBooks")) );
Swift
let displayCapacity = 1000 let result = try await db.pipeline() .collection("books") .select([Field("unsoldBooks").mod(Constant(displayCapacity)).as("warehousedBooks")]) .execute()
Kotlin
val displayCapacity = 1000 val result = db.pipeline() .collection("books") .select(Expression.mod(field("unsoldBooks"), displayCapacity).alias("warehousedBooks")) .execute()
Java
int displayCapacity = 1000; Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select(Expression.mod(field("unsoldBooks"), displayCapacity).alias("warehousedBooks")) .execute();
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() )
Java
int displayCapacity = 1000; Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(mod(field("unsoldBooks"), displayCapacity).as("warehousedBooks")) .execute() .get();
जाएं
displayCapacity := 1000 snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.Mod(firestore.FieldOf("unsoldBooks"), displayCapacity).As("warehousedBooks"), )). Execute(ctx)
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();
Web
const booksPerShelf = 100; const result = await execute(db.pipeline() .collection("books") .select( field("unsoldBooks").divide(constant(booksPerShelf)).ceil().as("requiredShelves") ) );
Swift
let booksPerShelf = 100 let result = try await db.pipeline() .collection("books") .select([ Field("unsoldBooks").divide(Constant(booksPerShelf)).ceil().as("requiredShelves") ]) .execute()
Kotlin
val booksPerShelf = 100 val result = db.pipeline() .collection("books") .select( Expression.divide(field("unsoldBooks"), booksPerShelf).ceil().alias("requiredShelves") ) .execute()
Java
int booksPerShelf = 100; Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select( Expression.divide(field("unsoldBooks"), booksPerShelf).ceil().alias("requiredShelves") ) .execute();
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() )
Java
int booksPerShelf = 100; Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(ceil(divide(field("unsoldBooks"), booksPerShelf)).as("requiredShelves")) .execute() .get();
जाएं
booksPerShelf := 100 snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.Ceil(firestore.Divide(firestore.FieldOf("unsoldBooks"), booksPerShelf)).As("requiredShelves"), )). Execute(ctx)
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();
Web
const result = await execute(db.pipeline() .collection("books") .addFields( field("wordCount").divide(field("pages")).floor().as("wordsPerPage") ) );
Swift
let result = try await db.pipeline() .collection("books") .addFields([ Field("wordCount").divide(Field("pages")).floor().as("wordsPerPage") ]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .addFields( Expression.divide(field("wordCount"), field("pages")).floor().alias("wordsPerPage") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .addFields( Expression.divide(field("wordCount"), field("pages")).floor().alias("wordsPerPage") ) .execute();
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() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .addFields(floor(divide(field("wordCount"), field("pages"))).as("wordsPerPage")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). AddFields(firestore.Selectables( firestore.Floor(firestore.Divide(firestore.FieldOf("wordCount"), firestore.FieldOf("pages"))).As("wordsPerPage"), )). Execute(ctx)
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();
Web
const result = await execute(db.pipeline() .collection("books") .select(field("soldBooks").multiply(field("price")).round().as("partialRevenue")) .aggregate(field("partialRevenue").sum().as("totalRevenue")) );
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()
Kotlin
val result = db.pipeline() .collection("books") .select(Expression.multiply(field("soldBooks"), field("price")).round().alias("partialRevenue")) .aggregate(AggregateFunction.sum("partialRevenue").alias("totalRevenue")) .execute()
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();
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() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(round(multiply(field("soldBooks"), field("price"))).as("partialRevenue")) .aggregate(sum("partialRevenue").as("totalRevenue")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.Round(firestore.Multiply(firestore.FieldOf("soldBooks"), firestore.FieldOf("price"))).As("partialRevenue"), )). Aggregate(firestore.Accumulators( firestore.Sum("partialRevenue").As("totalRevenue"), )). Execute(ctx)
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();
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") ) );
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()
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()
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();
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() )
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();
जाएं
googleplexLat := 37.4221 googleplexLng := -122.0853 snapshot := client.Pipeline(). Collection("cities"). AddFields(firestore.Selectables( firestore.Pow(firestore.Multiply(firestore.Subtract(firestore.FieldOf("lat"), googleplexLat), 111), 2).As("latitudeDifference"), firestore.Pow(firestore.Multiply(firestore.Subtract(firestore.FieldOf("lng"), googleplexLng), 111), 2).As("longitudeDifference"), )). Select(firestore.Fields( firestore.Sqrt(firestore.Add(firestore.FieldOf("latitudeDifference"), firestore.FieldOf("longitudeDifference"))). // Inaccurate for large distances or close to poles As("approximateDistanceToGoogle"), )). Execute(ctx)
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();
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") ) );
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()
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()
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();
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() )
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();
जाएं
googleplexLat := 37.4221 googleplexLng := -122.0853 snapshot := client.Pipeline(). Collection("cities"). AddFields(firestore.Selectables( firestore.Pow(firestore.Multiply(firestore.Subtract(firestore.FieldOf("lat"), googleplexLat), 111), 2).As("latitudeDifference"), firestore.Pow(firestore.Multiply(firestore.Subtract(firestore.FieldOf("lng"), googleplexLng), 111), 2).As("longitudeDifference"), )). Select(firestore.Fields( firestore.Sqrt(firestore.Add(firestore.FieldOf("latitudeDifference"), firestore.FieldOf("longitudeDifference"))). // Inaccurate for large distances or close to poles As("approximateDistanceToGoogle"), )). Execute(ctx)
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();
Web
const result = await execute(db.pipeline() .collection("books") .select(field("rating").exp().as("expRating")) );
Swift
let result = try await db.pipeline() .collection("books") .select([Field("rating").exp().as("expRating")]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select(field("rating").exp().alias("expRating")) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select(field("rating").exp().alias("expRating")) .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field result = ( client.pipeline() .collection("books") .select(Field.of("rating").exp().as_("expRating")) .execute() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(exp(field("rating")).as("expRating")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.Exp(firestore.FieldOf("rating")).As("expRating"), )). Execute(ctx)
एलएन
सिंटैक्स:
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();
Web
const result = await execute(db.pipeline() .collection("books") .select(field("rating").ln().as("lnRating")) );
Swift
let result = try await db.pipeline() .collection("books") .select([Field("rating").ln().as("lnRating")]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select(field("rating").ln().alias("lnRating")) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select(field("rating").ln().alias("lnRating")) .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field result = ( client.pipeline() .collection("books") .select(Field.of("rating").ln().as_("lnRating")) .execute() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(ln(field("rating")).as("lnRating")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.Ln(firestore.FieldOf("rating")).As("lnRating"), )). Execute(ctx)
LOG
सिंटैक्स:
log(number: FLOAT64, base: FLOAT64) -> FLOAT64
log(number: FLOAT64) -> FLOAT64
ब्यौरा:
यह फ़ंक्शन, number का base लॉगरिद्म दिखाता है.
- अगर सिर्फ़
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
|
यह फ़ंक्शन, ARRAY में मौजूद n सबसे छोटी वैल्यू दिखाता है
|
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();
Swift
let result = try await db.pipeline() .collection("books") .select([Field("genre").arrayConcat([Field("subGenre")]).as("allGenres")]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select(field("genre").arrayConcat(field("subGenre")).alias("allGenres")) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select(field("genre").arrayConcat(field("subGenre")).alias("allGenres")) .execute();
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() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(arrayConcat(field("genre"), field("subGenre")).as("allGenres")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.ArrayConcat(firestore.FieldOf("genre"), firestore.FieldOf("subGenre")).As("allGenres"), )). Execute(ctx)
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();
Web
const result = await execute(db.pipeline() .collection("books") .select(field("genre").arrayContains(constant("mystery")).as("isMystery")) );
Swift
let result = try await db.pipeline() .collection("books") .select([Field("genre").arrayContains(Constant("mystery")).as("isMystery")]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select(field("genre").arrayContains("mystery").alias("isMystery")) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select(field("genre").arrayContains("mystery").alias("isMystery")) .execute();
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() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(arrayContains(field("genre"), "mystery").as("isMystery")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.ArrayContains(firestore.FieldOf("genre"), "mystery").As("isMystery"), )). Execute(ctx)
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();
Web
const result = await execute(db.pipeline() .collection("books") .select( field("genre") .arrayContainsAll([constant("fantasy"), constant("adventure")]) .as("isFantasyAdventure") ) );
Swift
let result = try await db.pipeline() .collection("books") .select([ Field("genre") .arrayContainsAll([Constant("fantasy"), Constant("adventure")]) .as("isFantasyAdventure") ]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select( field("genre") .arrayContainsAll(listOf("fantasy", "adventure")) .alias("isFantasyAdventure") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select( field("genre") .arrayContainsAll(Arrays.asList("fantasy", "adventure")) .alias("isFantasyAdventure") ) .execute();
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() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select( arrayContainsAll(field("genre"), Arrays.asList("fantasy", "adventure")) .as("isFantasyAdventure")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.ArrayContainsAll(firestore.FieldOf("genre"), []string{"fantasy", "adventure"}).As("isFantasyAdventure"), )). Execute(ctx)
ARRAY_CONTAINS_ANY
सिंटैक्स:
array_contains_any(array: ARRAY, search_values: ARRAY) -> BOOLEAN
ब्यौरा:
अगर array में कोई भी search_values मिलता है, तो रिस्पॉन्स के तौर पर 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();
Web
const result = await execute(db.pipeline() .collection("books") .select( field("genre") .arrayContainsAny([constant("fantasy"), constant("nonfiction")]) .as("isMysteryOrFantasy") ) );
Swift
let result = try await db.pipeline() .collection("books") .select([ Field("genre") .arrayContainsAny([Constant("fantasy"), Constant("nonfiction")]) .as("isMysteryOrFantasy") ]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select( field("genre") .arrayContainsAny(listOf("fantasy", "nonfiction")) .alias("isMysteryOrFantasy") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select( field("genre") .arrayContainsAny(Arrays.asList("fantasy", "nonfiction")) .alias("isMysteryOrFantasy") ) .execute();
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() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select( arrayContainsAny(field("genre"), Arrays.asList("fantasy", "nonfiction")) .as("isMysteryOrFantasy")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.ArrayContainsAny(firestore.FieldOf("genre"), []string{"fantasy", "nonfiction"}).As("isMysteryOrFantasy"), )). Execute(ctx)
ARRAY_FILTER
सिंटैक्स:
array_filter(array: ARRAY, predicate: (ANY) -> BOOLEAN) -> ARRAY
ब्यौरा:
array एक्सप्रेशन का इस्तेमाल करके predicate को फ़िल्टर करता है. साथ ही, एक नई कैटगरी दिखाता है, जिसमें सिर्फ़ वे एलिमेंट होते हैं जो प्रेडिकेट को पूरा करते हैं.
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 में मौजूद 0 पर आधारित इंडेक्स 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();
Web
const result = await execute(db.pipeline() .collection("books") .select(field("genre").arrayLength().as("genreCount")) );
Swift
let result = try await db.pipeline() .collection("books") .select([Field("genre").arrayLength().as("genreCount")]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select(field("genre").arrayLength().alias("genreCount")) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select(field("genre").arrayLength().alias("genreCount")) .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field result = ( client.pipeline() .collection("books") .select(Field.of("genre").array_length().as_("genreCount")) .execute() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(arrayLength(field("genre")).as("genreCount")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.ArrayLength(firestore.FieldOf("genre")).As("genreCount"), )). Execute(ctx)
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();
Web
const result = await execute(db.pipeline() .collection("books") .select(field("genre").arrayReverse().as("reversedGenres")) );
Swift
let result = try await db.pipeline() .collection("books") .select([Field("genre").arrayReverse().as("reversedGenres")]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select(field("genre").arrayReverse().alias("reversedGenres")) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select(field("genre").arrayReverse().alias("reversedGenres")) .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field result = ( client.pipeline() .collection("books") .select(Field.of("genre").array_reverse().as_("reversedGenres")) .execute() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(arrayReverse(field("genre")).as("reversedGenres")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.ArrayReverse(firestore.FieldOf("genre")).As("reversedGenres"), )). Execute(ctx)
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
ब्यौरा:
यह फ़ंक्शन, array के आखिरी n एलिमेंट दिखाता है.
- अगर
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
सिंटैक्स:
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
सिंटैक्स:
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
ब्यौरा:
यह फ़ंक्शन, n में मौजूद array सबसे छोटी वैल्यू का ऐरे दिखाता है. यह ऐरे, बढ़ते क्रम में होता है.
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] | 3000 |
| [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();
Web
const result = await execute(db.pipeline() .collection("books") .select(field("rating").equal(5).as("hasPerfectRating")) );
Swift
let result = try await db.pipeline() .collection("books") .select([Field("rating").equal(5).as("hasPerfectRating")]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select(field("rating").equal(5).alias("hasPerfectRating")) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select(field("rating").equal(5).alias("hasPerfectRating")) .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field result = ( client.pipeline() .collection("books") .select(Field.of("rating").equal(5).as_("hasPerfectRating")) .execute() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(equal(field("rating"), 5).as("hasPerfectRating")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.Equal(firestore.FieldOf("rating"), 5).As("hasPerfectRating"), )). Execute(ctx)
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();
Web
const result = await execute(db.pipeline() .collection("books") .select(field("rating").greaterThan(4).as("hasHighRating")) );
Swift
let result = try await db.pipeline() .collection("books") .select([Field("rating").greaterThan(4).as("hasHighRating")]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select(field("rating").greaterThan(4).alias("hasHighRating")) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select(field("rating").greaterThan(4).alias("hasHighRating")) .execute();
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() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(greaterThan(field("rating"), 4).as("hasHighRating")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.GreaterThan(firestore.FieldOf("rating"), 4).As("hasHighRating"), )). Execute(ctx)
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();
Web
const result = await execute(db.pipeline() .collection("books") .select(field("published").greaterThanOrEqual(1900).as("publishedIn20thCentury")) );
Swift
let result = try await db.pipeline() .collection("books") .select([Field("published").greaterThanOrEqual(1900).as("publishedIn20thCentury")]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select(field("published").greaterThanOrEqual(1900).alias("publishedIn20thCentury")) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select(field("published").greaterThanOrEqual(1900).alias("publishedIn20thCentury")) .execute();
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() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(greaterThanOrEqual(field("published"), 1900).as("publishedIn20thCentury")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.GreaterThanOrEqual(firestore.FieldOf("published"), 1900).As("publishedIn20thCentury"), )). Execute(ctx)
LESS_THAN
सिंटैक्स:
less_than(x: ANY, y: ANY) -> BOOLEAN
ब्यौरा:
अगर x, y से कम है, तो यह फ़ंक्शन TRUE दिखाता है. अगर ऐसा नहीं है, तो यह 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();
Web
const result = await execute(db.pipeline() .collection("books") .select(field("published").lessThan(1923).as("isPublicDomainProbably")) );
Swift
let result = try await db.pipeline() .collection("books") .select([Field("published").lessThan(1923).as("isPublicDomainProbably")]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select(field("published").lessThan(1923).alias("isPublicDomainProbably")) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select(field("published").lessThan(1923).alias("isPublicDomainProbably")) .execute();
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() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(lessThan(field("published"), 1923).as("isPublicDomainProbably")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.LessThan(firestore.FieldOf("published"), 1923).As("isPublicDomainProbably"), )). Execute(ctx)
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();
Web
const result = await execute(db.pipeline() .collection("books") .select(field("rating").lessThanOrEqual(2).as("hasBadRating")) );
Swift
let result = try await db.pipeline() .collection("books") .select([Field("rating").lessThanOrEqual(2).as("hasBadRating")]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select(field("rating").lessThanOrEqual(2).alias("hasBadRating")) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select(field("rating").lessThanOrEqual(2).alias("hasBadRating")) .execute();
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() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(lessThanOrEqual(field("rating"), 2).as("hasBadRating")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.LessThanOrEqual(firestore.FieldOf("rating"), 2).As("hasBadRating"), )). Execute(ctx)
NOT_EQUAL
सिंटैक्स:
not_equal(x: ANY, y: ANY) -> BOOLEAN
ब्यौरा:
अगर x, y के बराबर नहीं है, तो TRUE दिखाता है. अगर , के बराबर है, तो 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();
Web
const result = await execute(db.pipeline() .collection("books") .select(field("title").notEqual("1984").as("not1984")) );
Swift
let result = try await db.pipeline() .collection("books") .select([Field("title").notEqual("1984").as("not1984")]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select(field("title").notEqual("1984").alias("not1984")) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select(field("title").notEqual("1984").alias("not1984")) .execute();
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() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(notEqual(field("title"), "1984").as("not1984")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.NotEqual(firestore.FieldOf("title"), "1984").As("not1984"), )). Execute(ctx)
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();
Web
उदाहरण:
const result = await execute(db.pipeline() .collection("books") .select(field("rating").exists().as("hasRating")) );
Swift
let result = try await db.pipeline() .collection("books") .select([Field("rating").exists().as("hasRating")]) .execute()
Kotlin
उदाहरण:
val result = db.pipeline() .collection("books") .select(field("rating").exists().alias("hasRating")) .execute()
Java
उदाहरण:
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select(field("rating").exists().alias("hasRating")) .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field result = ( client.pipeline() .collection("books") .select(Field.of("rating").exists().as_("hasRating")) .execute() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(exists(field("rating")).as("hasRating")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.FieldExists(firestore.FieldOf("rating")).As("hasRating"), )). Execute(ctx)
IS_ABSENT
सिंटैक्स:
is_absent(value: ANY) -> BOOLEAN
ब्यौरा:
अगर value मौजूद नहीं है, तो TRUE दिखाता है. अगर मौजूद है, तो 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();
Web
const result = await execute(db.pipeline() .collection("books") .select( and(field("rating").greaterThan(4), field("price").lessThan(10)) .as("under10Recommendation") ) );
Swift
let result = try await db.pipeline() .collection("books") .select([ (Field("rating").greaterThan(4) && Field("price").lessThan(10)) .as("under10Recommendation") ]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select( Expression.and(field("rating").greaterThan(4), field("price").lessThan(10)) .alias("under10Recommendation") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select( Expression.and( field("rating").greaterThan(4), field("price").lessThan(10) ).alias("under10Recommendation") ) .execute();
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() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select( and(greaterThan(field("rating"), 4), lessThan(field("price"), 10)) .as("under10Recommendation")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.And( firestore.GreaterThan(firestore.FieldOf("rating"), 4), firestore.LessThan(firestore.FieldOf("price"), 10), ).As("under10Recommendation"), )). Execute(ctx)
या
सिंटैक्स:
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();
Web
const result = await execute(db.pipeline() .collection("books") .select( or(field("genre").equal("Fantasy"), field("tags").arrayContains("adventure")) .as("matchesSearchFilters") ) );
Swift
let result = try await db.pipeline() .collection("books") .select([ (Field("genre").equal("Fantasy") || Field("tags").arrayContains("adventure")) .as("matchesSearchFilters") ]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select( Expression.or(field("genre").equal("Fantasy"), field("tags").arrayContains("adventure")) .alias("matchesSearchFilters") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select( Expression.or( field("genre").equal("Fantasy"), field("tags").arrayContains("adventure") ).alias("matchesSearchFilters") ) .execute();
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() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select( or(equal(field("genre"), "Fantasy"), arrayContains(field("tags"), "adventure")) .as("matchesSearchFilters")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.Or( firestore.Equal(firestore.FieldOf("genre"), "Fantasy"), firestore.ArrayContains(firestore.FieldOf("tags"), "adventure"), ).As("matchesSearchFilters"), )). Execute(ctx)
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") ) );
Web
const result = await execute(db.pipeline() .collection("books") .select( xor(field("tags").arrayContains("magic"), field("tags").arrayContains("nonfiction")) .as("matchesSearchFilters") ) );
Swift
let result = try await db.pipeline() .collection("books") .select([ (Field("tags").arrayContains("magic") ^ Field("tags").arrayContains("nonfiction")) .as("matchesSearchFilters") ]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select( Expression.xor(field("tags").arrayContains("magic"), field("tags").arrayContains("nonfiction")) .alias("matchesSearchFilters") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select( Expression.xor( field("tags").arrayContains("magic"), field("tags").arrayContains("nonfiction") ).alias("matchesSearchFilters") ) .execute();
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() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select( xor( arrayContains(field("tags"), "magic"), arrayContains(field("tags"), "nonfiction")) .as("matchesSearchFilters")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.Xor( firestore.ArrayContains(firestore.FieldOf("tags"), "magic"), firestore.ArrayContains(firestore.FieldOf("tags"), "nonfiction"), ).As("matchesSearchFilters"), )). Execute(ctx)
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") ) );
Web
const result = await execute(db.pipeline() .collection("books") .select( field("tags").arrayContains("nonfiction").not() .as("isFiction") ) );
Swift
let result = try await db.pipeline() .collection("books") .select([ (!Field("tags").arrayContains("nonfiction")) .as("isFiction") ]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select( Expression.not( field("tags").arrayContains("nonfiction") ).alias("isFiction") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select( Expression.not( field("tags").arrayContains("nonfiction") ).alias("isFiction") ) .execute();
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() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(not(arrayContains(field("tags"), "nonfiction")).as("isFiction")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.Not(firestore.ArrayContains(firestore.FieldOf("tags"), "nonfiction")).As("isFiction"), )). Execute(ctx)
शर्त के साथ
सिंटैक्स:
conditional(condition: BOOLEAN, true_case: ANY, false_case: ANY) -> ANY
ब्यौरा:
अगर condition की वैल्यू TRUE है, तो यह फ़ंक्शन true_case का आकलन करके उसे दिखाता है.
यह फ़ंक्शन, false_case का आकलन करता है और उसे दिखाता है. ऐसा तब होता है, जब शर्त FALSE, NULL या ABSENT वैल्यू के तौर पर तय की जाती है.
उदाहरण:
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") ) );
Web
const result = await execute(db.pipeline() .collection("books") .select( field("tags").arrayConcat([ field("pages").greaterThan(100) .conditional(constant("longRead"), constant("shortRead")) ]).as("extendedTags") ) );
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()
Kotlin
val result = db.pipeline() .collection("books") .select( field("tags").arrayConcat( Expression.conditional( field("pages").greaterThan(100), constant("longRead"), constant("shortRead") ) ).alias("extendedTags") ) .execute()
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();
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() )
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();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.ArrayConcat( firestore.FieldOf("tags"), firestore.Conditional( firestore.GreaterThan(firestore.FieldOf("pages"), 100), firestore.ConstantOf("longRead"), firestore.ConstantOf("shortRead"), ), ).As("extendedTags"), )). Execute(ctx)
IF_NULL
सिंटैक्स:
if_null(expr: ANY, replacement: ANY) -> ANY
ब्यौरा:
अगर यह NULL नहीं है, तो expr दिखाता है. अगर यह है, तो इसका आकलन करके
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 | "दो" |
| 3000 | "अन्य" |
EQUAL_ANY
सिंटैक्स:
equal_any(value: ANY, search_space: ARRAY) -> BOOLEAN
ब्यौरा:
अगर search_space अरे में value मौजूद है, तो 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") ) );
Web
const result = await execute(db.pipeline() .collection("books") .select( field("genre").equalAny(["Science Fiction", "Psychological Thriller"]) .as("matchesGenreFilters") ) );
Swift
let result = try await db.pipeline() .collection("books") .select([ Field("genre").equalAny(["Science Fiction", "Psychological Thriller"]) .as("matchesGenreFilters") ]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select( field("genre").equalAny(listOf("Science Fiction", "Psychological Thriller")) .alias("matchesGenreFilters") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select( field("genre").equalAny(Arrays.asList("Science Fiction", "Psychological Thriller")) .alias("matchesGenreFilters") ) .execute();
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() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select( equalAny(field("genre"), Arrays.asList("Science Fiction", "Psychological Thriller")) .as("matchesGenreFilters")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.EqualAny(firestore.FieldOf("genre"), []string{"Science Fiction", "Psychological Thriller"}).As("matchesGenreFilters"), )). Execute(ctx)
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") ) );
Web
const result = await execute(db.pipeline() .collection("books") .select( field("author").notEqualAny(["George Orwell", "F. Scott Fitzgerald"]) .as("byExcludedAuthors") ) );
Swift
let result = try await db.pipeline() .collection("books") .select([ Field("author").notEqualAny(["George Orwell", "F. Scott Fitzgerald"]) .as("byExcludedAuthors") ]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select( field("author").notEqualAny(listOf("George Orwell", "F. Scott Fitzgerald")) .alias("byExcludedAuthors") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select( field("author").notEqualAny(Arrays.asList("George Orwell", "F. Scott Fitzgerald")) .alias("byExcludedAuthors") ) .execute();
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() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select( notEqualAny(field("author"), Arrays.asList("George Orwell", "F. Scott Fitzgerald")) .as("byExcludedAuthors")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.NotEqualAny(firestore.FieldOf("author"), []string{"George Orwell", "F. Scott Fitzgerald"}).As("byExcludedAuthors"), )). Execute(ctx)
MAXIMUM
सिंटैक्स:
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")) );
Web
const result = await execute(db.pipeline() .collection("books") .aggregate(field("price").maximum().as("maximumPrice")) );
Swift
let result = try await db.pipeline() .collection("books") .select([ Field("rating").logicalMaximum([1]).as("flooredRating") ]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select( field("rating").logicalMaximum(1).alias("flooredRating") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select( field("rating").logicalMaximum(1).alias("flooredRating") ) .execute();
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() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(logicalMaximum(field("rating"), 1).as("flooredRating")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.LogicalMaximum(firestore.FieldOf("rating"), 1).As("flooredRating"), )). Execute(ctx)
MINIMUM
सिंटैक्स:
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")) );
Web
const result = await execute(db.pipeline() .collection("books") .aggregate(field("price").minimum().as("minimumPrice")) );
Swift
let result = try await db.pipeline() .collection("books") .select([ Field("rating").logicalMinimum([5]).as("cappedRating") ]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select( field("rating").logicalMinimum(5).alias("cappedRating") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select( field("rating").logicalMinimum(5).alias("cappedRating") ) .execute();
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() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(logicalMinimum(field("rating"), 5).as("cappedRating")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.LogicalMinimum(firestore.FieldOf("rating"), 5).As("cappedRating"), )). Execute(ctx)
मैप फ़ंक्शन
| नाम | ब्यौरा |
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();
Web
const result = await execute(db.pipeline() .collection("books") .select( field("awards").mapGet("pulitzer").as("hasPulitzerAward") ) );
Swift
let result = try await db.pipeline() .collection("books") .select([ Field("awards").mapGet("pulitzer").as("hasPulitzerAward") ]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select( field("awards").mapGet("pulitzer").alias("hasPulitzerAward") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select( field("awards").mapGet("pulitzer").alias("hasPulitzerAward") ) .execute();
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() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(mapGet(field("awards"), "pulitzer").as("hasPulitzerAward")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.MapGet(firestore.FieldOf("awards"), "pulitzer").As("hasPulitzerAward"), )). Execute(ctx)
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
|
अगर कोई STRING, दिए गए प्रीफ़िक्स से शुरू होता है, तो TRUE दिखाता है
|
ENDS_WITH
|
अगर कोई STRING दिए गए पोस्टफ़िक्स पर खत्म होता है, तो TRUE दिखाता है
|
LIKE
|
अगर कोई STRING किसी पैटर्न से मेल खाता है, तो TRUE दिखाता है
|
REGEX_CONTAINS
|
अगर कोई वैल्यू, रेगुलर एक्सप्रेशन से कुछ हद तक या पूरी तरह मैच करती है, तो यह फ़ंक्शन TRUE दिखाता है
|
REGEX_MATCH
|
अगर वैल्यू का कोई भी हिस्सा रेगुलर एक्सप्रेशन से मैच करता है, तो TRUE दिखाता है
|
STRING_CONCAT
|
यह फ़ंक्शन, कई STRING को एक STRING में जोड़ता है
|
STRING_CONTAINS
|
अगर किसी वैल्यू में STRING मौजूद है, तो TRUE दिखाता है
|
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();
Web
const result = await execute(db.pipeline() .collection("books") .select( field("title").byteLength().as("titleByteLength") ) );
Swift
let result = try await db.pipeline() .collection("books") .select([ Field("title").byteLength().as("titleByteLength") ]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select( field("title").byteLength().alias("titleByteLength") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select( field("title").byteLength().alias("titleByteLength") ) .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field result = ( client.pipeline() .collection("books") .select(Field.of("title").byte_length().as_("titleByteLength")) .execute() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(byteLength(field("title")).as("titleByteLength")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.ByteLength(firestore.FieldOf("title")).As("titleByteLength"), )). Execute(ctx)
CHAR_LENGTH
सिंटैक्स:
char_length(value: STRING) -> INT64
ब्यौरा:
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();
Web
const result = await execute(db.pipeline() .collection("books") .select( field("title").charLength().as("titleCharLength") ) );
Swift
let result = try await db.pipeline() .collection("books") .select([ Field("title").charLength().as("titleCharLength") ]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select( field("title").charLength().alias("titleCharLength") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select( field("title").charLength().alias("titleCharLength") ) .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field result = ( client.pipeline() .collection("books") .select(Field.of("title").char_length().as_("titleCharLength")) .execute() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(charLength(field("title")).as("titleCharLength")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.CharLength(firestore.FieldOf("title")).As("titleCharLength"), )). Execute(ctx)
STARTS_WITH
सिंटैक्स:
starts_with(value: STRING, prefix: STRING) -> BOOLEAN
ब्यौरा:
अगर 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();
Web
const result = await execute(db.pipeline() .collection("books") .select( field("title").startsWith("The") .as("needsSpecialAlphabeticalSort") ) );
Swift
let result = try await db.pipeline() .collection("books") .select([ Field("title").startsWith("The") .as("needsSpecialAlphabeticalSort") ]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select( field("title").startsWith("The") .alias("needsSpecialAlphabeticalSort") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select( field("title").startsWith("The") .alias("needsSpecialAlphabeticalSort") ) .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field result = ( client.pipeline() .collection("books") .select( Field.of("title").starts_with("The").as_("needsSpecialAlphabeticalSort") ) .execute() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(startsWith(field("title"), "The").as("needsSpecialAlphabeticalSort")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.StartsWith(firestore.FieldOf("title"), "The").As("needsSpecialAlphabeticalSort"), )). Execute(ctx)
ENDS_WITH
सिंटैक्स:
ends_with(value: STRING, postfix: STRING) -> BOOLEAN
ब्यौरा:
अगर 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();
Swift
let result = try await db.pipeline() .collection("inventory/devices/laptops") .select([ Field("name").endsWith("16 inch") .as("16InLaptops") ]) .execute()
Kotlin
val result = db.pipeline() .collection("inventory/devices/laptops") .select( field("name").endsWith("16 inch") .alias("16InLaptops") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("inventory/devices/laptops") .select( field("name").endsWith("16 inch") .alias("16InLaptops") ) .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field result = ( client.pipeline() .collection("inventory/devices/laptops") .select(Field.of("name").ends_with("16 inch").as_("16InLaptops")) .execute() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("inventory/devices/laptops") .select(endsWith(field("name"), "16 inch").as("16InLaptops")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("inventory/devices/laptops"). Select(firestore.Fields( firestore.EndsWith(firestore.FieldOf("name"), "16 inch").As("`Laptops16in`"), )). Execute(ctx)
पसंद करें
सिंटैक्स:
like(value: STRING, pattern: STRING) -> BOOLEAN
ब्यौरा:
अगर value का मिलान pattern से होता है, तो TRUE दिखाता है.
उदाहरण:
| value | pattern | 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();
Web
const result = await execute(db.pipeline() .collection("books") .select( field("genre").like("%Fiction") .as("anyFiction") ) );
Swift
let result = try await db.pipeline() .collection("books") .select([ Field("genre").like("%Fiction") .as("anyFiction") ]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select( field("genre").like("%Fiction") .alias("anyFiction") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select( field("genre").like("%Fiction") .alias("anyFiction") ) .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field result = ( client.pipeline() .collection("books") .select(Field.of("genre").like("%Fiction").as_("anyFiction")) .execute() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(like(field("genre"), "%Fiction").as("anyFiction")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.Like(firestore.FieldOf("genre"), "%Fiction").As("anyFiction"), )). Execute(ctx)
REGEX_CONTAINS
सिंटैक्स:
regex_contains(value: STRING, pattern: STRING) -> BOOLEAN
ब्यौरा:
अगर value का कोई हिस्सा pattern से मैच करता है, तो TRUE दिखाता है. अगर pattern एक मान्य रेगुलर एक्सप्रेशन नहीं है, तो यह फ़ंक्शन error दिखाता है.
रेगुलर एक्सप्रेशन, re2 लाइब्रेरी के सिंटैक्स का पालन करते हैं.
उदाहरण:
| value | pattern | 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();
Web
const result = await execute(db.pipeline() .collection("documents") .select( field("title").regexContains("Firestore (Enterprise|Standard)") .as("isFirestoreRelated") ) );
Swift
let result = try await db.pipeline() .collection("documents") .select([ Field("title").regexContains("Firestore (Enterprise|Standard)") .as("isFirestoreRelated") ]) .execute()
Kotlin
val result = db.pipeline() .collection("documents") .select( field("title").regexContains("Firestore (Enterprise|Standard)") .alias("isFirestoreRelated") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("documents") .select( field("title").regexContains("Firestore (Enterprise|Standard)") .alias("isFirestoreRelated") ) .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field result = ( client.pipeline() .collection("documents") .select( Field.of("title") .regex_contains("Firestore (Enterprise|Standard)") .as_("isFirestoreRelated") ) .execute() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("documents") .select( regexContains(field("title"), "Firestore (Enterprise|Standard)") .as("isFirestoreRelated")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("documents"). Select(firestore.Fields( firestore.RegexContains(firestore.FieldOf("title"), "Firestore (Enterprise|Standard)").As("isFirestoreRelated"), )). Execute(ctx)
REGEX_MATCH
सिंटैक्स:
regex_match(value: STRING, pattern: STRING) -> BOOLEAN
ब्यौरा:
अगर value, pattern से पूरी तरह मैच होता है, तो TRUE दिखाता है. अगर pattern एक मान्य रेगुलर एक्सप्रेशन नहीं है, तो यह फ़ंक्शन error दिखाता है.
रेगुलर एक्सप्रेशन, re2 लाइब्रेरी के सिंटैक्स का पालन करते हैं.
उदाहरण:
| value | pattern | 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();
Web
const result = await execute(db.pipeline() .collection("documents") .select( field("title").regexMatch("Firestore (Enterprise|Standard)") .as("isFirestoreExactly") ) );
Swift
let result = try await db.pipeline() .collection("documents") .select([ Field("title").regexMatch("Firestore (Enterprise|Standard)") .as("isFirestoreExactly") ]) .execute()
Kotlin
val result = db.pipeline() .collection("documents") .select( field("title").regexMatch("Firestore (Enterprise|Standard)") .alias("isFirestoreExactly") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("documents") .select( field("title").regexMatch("Firestore (Enterprise|Standard)") .alias("isFirestoreExactly") ) .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field result = ( client.pipeline() .collection("documents") .select( Field.of("title") .regex_match("Firestore (Enterprise|Standard)") .as_("isFirestoreExactly") ) .execute() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("documents") .select( regexMatch(field("title"), "Firestore (Enterprise|Standard)") .as("isFirestoreExactly")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("documents"). Select(firestore.Fields( firestore.RegexMatch(firestore.FieldOf("title"), "Firestore (Enterprise|Standard)").As("isFirestoreExactly"), )). Execute(ctx)
STRING_CONCAT
सिंटैक्स:
string_concat(values: STRING...) -> STRING
ब्यौरा:
दो या उससे ज़्यादा STRING वैल्यू को एक साथ जोड़कर एक नतीजा दिखाता है.
उदाहरण:
| आर्ग्युमेंट | string_concat(values...) |
|---|---|
() |
गड़बड़ी |
("a") |
"a" |
("abc", "def") |
"abcdef" |
("a", "", "c") |
"ac" |
Node.js
const result = await db.pipeline() .collection("books") .select( field("title").stringConcat(" by ", field("author")) .as("fullyQualifiedTitle") ) .execute();
Web
const result = await execute(db.pipeline() .collection("books") .select( field("title").stringConcat(" by ", field("author")) .as("fullyQualifiedTitle") ) );
Swift
let result = try await db.pipeline() .collection("books") .select([ Field("title").concat([" by ", Field("author")]) .as("fullyQualifiedTitle") ]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select( field("title").concat(" by ", field("author")) .alias("fullyQualifiedTitle") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select( field("title").concat(" by ", field("author")) .alias("fullyQualifiedTitle") ) .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field result = ( client.pipeline() .collection("books") .select( Field.of("title") .concat(" by ", Field.of("author")) .as_("fullyQualifiedTitle") ) .execute() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(stringConcat(field("title"), " by ", field("author")).as("fullyQualifiedTitle")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.StringConcat(firestore.FieldOf("title"), " by ", firestore.FieldOf("author")).As("fullyQualifiedTitle"), )). Execute(ctx)
STRING_CONTAINS
सिंटैक्स:
string_contains(value: STRING, substring: STRING) -> BOOLEAN
ब्यौरा:
इस फ़ंक्शन से यह पता चलता है कि value में लिटरल स्ट्रिंग substring मौजूद है या नहीं.
उदाहरण:
| 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();
Web
const result = await execute(db.pipeline() .collection("articles") .select( field("body").stringContains("Firestore") .as("isFirestoreRelated") ) );
Swift
let result = try await db.pipeline() .collection("articles") .select([ Field("body").stringContains("Firestore") .as("isFirestoreRelated") ]) .execute()
Kotlin
val result = db.pipeline() .collection("articles") .select( field("body").stringContains("Firestore") .alias("isFirestoreRelated") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("articles") .select( field("body").stringContains("Firestore") .alias("isFirestoreRelated") ) .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field result = ( client.pipeline() .collection("articles") .select(Field.of("body").string_contains("Firestore").as_("isFirestoreRelated")) .execute() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("articles") .select(stringContains(field("body"), "Firestore").as("isFirestoreRelated")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("articles"). Select(firestore.Fields( firestore.StringContains(firestore.FieldOf("body"), "Firestore").As("isFirestoreRelated"), )). Execute(ctx)
STRING_INDEX_OF
सिंटैक्स:
string_index_of[T <: STRING | BYTES](value: T, search: T) -> INT64
ब्यौरा:
value में search की पहली एंट्री का इंडेक्स दिखाता है. यह इंडेक्स 0 से शुरू होता है.
- अगर
searchनहीं मिलता है, तो-1दिखाता है. - अगर
value,STRINGवैल्यू है, तो नतीजे को यूनिकोड कोड पॉइंट में मापा जाता है. अगर यहBYTESवैल्यू है, तो इसे बाइट में मापा जाता है. - अगर
searchकोई खालीSTRINGयाBYTESवैल्यू है, तो नतीजा0होता है.
उदाहरण:
| value | खोजें | string_index_of(value, search) |
|---|---|---|
| "hello world" | "o" | 4 |
| "hello world" | "l" | 2 |
| "hello world" | "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();
Web
const result = await execute(db.pipeline() .collection("authors") .select( field("name").toUpper() .as("uppercaseName") ) );
Swift
let result = try await db.pipeline() .collection("authors") .select([ Field("name").toUpper() .as("uppercaseName") ]) .execute()
Kotlin
val result = db.pipeline() .collection("authors") .select( field("name").toUpper() .alias("uppercaseName") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("authors") .select( field("name").toUpper() .alias("uppercaseName") ) .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field result = ( client.pipeline() .collection("authors") .select(Field.of("name").to_upper().as_("uppercaseName")) .execute() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("authors") .select(toUpper(field("name")).as("uppercaseName")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("authors"). Select(firestore.Fields( firestore.ToUpper(firestore.FieldOf("name")).As("uppercaseName"), )). Execute(ctx)
TO_LOWER
सिंटैक्स:
to_lower[T <: STRING | BYTES](value: T) -> T
ब्यौरा:
यह STRING या BYTES वैल्यू को छोटे अक्षरों में बदलता है.
अगर कोई बाइट या वर्ण, UTF-8 के बड़े अक्षरों वाले वर्ण से मेल नहीं खाता है, तो उसे बिना किसी बदलाव के पास कर दिया जाता है.
उदाहरण:
| 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();
Web
const result = await execute(db.pipeline() .collection("authors") .select( field("genre").toLower().equal("fantasy") .as("isFantasy") ) );
Swift
let result = try await db.pipeline() .collection("authors") .select([ Field("genre").toLower().equal("fantasy") .as("isFantasy") ]) .execute()
Kotlin
val result = db.pipeline() .collection("authors") .select( field("genre").toLower().equal("fantasy") .alias("isFantasy") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("authors") .select( field("genre").toLower().equal("fantasy") .alias("isFantasy") ) .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field result = ( client.pipeline() .collection("authors") .select(Field.of("genre").to_lower().equal("fantasy").as_("isFantasy")) .execute() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("authors") .select(equal(toLower(field("genre")), "fantasy").as("isFantasy")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("authors"). Select(firestore.Fields( firestore.Equal(firestore.ToLower(firestore.FieldOf("genre")), "fantasy").As("isFantasy"), )). Execute(ctx)
SUBSTRING
सिंटैक्स:
substring[T <: STRING | BYTES](input: T, position: INT64) -> T
substring[T <: STRING | BYTES](input: T, position: INT64, length: INT64) -> T
ब्यौरा:
यह फ़ंक्शन, input की एक सबस्ट्रिंग दिखाता है. यह position (शून्य पर आधारित इंडेक्स) से शुरू होती है और इसमें length तक की एंट्री शामिल होती हैं. अगर कोई length नहीं दिया गया है, तो position से लेकर input के आखिर तक की सबस्ट्रिंग दिखाता है.
अगर
input,STRINGवैल्यू है, तोpositionऔरlengthको यूनिकोड कोड पॉइंट में मापा जाता है. अगर यह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();
Web
const result = await execute(db.pipeline() .collection("books") .where(field("title").startsWith("The ")) .select( field("title").substring(4) .as("titleWithoutLeadingThe") ) );
Swift
let result = try await db.pipeline() .collection("books") .where(Field("title").startsWith("The ")) .select([ Field("title").substring(position: 4) .as("titleWithoutLeadingThe") ]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .where(field("title").startsWith("The ")) .select( field("title") .substring(constant(4), field("title").charLength().subtract(4)) .alias("titleWithoutLeadingThe") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .where(field("title").startsWith("The ")) .select( field("title").substring( constant(4), field("title").charLength().subtract(4)) .alias("titleWithoutLeadingThe") ) .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field result = ( client.pipeline() .collection("books") .where(Field.of("title").starts_with("The ")) .select(Field.of("title").substring(4).as_("titleWithoutLeadingThe")) .execute() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .where(startsWith(field("title"), "The ")) .select( substring(field("title"), constant(4), field("title").charLength()) .as("titleWithoutLeadingThe")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Where(firestore.StartsWith(firestore.FieldOf("title"), "The ")). Select(firestore.Fields( firestore.Substring(firestore.FieldOf("title"), firestore.ConstantOf(4), firestore.FieldOf("title").CharLength()).As("titleWithoutLeadingThe"), )). Execute(ctx)
STRING_REVERSE
सिंटैक्स:
string_reverse[T <: STRING | BYTES](input: T) -> T
ब्यौरा:
यह फ़ंक्शन, दिए गए इनपुट को उल्टे क्रम में दिखाता है.
जब इनपुट STRING होता है, तो वर्णों को यूनिकोड कोड पॉइंट से अलग किया जाता है. वहीं, जब इनपुट BYTES वैल्यू होती है, तो वर्णों को बाइट से अलग किया जाता है.
उदाहरण:
| इनपुट | string_reverse(input) |
|---|---|
| "abc" | "cba" |
| "a🌹b" | "b🌹a" |
| "नमस्ते" | "olleh" |
| b"abc" | b"cba" |
Node.js
const result = await db.pipeline() .collection("books") .select( field("name").reverse().as("reversedName") ) .execute();
Web
const result = await execute(db.pipeline() .collection("books") .select( field("name").reverse().as("reversedName") ) );
Swift
let result = try await db.pipeline() .collection("books") .select([ Field("name").reverse().as("reversedName") ]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select( field("name").reverse().alias("reversedName") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select( field("name").reverse().alias("reversedName") ) .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field result = ( client.pipeline() .collection("books") .select(Field.of("name").string_reverse().as_("reversedName")) .execute() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(reverse(field("name")).as("reversedName")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.Reverse(firestore.FieldOf("name")).As("reversedName"), )). Execute(ctx)
STRING_REPEAT
सिंटैक्स:
string_repeat[T <: STRING | BYTES](input: T, repetitions: INT64) -> T
ब्यौरा:
यह फ़ंक्शन, input को repetitions बार दोहराकर दिखाता है.
repetitionsएक गैर-ऋणात्मक पूर्णांक होना चाहिए.- अगर
repetitions,0है, तोinputके टाइप की खाली वैल्यू दिखाता है. - अगर नतीजे का साइज़, तय सीमा (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") ) );
Swift
let result = try await db.pipeline() .collection("books") .select([ Field("name").trim(" \n\t").as("whitespaceTrimmedName") ]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select( field("name").trim().alias("whitespaceTrimmedName") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select( field("name").trim().alias("whitespaceTrimmedName") ) .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field result = ( client.pipeline() .collection("books") .select(Field.of("name").trim().as_("whitespaceTrimmedName")) .execute() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(trim(field("name")).as("whitespaceTrimmedName")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.Trim(firestore.FieldOf("name")).As("whitespaceTrimmedName"), )). Execute(ctx)
LTRIM
सिंटैक्स:
ltrim[T <: STRING | BYTES](value: T, to_trim: T) -> T
ltrim[T <: STRING | BYTES](value: T) -> T
ब्यौरा:
यह फ़ंक्शन, दिए गए 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 आर्ग्युमेंट एक स्ट्रिंग होना चाहिए और इनमें से कोई एक होना चाहिए:
microsecondmillisecondsecondminutehourdayweekweek([weekday])monthquarteryearisoyear
अगर 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 यूटीसी | "second" | नहीं दिया गया | 2001-01-01 10:20:30 यूटीसी |
| 1997-05-31 04:30:30 यूटीसी | "दिन" | नहीं दिया गया | 1997-05-31 00:00:00 यूटीसी |
| 1997-05-31 04:30:30 यूटीसी | "दिन" | "America/Los_Angeles" | 1997-05-30 07:00:00 यूटीसी |
| 2001-03-16 04:00:00 यूटीसी | "week(friday) | नहीं दिया गया | 2001-03-16 00:00:00 यूटीसी |
| 2001-03-23 04:00:00 यूटीसी | "week(friday) | "America/Los_Angeles" | 2001-03-23 17:00:00 यूटीसी |
| 2026-01-24 20:00:00 यूटीसी | "महीना" | "GMT+06:32:43" | 2026-01-01T06:32:43 UTC |
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();
Web
const result = await execute(db.pipeline() .collection("documents") .select( field("createdAtMicros").unixMicrosToTimestamp().as("createdAtString") ) );
Swift
let result = try await db.pipeline() .collection("documents") .select([ Field("createdAtMicros").unixMicrosToTimestamp().as("createdAtString") ]) .execute()
Kotlin
val result = db.pipeline() .collection("documents") .select( field("createdAtMicros").unixMicrosToTimestamp().alias("createdAtString") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("documents") .select( field("createdAtMicros").unixMicrosToTimestamp().alias("createdAtString") ) .execute();
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() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("documents") .select(unixMicrosToTimestamp(field("createdAtMicros")).as("createdAtString")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("documents"). Select(firestore.Fields( firestore.UnixMicrosToTimestamp(firestore.FieldOf("createdAtMicros")).As("createdAtString"), )). Execute(ctx)
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();
Web
const result = await execute(db.pipeline() .collection("documents") .select( field("createdAtMillis").unixMillisToTimestamp().as("createdAtString") ) );
Swift
let result = try await db.pipeline() .collection("documents") .select([ Field("createdAtMillis").unixMillisToTimestamp().as("createdAtString") ]) .execute()
Kotlin
val result = db.pipeline() .collection("documents") .select( field("createdAtMillis").unixMillisToTimestamp().alias("createdAtString") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("documents") .select( field("createdAtMillis").unixMillisToTimestamp().alias("createdAtString") ) .execute();
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() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("documents") .select(unixMillisToTimestamp(field("createdAtMillis")).as("createdAtString")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("documents"). Select(firestore.Fields( firestore.UnixMillisToTimestamp(firestore.FieldOf("createdAtMillis")).As("createdAtString"), )). Execute(ctx)
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();
Web
const result = await execute(db.pipeline() .collection("documents") .select( field("createdAtSeconds").unixSecondsToTimestamp().as("createdAtString") ) );
Swift
let result = try await db.pipeline() .collection("documents") .select([ Field("createdAtSeconds").unixSecondsToTimestamp().as("createdAtString") ]) .execute()
Kotlin
val result = db.pipeline() .collection("documents") .select( field("createdAtSeconds").unixSecondsToTimestamp().alias("createdAtString") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("documents") .select( field("createdAtSeconds").unixSecondsToTimestamp().alias("createdAtString") ) .execute();
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() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("documents") .select(unixSecondsToTimestamp(field("createdAtSeconds")).as("createdAtString")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("documents"). Select(firestore.Fields( firestore.UnixSecondsToTimestamp(firestore.FieldOf("createdAtSeconds")).As("createdAtString"), )). Execute(ctx)
TIMESTAMP_ADD
सिंटैक्स:
timestamp_add(timestamp: TIMESTAMP, unit: STRING, amount: INT64) -> TIMESTAMP
ब्यौरा:
timestamp से unit का amount जोड़ता है. amount आर्ग्युमेंट नेगेटिव हो सकता है. ऐसे में, यह TIMESTAMP_SUB के बराबर होता है.
unit आर्ग्युमेंट एक स्ट्रिंग होना चाहिए और इनमें से कोई एक होना चाहिए:
microsecondmillisecondsecondminutehourday
अगर नतीजे वाला टाइमस्टैंप, TIMESTAMP रेंज में नहीं आता है, तो यह फ़ंक्शन गड़बड़ी दिखाता है.
उदाहरण:
timestamp |
unit |
amount |
timestamp_add(timestamp, unit, amount) |
|---|---|---|---|
| 20-02-2025 00:00:00 यूटीसी | "minute" | 2L | 20-02-2025 00:02:00 यूटीसी |
| 20-02-2025 00:00:00 यूटीसी | "घंटा" | -4L | 19-02-2025 20:00:00 यूटीसी |
| 20-02-2025 00:00:00 यूटीसी | "दिन" | 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();
Web
const result = await execute(db.pipeline() .collection("documents") .select( field("createdAt").timestampAdd("day", 3653).as("expiresAt") ) );
Swift
let result = try await db.pipeline() .collection("documents") .select([ Field("createdAt").timestampAdd(3653, .day).as("expiresAt") ]) .execute()
Kotlin
val result = db.pipeline() .collection("documents") .select( field("createdAt") .timestampAdd("day", 3653) .alias("expiresAt") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("documents") .select( field("createdAt").timestampAdd("day", 3653).alias("expiresAt") ) .execute();
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() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("documents") .select(timestampAdd(field("createdAt"), "day", 3653).as("expiresAt")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("documents"). Select(firestore.Fields( firestore.TimestampAdd(firestore.FieldOf("createdAt"), "day", 3653).As("expiresAt"), )). Execute(ctx)
TIMESTAMP_SUB
सिंटैक्स:
timestamp_sub(timestamp: TIMESTAMP, unit: STRING, amount: INT64) -> TIMESTAMP
ब्यौरा:
timestamp में से unit का amount घटाता है. amount आर्ग्युमेंट की वैल्यू नेगेटिव हो सकती है. इस मामले में, यह TIMESTAMP_ADD के बराबर होता है.
unit आर्ग्युमेंट एक स्ट्रिंग होना चाहिए और इनमें से कोई एक होना चाहिए:
microsecondmillisecondsecondminutehourday
अगर नतीजे वाला टाइमस्टैंप, 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 यूटीसी | "दिन" | 3000 | 01-07-2026 00:00:00 यूटीसी |
Node.js
const result = await db.pipeline() .collection("documents") .select( field("expiresAt").timestampSubtract("day", 14).as("sendWarningTimestamp") ) .execute();
Web
const result = await execute(db.pipeline() .collection("documents") .select( field("expiresAt").timestampSubtract("day", 14).as("sendWarningTimestamp") ) );
Swift
let result = try await db.pipeline() .collection("documents") .select([ Field("expiresAt").timestampSubtract(14, .day).as("sendWarningTimestamp") ]) .execute()
Kotlin
val result = db.pipeline() .collection("documents") .select( field("expiresAt") .timestampSubtract("day", 14) .alias("sendWarningTimestamp") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("documents") .select( field("expiresAt").timestampSubtract("day", 14).alias("sendWarningTimestamp") ) .execute();
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() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("documents") .select(timestampSubtract(field("expiresAt"), "day", 14).as("sendWarningTimestamp")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("documents"). Select(firestore.Fields( firestore.TimestampSubtract(firestore.FieldOf("expiresAt"), "day", 14).As("sendWarningTimestamp"), )). Execute(ctx)
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();
Web
const result = await execute(db.pipeline() .collection("documents") .select( field("dateString").timestampToUnixMicros().as("unixMicros") ) );
Swift
let result = try await db.pipeline() .collection("documents") .select([ Field("dateString").timestampToUnixMicros().as("unixMicros") ]) .execute()
Kotlin
val result = db.pipeline() .collection("documents") .select( field("dateString").timestampToUnixMicros().alias("unixMicros") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("documents") .select( field("dateString").timestampToUnixMicros().alias("unixMicros") ) .execute();
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() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("documents") .select(timestampToUnixMicros(field("dateString")).as("unixMicros")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("documents"). Select(firestore.Fields( firestore.TimestampToUnixMicros(firestore.FieldOf("dateString")).As("unixMicros"), )). Execute(ctx)
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();
Web
const result = await execute(db.pipeline() .collection("documents") .select( field("dateString").timestampToUnixMillis().as("unixMillis") ) );
Swift
let result = try await db.pipeline() .collection("documents") .select([ Field("dateString").timestampToUnixMillis().as("unixMillis") ]) .execute()
Kotlin
val result = db.pipeline() .collection("documents") .select( field("dateString").timestampToUnixMillis().alias("unixMillis") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("documents") .select( field("dateString").timestampToUnixMillis().alias("unixMillis") ) .execute();
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() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("documents") .select(timestampToUnixMillis(field("dateString")).as("unixMillis")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("documents"). Select(firestore.Fields( firestore.TimestampToUnixMillis(firestore.FieldOf("dateString")).As("unixMillis"), )). Execute(ctx)
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();
Web
const result = await execute(db.pipeline() .collection("documents") .select( field("dateString").timestampToUnixSeconds().as("unixSeconds") ) );
Swift
let result = try await db.pipeline() .collection("documents") .select([ Field("dateString").timestampToUnixSeconds().as("unixSeconds") ]) .execute()
Kotlin
val result = db.pipeline() .collection("documents") .select( field("dateString").timestampToUnixSeconds().alias("unixSeconds") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("documents") .select( field("dateString").timestampToUnixSeconds().alias("unixSeconds") ) .execute();
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() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("documents") .select(timestampToUnixSeconds(field("dateString")).as("unixSeconds")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("documents"). Select(firestore.Fields( firestore.TimestampToUnixSeconds(firestore.FieldOf("dateString")).As("unixSeconds"), )). Execute(ctx)
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 आर्ग्युमेंट एक स्ट्रिंग होना चाहिए और इनमें से कोई एक होना चाहिए:
microsecondmillisecondsecondminutehourday
उदाहरण:
end |
start |
unit |
timestamp_diff(end, start, unit) |
|---|---|---|---|
| 04-07-2026 00:01:00 यूटीसी | 04-07-2026 00:00:00 यूटीसी | "second" | 60L |
| 04-07-2026 00:00:00 यूटीसी | 05-07-2026 00:00:00 यूटीसी | "दिन" | -1L |
| 04-07-2026 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 आर्ग्युमेंट एक स्ट्रिंग होना चाहिए और इनमें से कोई एक होना चाहिए:
microsecondmillisecondsecondminutehourdaydayofweek: यह 1 (रविवार) और 7 (शनिवार) के बीच की वैल्यू दिखाता है.dayofyearweek: इससे साल के हफ़्ते की संख्या मिलती है. साल के पहले रविवार से इसकी गिनती शुरू होती है.week([weekday]): यह साल के हफ़्ते की संख्या दिखाता है. यह संख्या, तय की गईweekdayसे शुरू होती है.monthquarteryearisoweek: यह आईएसओ 8601 के हिसाब से हफ़्ते की संख्या दिखाता है.isoyear: यह आईएसओ 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 यूटीसी | "दिन" | नहीं दिया गया | 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" |
| सही | "boolean" |
| 1 | "int32" |
| -3L | "int64" |
| 3.14 | "float64" |
| 01-01-2024T00:00:00Z यूटीसी | "टाइमस्टैंप" |
| "foo" | "string" |
| b"foo" | "बाइट" |
| [1, 2] | "ऐरे" |
| {"a": 1} | "map" |
path("c/d") |
"रेफ़रंस" |
vector([1.0, 2.0]) |
"वेक्टर" |
| ABSENT | NULL |
क्लाइंट के उदाहरण
Node.js
const result = await db.pipeline() .collection("books") .select(field("title").notEqual("1984").as("not1984")) .execute();
Web
const result = await execute(db.pipeline() .collection("books") .select(field("title").notEqual("1984").as("not1984")) );
Swift
let result = try await db.pipeline() .collection("books") .select([Field("title").notEqual("1984").as("not1984")]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select(field("title").notEqual("1984").alias("not1984")) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select(field("title").notEqual("1984").alias("not1984")) .execute();
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() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(notEqual(field("title"), "1984").as("not1984")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.NotEqual(firestore.FieldOf("title"), "1984").As("not1984"), )). Execute(ctx)
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" | सही |
| सही | "boolean" | सही |
| 3.14 | "float64" | सही |
| "foo" | "string" | सही |
| b"foo" | "string" | गलत |
| [1, 2] | "ऐरे" | सही |
| {"a": 1} | "map" | सही |
vector([1.0, 2.0]) |
"वेक्टर" | सही |
| ABSENT | "string" | 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();
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")));
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()
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()
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();
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() )
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();
जाएं
sampleVector := []float64{0.0, 1.0, 2.0, 3.0, 4.0, 5.0} snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.CosineDistance(firestore.FieldOf("embedding"), sampleVector).As("cosineDistance"), )). Execute(ctx)
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();
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") ) );
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()
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()
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();
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() )
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();
जाएं
sampleVector := []float64{0.0, 1.0, 2.0, 3.0, 4.0, 5.0} snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.DotProduct(firestore.FieldOf("embedding"), sampleVector).As("dotProduct"), )). Execute(ctx)
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();
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") ) );
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()
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()
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();
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() )
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();
जाएं
sampleVector := []float64{0.0, 1.0, 2.0, 3.0, 4.0, 5.0} snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.EuclideanDistance(firestore.FieldOf("embedding"), sampleVector).As("euclideanDistance"), )). Execute(ctx)
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();
Web
const result = await execute(db.pipeline() .collection("books") .select( field("embedding").vectorLength().as("vectorLength") ) );
Swift
let result = try await db.pipeline() .collection("books") .select([ Field("embedding").vectorLength().as("vectorLength") ]) .execute()
Kotlin
val result = db.pipeline() .collection("books") .select( field("embedding").vectorLength().alias("vectorLength") ) .execute()
Java
Task<Pipeline.Snapshot> result = db.pipeline() .collection("books") .select( field("embedding").vectorLength().alias("vectorLength") ) .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field result = ( client.pipeline() .collection("books") .select(Field.of("embedding").vector_length().as_("vectorLength")) .execute() )
Java
Pipeline.Snapshot result = firestore .pipeline() .collection("books") .select(vectorLength(field("embedding")).as("vectorLength")) .execute() .get();
जाएं
snapshot := client.Pipeline(). Collection("books"). Select(firestore.Fields( firestore.VectorLength(firestore.FieldOf("embedding")).As("vectorLength"), )). Execute(ctx)