StructuredQuery

{
  "select": {
    object (Projection)
  },
  "from": [
    {
      object (CollectionSelector)
    }
  ],
  "where": {
    object (Filter)
  },
  "orderBy": [
    {
      object (Order)
    }
  ],
  "startAt": {
    object (Cursor)
  },
  "endAt": {
    object (Cursor)
  },
  "offset": integer,
  "limit": integer,
  "findNearest": {
    object (FindNearest)
  }
}

object (Projection)

लौटाए जाने वाले फ़ील्ड का वैकल्पिक सब-सेट.

यह क्वेरी के जवाब में मिले दस्तावेज़ों पर DocumentMask की तरह काम करता है. इस नीति को सेट न करने पर, यह मान लिया जाता है कि कॉलर सभी फ़ील्ड वापस लाना चाहता है.

object (CollectionSelector)

वे कलेक्शन, जिनके बारे में क्वेरी की जानी है.

object (Filter)

लागू किया जाने वाला फ़िल्टर.

object (Order)

क्वेरी के नतीजों पर लागू करने का क्रम.

Firestore की मदद से, कॉल करने वाले लोग पूरा क्रम दे सकते हैं. साथ ही, वे किसी भी क्रम में या कोई क्रम नहीं दे सकते. सभी मामलों में, Firestore इन नियमों के ज़रिए एक स्थिर क्रम की गारंटी देता है:

• orderBy, इनइक्वालिटी फ़िल्टर के साथ इस्तेमाल किए जाने वाले सभी फ़ील्ड का रेफ़रंस देने के लिए ज़रूरी है.
• ऐसे सभी फ़ील्ड जिन्हें orderBy में शामिल करना ज़रूरी है, लेकिन जो पहले से मौजूद नहीं हैं उन्हें फ़ील्ड के नाम के शब्दकोश के क्रम में जोड़ा जाता है.
• अगर __name__ पर कोई ऑर्डर तय नहीं किया गया है, तो उसे डिफ़ॉल्ट रूप से जोड़ा जाता है.

फ़ील्ड को आखिरी ऑर्डर के क्रम में ही जोड़ा जाता है या अगर कोई क्रम तय नहीं किया गया है, तो उन्हें 'ASCENDING' के तौर पर जोड़ा जाता है. उदाहरण के लिए:

• ORDER BY a, ORDER BY a ASC, __name__ ASC हो जाता है
• ORDER BY a DESC, ORDER BY a DESC, __name__ DESC हो जाता है
• WHERE a > 1, WHERE a > 1 ORDER BY a ASC, __name__ ASC हो जाता है
• WHERE __name__ > ... AND a > 1, WHERE __name__ > ... AND a > 1 ORDER BY a ASC, __name__ ASC हो जाता है

object (Cursor)

नतीजे में किसी पोज़िशन का संभावित प्रीफ़िक्स, जिससे क्वेरी शुरू होती है.

नतीजे के सेट का क्रम, ओरिजनल क्वेरी के ORDER BY क्लॉज़ पर आधारित होता है.

SELECT * FROM k WHERE a = 1 AND b > 2 ORDER BY b ASC, __name__ ASC;

इस क्वेरी के नतीजे (b ASC, __name__ ASC) के हिसाब से क्रम में लगाए गए हैं.

कर्सर, जगह के पूरे क्रम या प्रीफ़िक्स का रेफ़रंस दे सकते हैं. हालांकि, इनमें दिए गए ORDER BY फ़ील्ड से ज़्यादा फ़ील्ड का रेफ़रंस नहीं दिया जा सकता.

ऊपर दिए गए उदाहरण को जारी रखते हुए, नीचे दिए गए स्टार्ट कर्सर अटैच करने से अलग-अलग असर होगा:

• START BEFORE (2, /k/123): क्वेरी को a = 1 AND b > 2 AND __name__ > /k/123 से ठीक पहले शुरू करें.
• START AFTER (10): क्वेरी को a = 1 AND b > 10 के तुरंत बाद शुरू करें.

शुरुआत में N नतीजों को स्किप करने के लिए, OFFSET को स्कैन करना पड़ता है, जबकि स्टार्ट कर्सर, क्वेरी को लॉजिकल पोज़िशन से शुरू करने की अनुमति देता है. किसी असल नतीजे से मैच करने के लिए, इस पोज़िशन की ज़रूरत नहीं होती. यह अगले दस्तावेज़ को ढूंढने के लिए, इस पोज़िशन से आगे की ओर स्कैन करता है.

ज़रूरी है:

• वैल्यू की संख्या, ORDER BY क्लॉज़ में बताई गई फ़ील्ड की संख्या से ज़्यादा नहीं हो सकती.

object (Cursor)

नतीजे में किसी पोज़िशन का संभावित प्रीफ़िक्स, जिसे क्वेरी को खत्म करने के लिए सेट किया गया है.

यह START_AT से मिलता-जुलता है. हालांकि, यह शुरुआती पोज़िशन के बजाय आखिरी पोज़िशन को कंट्रोल करता है.

ज़रूरी है:

• वैल्यू की संख्या, ORDER BY क्लॉज़ में बताई गई फ़ील्ड की संख्या से ज़्यादा नहीं हो सकती.

integer

पहला नतीजा लौटाने से पहले स्किप किए जाने वाले दस्तावेज़ों की संख्या.

यह WHERE, START AT, और END AT में तय की गई पाबंदियों के बाद, लेकिन LIMIT क्लॉज़ से पहले लागू होता है.

ज़रूरी है:

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

integer

दिखाए जाने वाले नतीजों की ज़्यादा से ज़्यादा संख्या.

अन्य सभी पाबंदियों के बाद लागू होता है.

ज़रूरी है:

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

object (FindNearest)

ज़रूरी नहीं. एक संभावित नज़दीकी पड़ोसी खोज.

दूसरे सभी फ़िल्टर और ऑर्डर करने के बाद लागू होता है.

दिए गए क्वेरी वेक्टर से सबसे नज़दीकी वेक्टर एम्बेड करता है.