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

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

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

मकसद

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

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

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

डिपेंडेंसी ग्राफ़ को विज़ुअलाइज़ करने के लिए, Graphviz नाम के टूल का इस्तेमाल किया जाता है. इसे डाउनलोड करके, साथ-साथ काम किया जा सकता है.

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

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

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

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

शुरू करना

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

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

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

bazel query 'query_function'

स्थिति

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

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
└── MODULE.bazel

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

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

बिल्ड चलाना

इस प्रोजेक्ट में 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/… कमांड चलाएं

इस मामले में, इस कैफ़े में मौजूद सामग्री और पकवानों के बारे में जानने के लिए, यह क्वेरी चलाएं:

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() का इस्तेमाल करें.

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

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

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

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

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

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

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

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

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

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

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

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

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

इस क्वेरी से, 'customers' पैकेज में मौजूद वे सभी टारगेट दिखते हैं जिनमें "pizza" टैग है.

खुद की जांच करें

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

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

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 फ़ाइलों में नियमों के तौर पर जोड़ें. हर नए कॉम्पोनेंट के लिए एक नई 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 को फिर से बनाएं, ताकि यह पक्का किया जा सके कि कोई गड़बड़ी नहीं है. अगर यह सही तरीके से बन जाता है, तो बधाई हो! आपने 'Cafe' के लिए एक नई डिपेंडेंसी जोड़ी है. अगर ऐसा नहीं है, तो वर्तनी की गलतियों और पैकेज के नाम की जांच करें. BUILD फ़ाइलें लिखने के बारे में ज़्यादा जानने के लिए, BUILD स्टाइल गाइड देखें.

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

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

dot -Tpng < graph2.in > graph2.png

graph2.png को देखने पर पता चलता है कि इसकी कोई भी डिपेंडेंसी, अन्य डिश के साथ शेयर नहीं की गई है. हालांकि, यह सिर्फ़ एक ऐसा टारगेट है जिस पर Chef निर्भर करता है.Smoothie

somepath() और allpaths()

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

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

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

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

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 → MacAndCheese → Cheese के पहले पाथ के हिसाब से है. इसके बजाय, 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() का आउटपुट पढ़ना थोड़ा मुश्किल होता है, क्योंकि यह डिपेंडेंसी की फ़्लैट की गई सूची होती है. Graphviz का इस्तेमाल करके इस ग्राफ़ को विज़ुअलाइज़ करने से, संबंध को बेहतर तरीके से समझा जा सकता है.

खुद की जांच करें

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

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

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

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

रैप अप

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