इस ट्यूटोरियल में, पहले से बनाए गए Bazel प्रोजेक्ट का इस्तेमाल करके, अपने कोड में डिपेंडेंसी को ट्रैक करने के लिए, Bazel के साथ काम करने का तरीका बताया गया है.
भाषा और --output फ़्लैग की जानकारी के लिए, Bazel क्वेरी रेफ़रंस और Bazel cquery रेफ़रंस मैन्युअल देखें. कमांड लाइन पर bazel help query या bazel help cquery टाइप करके, अपने आईडीई में मदद पाएं.
मकसद
इस गाइड में, आपको बुनियादी क्वेरी के बारे में बताया गया है. इनका इस्तेमाल करके, अपने प्रोजेक्ट की फ़ाइल डिपेंडेंसी के बारे में ज़्यादा जाना जा सकता है. यह ऐप्लिकेशन, Basel के ऐसे नए डेवलपर के लिए बनाया गया है जिन्हें इस बात की बुनियादी जानकारी है कि Basel और BUILD फ़ाइलें कैसे काम करती हैं.
ज़रूरी शर्तें
अगर आपने पहले से Baकोई इंस्टॉल नहीं किया है, तो उसे इंस्टॉल करके शुरू करें. इस ट्यूटोरियल में, सोर्स कंट्रोल के लिए Git का इस्तेमाल किया गया है. इसलिए, बेहतर नतीजों के लिए, Git भी इंस्टॉल करें.
डिपेंडेंसी ग्राफ़ को विज़ुअलाइज़ करने के लिए, Graphviz टूल का इस्तेमाल किया जाता है. इसे डाउनलोड करके, इस टूल का इस्तेमाल किया जा सकता है.
सैंपल प्रोजेक्ट पाना
इसके बाद, अपने पसंदीदा कमांड-लाइन टूल में यह कमांड चलाकर, Bazel के उदाहरणों के रिपॉज़िटरी से सैंपल ऐप्लिकेशन पाएं:
git clone https://github.com/bazelbuild/examples.git
इस ट्यूटोरियल का सैंपल प्रोजेक्ट, examples/query-quickstart डायरेक्ट्री में मौजूद है.
शुरू करना
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. इन पैकेज में मौजूद नियम, अलग-अलग टैग और डिपेंडेंसी की मदद से, कैफ़े के अलग-अलग कॉम्पोनेंट तय करते हैं.
बिल्ड चलाना
इस प्रोजेक्ट में Runner.java के अंदर एक मुख्य तरीका है, जिसे कैफ़े का मेन्यू प्रिंट करने के लिए इस्तेमाल किया जा सकता है. bazel build कमांड का इस्तेमाल करके, Bazel की मदद से प्रोजेक्ट बनाएं. साथ ही, : का इस्तेमाल करके यह सिग्नल दें कि टारगेट का नाम 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, dot का इस्तेमाल करके PNG बनाता है. यह एक ऐसा टूल है जो टेक्स्ट को विज़ुअलाइज़ेशन में बदलता है:
dot -Tpng < graph.in > graph.png
graph.png खोलने पर, आपको कुछ ऐसा दिखेगा. इस गाइड में, पाथ की ज़रूरी जानकारी को साफ़ तौर पर दिखाने के लिए, नीचे दिए गए ग्राफ़ को आसान बनाया गया है.
इससे, इस गाइड में अलग-अलग क्वेरी फ़ंक्शन के आउटपुट देखने में मदद मिलती है.
रिवर्स डिपेंडेंसी ढूंढना
अगर आपके पास कोई ऐसा टारगेट है जिसका इस्तेमाल दूसरे टारगेट करते हैं, तो क्वेरी का इस्तेमाल करके यह पता लगाया जा सकता है कि कौनसे टारगेट किसी खास नियम पर निर्भर हैं. इसे “रिवर्स डिपेंडेंसी” कहा जाता है. rdeps() का इस्तेमाल करना, किसी ऐसे कोड बेस में फ़ाइल में बदलाव करते समय मददगार हो सकता है जिसके बारे में आपको पता नहीं है. साथ ही, इससे आपको इस पर निर्भर अन्य फ़ाइलों से अनजाने में डेटा ऐक्सेस करने से रोका जा सकता है.
उदाहरण के लिए, आपको cheese नाम के किसी इंग्रीडिएंट में कुछ बदलाव करने हैं. Cafe Bazel को कोई समस्या न हो, इसके लिए आपको यह देखना होगा कि कौनसे डिश 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
क्वेरी के नतीजों से पता चलता है कि पिज़्ज़ा और मैक ऐंड चीज़, दोनों में चीज़ का इस्तेमाल किया जाता है. वाह! क्या सरप्राइज़ है!
टैग के आधार पर टारगेट ढूंढना
दो ग्राहक, अमीर और जेनी, 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 फ़ाइलों में नियमों के तौर पर जोड़ें. हर नए इंग्रीडिएंट के लिए एक नई 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 के लिए '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 को फिर से बनाएं, ताकि यह पक्का किया जा सके कि कोई गड़बड़ी न हो. अगर यह प्रोसेस पूरी हो जाती है, तो बधाई! आपने '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 को देखकर, यह पता चलता है कि Smoothie में अन्य डिश के साथ कोई डिपेंडेंसी शेयर नहीं की गई है. हालांकि, यह सिर्फ़ एक और टारगेट है जिस पर Chef निर्भर करता है.
somepath() और allpaths()
अगर आपको यह जानना है कि एक पैकेज, दूसरे पैकेज पर क्यों निर्भर करता है, तो क्या करना होगा? दोनों के बीच डिपेंडेंसी पाथ दिखाने से जवाब मिल जाता है.
डिपेंडेंसी पाथ ढूंढने के लिए, दो फ़ंक्शन इस्तेमाल किए जा सकते हैं: somepath() और allpaths(). शुरुआती टारगेट S और आखिरी पॉइंट E दिया गया है. somepath(S,E) का इस्तेमाल करके, S और E के बीच का पाथ ढूंढें.
'चीफ़' और 'चीज़' के टारगेट के बीच के संबंध को देखकर, इन दो फ़ंक्शन के बीच का अंतर देखें. एक टारगेट से दूसरे टारगेट तक पहुंचने के लिए, अलग-अलग पाथ उपलब्ध हैं:
- शेफ़ → मैक ऐंड चीज़ → चीज़
- शेफ़ → पिज़्ज़ा → चीज़
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 का इस्तेमाल करके इस ग्राफ़ को विज़ुअलाइज़ करने से, संबंध को समझना आसान हो जाता है.
खुद को टेस्ट करना
Cafe बेज़ल के ग्राहकों में से एक ने रेस्टोरेंट की पहली समीक्षा दी! माफ़ करें, समीक्षा में कुछ जानकारी मौजूद नहीं है. जैसे, समीक्षक की पहचान और किस डिश के बारे में बताई गई है. अच्छी बात यह है कि Bazel की मदद से, इस जानकारी को ऐक्सेस किया जा सकता है. reviews पैकेज में एक प्रोग्राम होता है, जो किसी गुप्त ग्राहक की समीक्षा को प्रिंट करता है. इसे इनकी मदद से बनाएं और चलाएं:
bazel build //src/main/java/com/example/reviews:review
bazel-bin/src/main/java/com/example/reviews/review
सिर्फ़ Bazel क्वेरी का इस्तेमाल करके, यह पता लगाने की कोशिश करें कि समीक्षा किसने लिखी है और उन्होंने किस डिश के बारे में बताया है.
संकेत
काम की जानकारी के लिए, टैग और डिपेंडेंसी देखें.
जवाब
इस समीक्षा में पिज़्ज़ा के बारे में बताया गया था और समीक्षा करने वाले व्यक्ति का नाम आमिर था. अगर bazel query --noimplicit\_deps 'deps(//src/main/java/com/example/reviews:review)' का इस्तेमाल करके, इस नियम की डिपेंडेंसी देखी जाती है, तो इस कमांड के नतीजे से पता चलता है कि समीक्षक आमिर है!
इसके बाद, आपको पता है कि समीक्षक का नाम आमिर है. इसलिए, क्वेरी फ़ंक्शन का इस्तेमाल करके, यह देखा जा सकता है कि आमिर के पास `BUILD` फ़ाइल में कौनसा टैग है. इससे यह पता चलेगा कि उसमें कौनसी डिश है.
bazel query 'attr(tags, "pizza", //src/main/java/com/example/customers/...)' कमांड से पता चलता है कि आमिर ही एक ऐसा ग्राहक है जिसने पिज़्ज़ा ऑर्डर किया है. साथ ही, वह समीक्षक भी है जिसने हमें जवाब दिया है.
खत्म हो रहा है
बधाई हो! आपने अब कई बुनियादी क्वेरी चलाई हैं. इन्हें अपने प्रोजेक्ट पर आज़माया जा सकता है. क्वेरी लैंग्वेज सिंटैक्स के बारे में ज़्यादा जानने के लिए, क्वेरी का रेफ़रंस पेज देखें. क्या आपको ज़्यादा बेहतर क्वेरी चाहिए? क्वेरी गाइड में, इस गाइड में दिए गए इस्तेमाल के उदाहरणों की तुलना में, इस्तेमाल के ज़्यादा उदाहरणों की पूरी जानकारी दिखती है.