क्रम से लगाएं

ब्यौरा

यह ऑपरेटर, इनपुट दस्तावेज़ों को एक या उससे ज़्यादा तय किए गए क्रम के आधार पर क्रम से लगाता है.

उदाहरण

Web

const results = await execute(db.pipeline()
  .collection("books")
  .sort(
    field("release_date").descending(), field("author").ascending()
  )
);
Swift
let results = try await db.pipeline()
  .collection("books")
  .sort([
    Field("release_date").descending(), Field("author").ascending()
  ])
  .execute()

Kotlin

val results = db.pipeline()
    .collection("books")
    .sort(
        field("release_date").descending(),
        field("author").ascending()
    )
    .execute()

Java

Task<Pipeline.Snapshot> results = db.pipeline()
    .collection("books")
    .sort(
        field("release_date").descending(),
        field("author").ascending()
    )
    .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

results = (
    client.pipeline()
    .collection("books")
    .sort(Field.of("release_date").descending(), Field.of("author").ascending())
    .execute()
)
Java
Pipeline.Snapshot results =
    firestore
        .pipeline()
        .collection("books")
        .sort(descending(field("release_date")), ascending(field("author")))
        .execute()
        .get();
जाएं
snapshot := client.Pipeline().
	Collection("books").
	Sort(firestore.Orders(
		firestore.Descending(firestore.FieldOf("release_date")),
		firestore.Ascending(firestore.FieldOf("author")),
	)).
	Execute(ctx)

व्यवहार

ऑर्डर को क्रम से लगाएं

सॉर्ट करने का क्रम, Cloud Firestore की वैल्यू टाइप के क्रम के हिसाब से होता है

नतीजों का क्रम तय होना

अगर क्वेरी में sort स्टेज नहीं है, तो दिखाए गए नतीजों का क्रम तय नहीं होता. साथ ही, यह अलग-अलग क्वेरी के लिए अलग-अलग हो सकता है. अगर sort स्टेज मौजूद है, लेकिन ऑर्डर करने वाले एक्सप्रेशन, दिखाए गए नतीजों को यूनीक तरीके से ऑर्डर नहीं कर पाते हैं, तो दिखाए गए नतीजों का क्रम, अब भी अलग-अलग हो सकता है.

उदाहरण के लिए, शहरों को country के हिसाब से क्रम से लगाएं. इसके लिए, यहां दिए गए डेटासेट के हिसाब से शहरों को बढ़ते क्रम में लगाएं:

{ name: "Los Angeles", state: "CA", country: "USA", population: 3970000 },
{ name: "New York", state: "NY", country: "USA", population: 8530000 }
{ name: "San Francisco", state: "CA", country: "USA", population: 870000 },

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

Node.js

const results = await db.pipeline()
  .collection("/cities")
  .sort(field("country").ascending(), fieldd("__name__").ascending())
  .execute();

जब कई दस्तावेज़ों में country की वैल्यू एक जैसी होती है, तब इस फ़ील्ड में दी गई वैल्यू का इस्तेमाल, यह तय करने के लिए किया जाता है कि कौनसे दस्तावेज़ को प्राथमिकता दी जाए. ध्यान दें कि कलेक्शन में मौजूद दस्तावेज़ की यूनीक कुंजी बनाने के लिए, country फ़ील्ड के साथ-साथ किसी अन्य फ़ील्ड का इस्तेमाल किया जा सकता है. इससे नतीजों को एक तय क्रम में दिखाया जा सकता है.

एक जैसी वैल्यू को क्रम से लगाना

एक जैसी वैल्यू को एक साथ क्रम से लगाया जाता है. हालांकि, एक जैसी क्लास में मौजूद नतीजों का क्रम, नतीजों के क्रम के बारे में चर्चा के मुताबिक तय नहीं होता. उदाहरण के लिए, शहरों को size के हिसाब से बढ़ते क्रम में लगाना. इसके लिए, यहां दिया गया डेटासेट इस्तेमाल किया गया है:

{ name: "Los Angeles", state: "CA", country: "USA", size: 3970000 },
{ name: "Mexico City", state: null, country: "Mexico", size: 3970000.0 },

डेटासेट में मौजूद दोनों दस्तावेज़ों के किसी भी क्रम में नतीजे जनरेट कर सकता है, क्योंकि दोनों दस्तावेज़ों की size वैल्यू 3970000 एक जैसी है.

सॉर्ट करने के कई चरण

जब क्वेरी में क्रम से लगाने के कई चरण शामिल होते हैं, तो क्वेरी के नतीजों पर सिर्फ़ क्रम से लगाने के आखिरी चरण का असर पड़ता है. ध्यान दें कि यह Core API में orderBy क्लॉज़ के व्यवहार से अलग है.

टॉप-एन सॉर्ट ऑप्टिमाइज़ेशन

sort के बाद limit(...) का इस्तेमाल करने पर, टॉप-एन सॉर्ट का इस्तेमाल किया जा सकता है. इस ऑप्टिमाइज़ेशन से, सॉर्ट स्टेज के लिए मेमोरी के इस्तेमाल की सीमा तय की जाती है. ऐसा इसलिए किया जाता है, ताकि यह एक बार में सिर्फ़ N दस्तावेज़ों को सेव कर सके. limit(...) के हिसाब से, सॉर्टिंग को ज़्यादा मेमोरी-इफ़िशिएंट बनाया जाता है.

शून्य और मौजूद नहीं है वैल्यू

अगर क्रम में तय किया गया कोई फ़ील्ड, किसी दस्तावेज़ में मौजूद नहीं है, तो उसकी वैल्यू को इस तरह से क्रम में लगाया जाता है जैसे कि वैल्यू null हो. उदाहरण के लिए, शहरों को उनकी state के हिसाब से बढ़ते क्रम में लगाया जा रहा है. इसके लिए, यहां दिया गया डेटासेट इस्तेमाल किया गया है:

{ name: "Los Angeles", state: "CA", country: "USA", population: 3970000 },
{ name: "Mexico City", state: null, country: "Mexico", population: 9200000 },
{ name: "New York", state: "NY", country: "USA", population: 8530000 }
{ name: "San Francisco", state: "CA", country: "USA", population: 870000 },
{ name: "Toronto", country: "Canada", population: 2930000 },

इससे ये नतीजे मिलते हैं. इनमें "टोरंटो" और "मेक्सिको सिटी" दस्तावेज़ों को null के तौर पर और अन्य दस्तावेज़ों से पहले क्रम में लगाया गया है.

{ name: "Toronto", country: "Canada", population: 2930000 },
{ name: "Mexico City", state: null, country: "Mexico", population: 9200000 },
{ name: "Los Angeles", state: "CA", country: "USA", population: 3970000 },
{ name: "San Francisco", state: "CA", country: "USA", population: 870000 },
{ name: "New York", state: "NY", country: "USA", population: 8530000 }