क्विकस्टार्ट

इस ट्यूटोरियल में बताया गया है कि पहले से बनाए गए Basel प्रोजेक्ट का इस्तेमाल करके, अपने कोड में डिपेंडेंसी को ट्रेस करने के लिए Basel के साथ कैसे काम किया जा सकता है.

भाषा और --output फ़्लैग की जानकारी के लिए, Bazu क्वेरी का रेफ़रंस और Bagel cquery का रेफ़रंस इस्तेमाल करने वाले मैन्युअल देखें. कमांड लाइन पर bazel help query या bazel help cquery टाइप करके, अपने IDE में मदद पाएं.

मकसद

यह गाइड आपको बेसिक क्वेरी के सेट के बारे में बताती है. इसका इस्तेमाल, प्रोजेक्ट की फ़ाइल डिपेंडेंसी के बारे में ज़्यादा जानने के लिए किया जा सकता है. यह ऐप्लिकेशन, Basel के ऐसे नए डेवलपर के लिए है जिन्हें इस बात की बुनियादी जानकारी है कि Basel और BUILD फ़ाइलें कैसे काम करती हैं.

ज़रूरी शर्तें

अगर आपने पहले से Baकोई इंस्टॉल नहीं किया है, तो उसे इंस्टॉल करके शुरू करें. यह ट्यूटोरियल सोर्स कंट्रोल के लिए Git का इस्तेमाल करता है. इसलिए, सबसे अच्छे नतीजे पाने के लिए, Git को भी इंस्टॉल करें.

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

सैंपल प्रोजेक्ट डाउनलोड करें

इसके बाद, अपनी पसंद के कमांड-लाइन टूल में यह चलाकर, Baze के सैंपल स्टोर करने की जगह से सैंपल ऐप्लिकेशन को वापस पाएं:

git clone https://github.com/bazelbuild/examples.git

इस ट्यूटोरियल के लिए सैंपल प्रोजेक्ट, examples/query-quickstart डायरेक्ट्री में है.

शुरू करना

बेज़ल क्वेरी क्या हैं?

क्वेरी, BUILD फ़ाइलों के बीच के संबंधों का विश्लेषण करके और काम की जानकारी के लिए इससे मिले आउटपुट की जांच करती हैं. इससे आपको Basel कोड बेस के बारे में जानने में मदद मिलती है. इस गाइड में, क्वेरी के कुछ बेसिक फ़ंक्शन की झलक दिखती है. हालांकि, ज़्यादा विकल्पों के लिए क्वेरी गाइड देखें. क्वेरी की मदद से, BUILD फ़ाइलों को मैन्युअल तरीके से नेविगेट किए बिना, बड़े साइज़ के प्रोजेक्ट में डिपेंडेंसी के बारे में जाना जा सकता है.

क्वेरी चलाने के लिए, अपना कमांड लाइन टर्मिनल खोलें और यह डालें:

bazel query 'query_function'

स्थिति

कल्पना कीजिए कि Cafe बेज़ल और उसके खास शेफ़ के बीच के रिश्ते की गहराई में उतरना हो. इस कैफ़े में खास तौर पर पिज़्ज़ा और मैक, और चीज़. नीचे देखें कि इस प्रोजेक्ट को कैसे बनाया गया है:

bazelqueryguide
├── BUILD
├── src
│   └── main
│       └── java
│           └── com
│               └── example
│                   ├── customers
│                   │   ├── Jenny.java
│                   │   ├── Amir.java
│                   │   └── BUILD
│                   ├── dishes
│                   │   ├── Pizza.java
│                   │   ├── MacAndCheese.java
│                   │   └── BUILD
│                   ├── ingredients
│                   │   ├── Cheese.java
│                   │   ├── Tomatoes.java
│                   │   ├── Dough.java
│                   │   ├── Macaroni.java
│                   │   └── BUILD
│                   ├── restaurant
│                   │   ├── Cafe.java
│                   │   ├── Chef.java
│                   │   └── BUILD
│                   ├── reviews
│                   │   ├── Review.java
│                   │   └── BUILD
│                   └── Runner.java
└── WORKSPACE

इस ट्यूटोरियल के दौरान, जब तक निर्देश न दिया जाए, तब तक BUILD फ़ाइलों में अपनी ज़रूरत की जानकारी न खोजें. इसके बजाय, सिर्फ़ क्वेरी फ़ंक्शन का इस्तेमाल करें.

एक प्रोजेक्ट में कैफ़े बनाने के अलग-अलग पैकेज शामिल होते हैं. इन्हें इन ग्रुप में बांटा गया है: restaurant, ingredients, dishes, customers, और reviews. इन पैकेज के नियम, कैफ़े के अलग-अलग कॉम्पोनेंट को अलग-अलग टैग और डिपेंडेंसी के साथ तय करते हैं.

बिल्ड चलाना

इस प्रोजेक्ट में Runner.java का एक मुख्य तरीका है, जिसे एक्ज़ीक्यूट किया जा सकता है कैफ़े का मेन्यू प्रिंट करने के लिए. निर्देश देकर, Basel का इस्तेमाल करके प्रोजेक्ट बनाएं bazel build और : का इस्तेमाल करके बताएं कि टारगेट का नाम runner है. यहां जाएं: टारगेट के नाम देखकर जानें कि रेफ़रंस टारगेट तय किए हैं.

यह प्रोजेक्ट बनाने के लिए, इस निर्देश को किसी टर्मिनल में चिपकाएं:

bazel build :runner

बिल्ड पूरा होने पर, आपका आउटपुट कुछ ऐसा दिखना चाहिए.

INFO: Analyzed target //:runner (49 packages loaded, 784 targets configured).
INFO: Found 1 target...
Target //:runner up-to-date:
  bazel-bin/runner.jar
  bazel-bin/runner
INFO: Elapsed time: 16.593s, Critical Path: 4.32s
INFO: 23 processes: 4 internal, 10 darwin-sandbox, 9 worker.
INFO: Build completed successfully, 23 total actions

इसके सफलतापूर्वक बन जाने के बाद, इस आदेश को चिपकाकर ऐप्लिकेशन चलाएं:

bazel-bin/runner

--------------------- MENU -------------------------

Pizza - Cheesy Delicious Goodness
Macaroni & Cheese - Kid-approved Dinner

----------------------------------------------------

इससे आपको मेन्यू आइटम की सूची दिखेगी, जिसमें मेन्यू आइटम के बारे में कम शब्दों में जानकारी होगी.

टारगेट एक्सप्लोर करना

प्रोजेक्ट में सामग्री और पकवानों की सूची अपने-अपने पैकेज में होती है. किसी पैकेज के नियम देखने के लिए क्वेरी का इस्तेमाल करने के लिए, bazel query package/… निर्देश चलाएं

इस मामले में, आप इसका उपयोग उन सामग्रियों और व्यंजनों को देखने के लिए कर सकते हैं जो इस कैफ़े में चलाकर हैं:

bazel query //src/main/java/com/example/dishes/...

bazel query //src/main/java/com/example/ingredients/...

अगर आप सामग्री पैकेज के टारगेट के लिए क्वेरी करते हैं, तो आउटपुट इस तरह दिखना चाहिए:

//src/main/java/com/example/ingredients:cheese
//src/main/java/com/example/ingredients:dough
//src/main/java/com/example/ingredients:macaroni
//src/main/java/com/example/ingredients:tomato

डिपेंडेंसी ढूंढना

आपका रनर, किन टारगेट पर दौड़ता है?

मान लें कि आपको फ़ाइल सिस्टम पर कार्रवाई किए बिना, अपने प्रोजेक्ट के स्ट्रक्चर के बारे में गहराई से जानना है. ऐसा हो सकता है कि बड़े प्रोजेक्ट के लिए यह काम न करे. कैफ़े बेज़ल किन नियमों का इस्तेमाल करता है?

अगर इस उदाहरण की तरह, आपके रनर का टारगेट runner है, तो कमांड चलाकर पता लगाएं कि टारगेट की डिपेंडेंसी क्या है:

bazel query --noimplicit_deps "deps(target)"

bazel query --noimplicit_deps "deps(:runner)"

//:runner
//:src/main/java/com/example/Runner.java
//src/main/java/com/example/dishes:MacAndCheese.java
//src/main/java/com/example/dishes:Pizza.java
//src/main/java/com/example/dishes:macAndCheese
//src/main/java/com/example/dishes:pizza
//src/main/java/com/example/ingredients:Cheese.java
//src/main/java/com/example/ingredients:Dough.java
//src/main/java/com/example/ingredients:Macaroni.java
//src/main/java/com/example/ingredients:Tomato.java
//src/main/java/com/example/ingredients:cheese
//src/main/java/com/example/ingredients:dough
//src/main/java/com/example/ingredients:macaroni
//src/main/java/com/example/ingredients:tomato
//src/main/java/com/example/restaurant:Cafe.java
//src/main/java/com/example/restaurant:Chef.java
//src/main/java/com/example/restaurant:cafe
//src/main/java/com/example/restaurant:chef

ज़्यादातर मामलों में, किसी खास टारगेट की अलग-अलग आउटपुट डिपेंडेंसी देखने के लिए, क्वेरी फ़ंक्शन deps() का इस्तेमाल करें.

डिपेंडेंसी ग्राफ़ को विज़ुअलाइज़ करना (ज़रूरी नहीं)

इस सेक्शन में बताया गया है कि किसी खास क्वेरी के लिए, डिपेंडेंसी पाथ को कैसे विज़ुअलाइज़ किया जा सकता है. Graphviz पाथ को समतल सूची के बजाय, डायरेक्ट किए गए एकाइक्लिक ग्राफ़ इमेज के तौर पर देखने में मदद करता है. --output के कई कमांड लाइन विकल्पों का इस्तेमाल करके, Basel क्वेरी ग्राफ़ के डिसप्ले को बदला जा सकता है. विकल्पों के लिए आउटपुट फ़ॉर्मैट देखें.

अपनी पसंद की क्वेरी चलाकर शुरुआत करें और बहुत ज़्यादा टूल डिपेंडेंसी हटाने के लिए --noimplicit_deps फ़्लैग जोड़ें. इसके बाद, आउटपुट फ़्लैग वाली क्वेरी को फ़ॉलो करें और ग्राफ़ को graph.in नाम वाली फ़ाइल में सेव करें, ताकि ग्राफ़ को टेक्स्ट के तौर पर दिखाया जा सके.

टारगेट :runner की सभी डिपेंडेंसी खोजने और आउटपुट को ग्राफ़ के तौर पर फ़ॉर्मैट करने के लिए:

bazel query --noimplicit_deps 'deps(:runner)' --output graph > graph.in

इससे graph.in नाम की फ़ाइल बनती है, जो बिल्ड ग्राफ़ को टेक्स्ट के तौर पर दिखाती है. ग्राफ़विज़, PNG बनाने के लिए dot का इस्तेमाल करता है. यह ऐसा टूल है जो टेक्स्ट को विज़ुअलाइज़ेशन में प्रोसेस करता है:

dot -Tpng < graph.in > graph.png

graph.png खोलने पर, आपको कुछ ऐसा दिखेगा. इस गाइड में, पाथ की ज़रूरी जानकारी को साफ़ तौर पर बताने के लिए, नीचे दिए गए ग्राफ़ को आसान बनाया गया है.

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

रिवर्स डिपेंडेंसी ढूंढना

अगर इसके बजाय आपके पास कोई ऐसा टारगेट है जिसका विश्लेषण करना है कि दूसरे टारगेट उसका इस्तेमाल कैसे करते हैं, तो क्वेरी का इस्तेमाल करके यह पता लगाया जा सकता है कि कौनसे टारगेट किसी खास नियम पर निर्भर हैं. इसे “रिवर्स डिपेंडेंसी” कहा जाता है. किसी ऐसे कोड बेस में मौजूद फ़ाइल में बदलाव करते समय rdeps() का इस्तेमाल करना फ़ायदेमंद हो सकता है, जिसके बारे में आपको पता नहीं है. साथ ही, इससे आपको इस पर निर्भर अन्य फ़ाइलों को अनजाने में हैक करने से बचाया जा सकता है.

उदाहरण के लिए, आपको cheese सामग्री में कुछ बदलाव करने हैं. कैफ़े बेज़ल से जुड़ी समस्या से बचने के लिए, आपको यह पता लगाना होगा कि किन व्यंजनों में cheese का इस्तेमाल होता है.

यह देखने के लिए कि कौनसे टारगेट किसी खास टारगेट/पैकेज पर निर्भर हैं, rdeps(universe_scope, target) का इस्तेमाल किया जा सकता है. rdeps() क्वेरी फ़ंक्शन में कम से कम दो आर्ग्युमेंट होते हैं: universe_scope, काम की डायरेक्ट्री, और target. Baze, दिए गए universe_scope में टारगेट की रिवर्स डिपेंडेंसी खोजता है. rdeps() ऑपरेटर एक वैकल्पिक तीसरा तर्क स्वीकार करता है: खोज की डेप्थ पर ऊपरी सीमा को बताने वाला पूर्णांक लिटरल.

पूरे प्रोजेक्ट ‘//...’ के स्कोप में टारगेट cheese की रिवर्स डिपेंडेंसी देखने के लिए, यह निर्देश चलाएं:

bazel query "rdeps(universe_scope, target)"

ex) bazel query "rdeps(//... , //src/main/java/com/example/ingredients:cheese)"

//:runner
//src/main/java/com/example/dishes:macAndCheese
//src/main/java/com/example/dishes:pizza
//src/main/java/com/example/ingredients:cheese
//src/main/java/com/example/restaurant:cafe
//src/main/java/com/example/restaurant:chef

क्वेरी के जवाब से पता चलता है कि पिज़्ज़ा और macAndCheies दोनों ही चीज़ पर निर्भर करते हैं. कितना आश्चर्यचकित है!

टैग के आधार पर टारगेट ढूंढना

बेज़ल कैफ़े में जाते हुए दो ग्राहक: आमिर और जेनी. इनके नाम के अलावा, इनके बारे में कोई जानकारी नहीं है. सौभाग्य से, उनके ऑर्डर 'ग्राहक' में टैग होते हैं BUILD फ़ाइल. इस टैग को कैसे ऐक्सेस किया जा सकता है?

डेवलपर, बैज के टारगेट को अलग-अलग आइडेंटिफ़ायर से टैग कर सकते हैं. ऐसा अक्सर टेस्टिंग के मकसद से किया जाता है. उदाहरण के लिए, टेस्ट के टैग आपके डीबग और रिलीज़ प्रोसेस में किसी टेस्ट की भूमिका के बारे में बता सकते हैं. खास तौर पर, C++ और Python टेस्ट में ऐसा हो सकता है जिनमें रनटाइम की जानकारी देने की सुविधा मौजूद न हो. टैग और साइज़ एलिमेंट का इस्तेमाल करने से, कोड बेस की चेक-इन नीति के आधार पर, टेस्ट के सुइट को अलग-अलग तरह से इकट्ठा किया जा सकता है.

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

bazel query 'attr(tags, "pizza", //src/main/java/com/example/customers/...)'

यह क्वेरी 'ग्राहकों' के सभी लक्ष्य दिखाती है वह पैकेज जिसमें "पिज़्ज़ा" टैग हो.

खुद को परखें

इस क्वेरी का इस्तेमाल करके जानें कि जेनी क्या ऑर्डर करना चाहती है.

नई डिपेंडेंसी जोड़ना

Cafe Basel का मेन्यू अब बड़ा हो गया है — ग्राहक अब स्मूदी ऑर्डर कर सकते हैं! इस स्मूदी में Strawberry और Banana की चीज़ें शामिल हैं.

सबसे पहले, स्मूदी बनाने में इस्तेमाल हुई चीज़ें जोड़ें: Strawberry.java और Banana.java. खाली Java क्लास जोड़ें.

src/main/java/com/example/ingredients/Strawberry.java

package com.example.ingredients;

public class Strawberry {

}

src/main/java/com/example/ingredients/Banana.java

package com.example.ingredients;

public class Banana {

}

इसके बाद, सही डायरेक्ट्री में Smoothie.java जोड़ें: dishes.

src/main/java/com/example/dishes/Smoothie.java

package com.example.dishes;

public class Smoothie {
    public static final String DISH_NAME = "Smoothie";
    public static final String DESCRIPTION = "Yummy and Refreshing";
}

आखिर में, इन फ़ाइलों को सही BUILD फ़ाइलों में नियमों के तौर पर जोड़ें. हर नई सामग्री के लिए एक नई java लाइब्रेरी बनाएं, जिसमें उसका नाम, सार्वजनिक रूप से दिखाई देने की सुविधा, और उसका नया बनाया गया 'src' शामिल हो फ़ाइल से लिए जाते हैं. आपको इस अपडेट की गई BUILD फ़ाइल का इस्तेमाल करना चाहिए:

src/main/java/com/example/ingredients/BUILD

java_library(
    name = "cheese",
    visibility = ["//visibility:public"],
    srcs = ["Cheese.java"],
)

java_library(
    name = "dough",
    visibility = ["//visibility:public"],
    srcs = ["Dough.java"],
)

java_library(
    name = "macaroni",
    visibility = ["//visibility:public"],
    srcs = ["Macaroni.java"],
)

java_library(
    name = "tomato",
    visibility = ["//visibility:public"],
    srcs = ["Tomato.java"],
)

java_library(
    name = "strawberry",
    visibility = ["//visibility:public"],
    srcs = ["Strawberry.java"],
)

java_library(
    name = "banana",
    visibility = ["//visibility:public"],
    srcs = ["Banana.java"],
)

पकवानों की BUILD फ़ाइल में, आपको Smoothie के लिए एक नया नियम जोड़ना है. ऐसा करने में Smoothie के लिए बनाई गई Java फ़ाइल, 'src' के तौर पर शामिल होती है फ़ाइल में बताए गए हैं और स्मूदी की हर सामग्री के लिए आपके बनाए नए नियम हैं.

src/main/java/com/example/dishes/BUILD

java_library(
    name = "macAndCheese",
    visibility = ["//visibility:public"],
    srcs = ["MacAndCheese.java"],
    deps = [
        "//src/main/java/com/example/ingredients:cheese",
        "//src/main/java/com/example/ingredients:macaroni",
    ],
)

java_library(
    name = "pizza",
    visibility = ["//visibility:public"],
    srcs = ["Pizza.java"],
    deps = [
        "//src/main/java/com/example/ingredients:cheese",
        "//src/main/java/com/example/ingredients:dough",
        "//src/main/java/com/example/ingredients:tomato",
    ],
)

java_library(
    name = "smoothie",
    visibility = ["//visibility:public"],
    srcs = ["Smoothie.java"],
    deps = [
        "//src/main/java/com/example/ingredients:strawberry",
        "//src/main/java/com/example/ingredients:banana",
    ],
)

आखिर में, आपको शेफ़ की BUILD फ़ाइल में डिपेंडेंसी के तौर पर स्मूदी को शामिल करना है.

src/main/java/com/example/restaurant/BUILD

java\_library(
    name = "chef",
    visibility = ["//visibility:public"],
    srcs = [
        "Chef.java",
    ],

    deps = [
        "//src/main/java/com/example/dishes:macAndCheese",
        "//src/main/java/com/example/dishes:pizza",
        "//src/main/java/com/example/dishes:smoothie",
    ],
)

java\_library(
    name = "cafe",
    visibility = ["//visibility:public"],
    srcs = [
        "Cafe.java",
    ],
    deps = [
        ":chef",
    ],
)

यह पक्का करने के लिए कि कोई गड़बड़ी नहीं है, cafe को फिर से बिल्ड करें. अगर यह सफलतापूर्वक बन जाता है, तो बधाई! आपने 'कैफ़े' के लिए एक नई डिपेंडेंसी जोड़ी है. अगर ऐसा नहीं है, तो पैकेज का नाम और स्पेलिंग की गलतियां देखें. BUILD फ़ाइलों में लिखने के बारे में ज़्यादा जानने के लिए, बिल्ड स्टाइल गाइड देखें.

अब, पिछली डिपेंडेंसी से तुलना करने के लिए Smoothie के साथ नए डिपेंडेंसी ग्राफ़ को विज़ुअलाइज़ करें. साफ़ तौर पर समझने के लिए, ग्राफ़ के इनपुट को graph2.in और graph2.png नाम दें.

bazel query --noimplicit_deps 'deps(:runner)' --output graph > graph2.in

dot -Tpng < graph2.in > graph2.png

graph2.png में आपको पता चलता है कि Smoothie किसी दूसरे व्यंजन पर निर्भर नहीं है. हालांकि, यह सिर्फ़ एक और टारगेट है, जिस पर Chef निर्भर करता है.

somepath() और allpaths()

अगर आपको यह पूछना है कि एक पैकेज दूसरे पैकेज पर क्यों निर्भर है, तो क्या होगा? दोनों के बीच डिपेंडेंसी पाथ दिखाने से जवाब मिलता है.

डिपेंडेंसी पाथ ढूंढने में दो फ़ंक्शन आपकी मदद कर सकते हैं: somepath() और allpaths(). शुरुआती टारगेट S और आखिरी पॉइंट E दिए जाने पर, somepath(S,E) का इस्तेमाल करके S और E के बीच का पाथ ढूंढें.

'शेफ़' के बीच के संबंध को देखकर उनके बीच के अंतर जानें और 'चीज़' टारगेट के लिए. एक टारगेट से दूसरे टारगेट तक पहुंचने के लिए, अलग-अलग पाथ उपलब्ध हैं:

• शेफ़ → MacAndCheies → चीज़
• शेफ़ → पिज़्ज़ा → चीज़

somepath() आपको इन दोनों विकल्पों में से एक पाथ देता है, जबकि 'allpaths()' हर संभावित पाथ का आउटपुट देता है.

कैफ़े बेज़ल का उदाहरण के तौर पर इस्तेमाल करके, इन निर्देशों को चलाएं:

bazel query "somepath(//src/main/java/com/example/restaurant/..., //src/main/java/com/example/ingredients:cheese)"

//src/main/java/com/example/restaurant:cafe
//src/main/java/com/example/restaurant:chef
//src/main/java/com/example/dishes:macAndCheese
//src/main/java/com/example/ingredients:cheese

यह नतीजा Cafe → Chef → MacAndCheies → Cheey का पहला पाथ है. इसके बजाय, allpaths() का इस्तेमाल करने पर आपको ये फ़ायदे मिलेंगे:

bazel query "allpaths(//src/main/java/com/example/restaurant/..., //src/main/java/com/example/ingredients:cheese)"

//src/main/java/com/example/dishes:macAndCheese
//src/main/java/com/example/dishes:pizza
//src/main/java/com/example/ingredients:cheese
//src/main/java/com/example/restaurant:cafe
//src/main/java/com/example/restaurant:chef

allpaths() के आउटपुट को पढ़ना थोड़ा मुश्किल होता है, क्योंकि यह डिपेंडेंसी की सभी वैल्यू वाली सूची में शामिल है. ग्राफ़विज़ का इस्तेमाल करके इस ग्राफ़ को विज़ुअलाइज़ करने से, संबंध समझने में आसान हो जाता है.

खुद को परखें

Cafe बेज़ल के ग्राहकों में से एक ने रेस्टोरेंट की पहली समीक्षा दी! माफ़ करें, समीक्षा में कुछ जानकारी मौजूद नहीं है. जैसे, समीक्षा करने वाले की पहचान बताना और उसमें किस पकवान के बारे में जानकारी देनी है. अच्छी बात यह है कि आपको बैजल से यह जानकारी मिल सकती है. reviews पैकेज में एक प्रोग्राम होता है. यह प्रोग्राम किसी ऐसे ग्राहक की समीक्षा को प्रिंट करता है जो इसके बारे में नहीं जानता. इसे बनाने और चलाने के लिए:

bazel build //src/main/java/com/example/reviews:review

bazel-bin/src/main/java/com/example/reviews/review

सिर्फ़ बेज़ल से जुड़ी क्वेरी के बाद यह जानने की कोशिश करें कि समीक्षा किसने लिखी है और वे किस पकवान के बारे में बता रहे थे.

खत्म हो रहा है

बधाई हो! अब आपके पास कई बेसिक क्वेरी हैं. इन्हें अपने प्रोजेक्ट पर आज़माया जा सकता है. क्वेरी लैंग्वेज सिंटैक्स के बारे में ज़्यादा जानने के लिए, क्वेरी रेफ़रंस पेज देखें. क्या आपको और बेहतर क्वेरी चाहिए? क्वेरी गाइड में, इस गाइड में दिए गए इस्तेमाल के उदाहरणों की तुलना में, इस्तेमाल के ज़्यादा उदाहरणों की पूरी जानकारी दिखती है.