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

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

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

कैंपेन का मकसद

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

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

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

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

सैंपल प्रोजेक्ट पाएं

इसके बाद, अपनी पसंद के कमांड-लाइन टूल में नीचे दिए गए तरीके को चलाकर, Bazel's Exampleडेटा स्टोर करने की जगह से सैंपल ऐप्लिकेशन फिर से पाएं:

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

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

YouTube TV का इस्तेमाल शुरू करना

Bazel क्वेरी क्या हैं?

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

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

bazel query 'query_function'

उदाहरण

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

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 में अलग-अलग किया जाता है. इन पैकेज में मौजूद नियम, अलग-अलग टैग और डिपेंडेंसी के साथ Cafe के अलग-अलग कॉम्पोनेंट को परिभाषित करते हैं.

बिल्ड चलाना

इस प्रोजेक्ट में Runner.java के अंदर एक मुख्य तरीका बताया गया है जिसे इस्तेमाल करके, कैफ़े के मेन्यू को प्रिंट किया जा सकता है. Bazel का इस्तेमाल करके, 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/… कमांड चलाएं

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

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

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

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

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

अगर, इस उदाहरण की तरह, आपके रनर का टारगेट 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() का इस्तेमाल करें.

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

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

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

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

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

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

dot -Tpng < graph.in > graph.png

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

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

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

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

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

यह देखने के लिए कि किसी खास टारगेट/पैकेज पर कौनसे टारगेट निर्भर करते हैं, आप rdeps(universe_scope, target) का इस्तेमाल कर सकते हैं. rdeps() क्वेरी फ़ंक्शन में कम से कम दो तर्क होते हैं: universe_scope — काम की डायरेक्ट्री — और target. Bazel, दिए गए 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

क्वेरी के रिटर्न से पता चलता है कि पिज़्ज़ा और macAndCheise पर चीज़ को इस्तेमाल करना पड़ता है. क्या बात है!

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

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

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

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

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

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

खुद को परखें

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

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

Cafe Bazel ने अपना मेन्यू बढ़ा दिया है — ग्राहक अब स्मूदी ऑर्डर कर सकते हैं! इस खास स्मूदी में 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 फ़ाइलों में नियमों के तौर पर जोड़ें. हर नई सामग्री के लिए एक नई JavaScript लाइब्रेरी बनाएं, जिसमें उसका नाम, सार्वजनिक तौर पर दिखने वाली जानकारी, और उसकी नई बनाई गई '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 के लिए 'src' फ़ाइल के रूप में बनाई गई Java फ़ाइल और स्मूदी की हर सामग्री के लिए आपके बनाए गए नए नियम शामिल होते हैं.

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 के बीच का पाथ ढूंढें.

'चीफ़' और 'चीज़' टारगेट के बीच के संबंध को देखकर, इन दोनों फ़ंक्शन के बीच के अंतर को समझें. एक टारगेट से दूसरे टारगेट पर जाने के कई तरीके हैं:

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

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

उदाहरण के तौर पर Cafe Bazel का इस्तेमाल करके, इसे चलाएं:

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 → MacAndCheze → Cheise का पहला पाथ है. इसके बजाय, 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 Bazel के एक ग्राहक ने, रेस्टोरेंट की पहली समीक्षा दी! माफ़ करें, समीक्षा में कुछ जानकारी मौजूद नहीं है. जैसे, समीक्षक की पहचान और उसमें किस पकवान के बारे में बताया गया है. अच्छी बात यह है कि आप Bazel की मदद से यह जानकारी ऐक्सेस कर सकते हैं. reviews के पैकेज में एक ऐसा प्रोग्राम शामिल है जो किसी ऐसे ग्राहक की समीक्षा को प्रिंट करता है जो किसी रहस्यमयी ग्राहक की समीक्षा नहीं करता है. इसे इनके साथ बनाएं और चलाएं:

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

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

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

रैप कर रहा है

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