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