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

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

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

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

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

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

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

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

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

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

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

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

रिपोर्ट का इस्तेमाल करना

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

क्वेरी, आपको Bazel कोडबेस के बारे में जानने में मदद करती हैं. ऐसा करने के लिए, BUILD फ़ाइलों के बीच के संबंधों का विश्लेषण किया जाता है और उपयोगी जानकारी के लिए मिले आउटपुट की जांच की जाती है. इस गाइड में, क्वेरी के कुछ बुनियादी फ़ंक्शन की झलक दी गई है. हालांकि, ज़्यादा विकल्पों के लिए, क्वेरी गाइड देखें. क्वेरी की मदद से, 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
└── MODULE.bazel

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

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

बिल्ड चलाया जा रहा है

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

ऐसे में, इसका इस्तेमाल उन चीज़ों और डिश के बारे में जानने के लिए किया जा सकता है जो इस 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

ध्यान दें: फ़्लैग --noimplicit_deps जोड़ने से कॉन्फ़िगरेशन और संभावित टूलचेन हट जाते हैं. इससे सूची आसान हो जाती है. इस फ़्लैग को छोड़ने पर, Bazel BUILD फ़ाइल में नहीं दी गई इंप्लिसिट डिपेंडेंसी दिखाता है और आउटपुट को व्यवस्थित करता है.

ज़्यादातर मामलों में, किसी खास टारगेट की अलग-अलग आउटपुट डिपेंडेंसी देखने के लिए, क्वेरी फ़ंक्शन 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 का इस्तेमाल किया जाता है.

चेतावनी: ingredients का अपना पैकेज है, इसलिए आपको टारगेट cheese के लिए, //package:target के तौर पर एक अलग नाम रखने के तरीके का इस्तेमाल करना होगा. रेफ़रंस वाले टारगेट या लेबल के बारे में ज़्यादा पढ़ें.

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

सलाह: प्रोजेक्ट के पूरे स्कोप में खोजने के लिए, universe_scope को //... पर सेट करें

पूरे प्रोजेक्ट ‘//...’ के स्कोप में टारगेट 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 के लिए बनाई गई 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",
    ],
)

आखिर में, आपको Chef की 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 के बीच कोई पाथ ढूंढें.

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

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

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 → MacAndCheise → Chese के पहले पाथ का पालन करता है. इसके बजाय, 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 से जुड़ी क्वेरी के अलावा, यह जानने की कोशिश करें कि समीक्षा किसने लिखी है और उसमें किस पकवान के बारे में बताया है.

संकेत

काम की जानकारी के लिए टैग और डिपेंडेंसी देखें.

जवाब दें

इस समीक्षा में पिज़्ज़ा के बारे में बताया गया था और आमिर ने इसके समीक्षक थे. अगर आप यह देखें कि इस नियम में कौन-कौनसी डिपेंडेंसी हैं, जो bazel query --noimplicit\_deps 'deps(//src/main/java/com/example/reviews:review)' का इस्तेमाल करती हैं तो इस निर्देश के आधार पर पता चलता है कि आमिर समीक्षक हैं! इसके बाद, आपको पता है कि समीक्षक आमिर हैं, इसलिए क्वेरी फ़ंक्शन का इस्तेमाल करके यह पता लगाया जा सकता है कि `BUILD` फ़ाइल में कौनसा टैग है, ताकि यह पता किया जा सके कि कौनसी डिश मौजूद है. निर्देश bazel query 'attr(tags, "pizza", //src/main/java/com/example/customers/...)' से पता चलता है कि पिज़्ज़ा ऑर्डर करने वाले सिर्फ़ आमिर ही हैं और वे समीक्षक हैं जो हमें जवाब देते हैं.

रैप कर रहा है

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