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

किसी समस्या की शिकायत करें सोर्स देखें Nightly · 7.4 .

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

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

मकसद

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

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

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

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

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

इसके बाद, अपने पसंदीदा कमांड-लाइन टूल में यह कमांड चलाकर, 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

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

आपका रनर, रनिंग के लिए किन टारगेट पर भरोसा करता है?

मान लें कि आपको फ़ाइल सिस्टम में बदलाव किए बिना, अपने प्रोजेक्ट के स्ट्रक्चर के बारे में ज़्यादा जानकारी चाहिए. ऐसा बड़े प्रोजेक्ट के लिए नहीं किया जा सकता. कैफ़े बेज़ल किन नियमों का इस्तेमाल करता है?

अगर इस उदाहरण की तरह, आपके रनर का टारगेट 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 जोड़ने से, कॉन्फ़िगरेशन और संभावित टूलचेन हट जाते हैं, ताकि सूची को आसान बनाया जा सके. जब इस फ़्लैग को छोड़ दिया जाता है, तो Baज़र, BUILD फ़ाइल में उन इंप्लिसिट डिपेंडेंसी दिखाता है जिनके बारे में BUILD फ़ाइल में नहीं बताया गया है. साथ ही, आउटपुट को व्यवस्थित कर देता है.

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

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

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

बेज़ल कैफ़े में जाते हुए दो ग्राहक: आमिर और जेनी. इनके नाम के अलावा, इनके बारे में कोई जानकारी नहीं है. सौभाग्य से, उनके ऑर्डर 'ग्राहक' 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 के लिए एक नया नियम जोड़ना है. ऐसा करने पर, इसमें 'src' फ़ाइल के तौर पर Smoothie के लिए बनाई गई 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 के बीच का पाथ ढूंढें.

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

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

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 के एक ग्राहक ने रेस्टोरेंट की पहली समीक्षा की! माफ़ करें, समीक्षा में कुछ जानकारी मौजूद नहीं है. जैसे, समीक्षक की पहचान और किस डिश के बारे में बताई गई है. अच्छी बात यह है कि 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/...)' कमांड से पता चलता है कि आमिर ही एक ऐसा ग्राहक है जिसने पिज़्ज़ा ऑर्डर किया है. साथ ही, वह समीक्षक भी है जिसने हमें जवाब दिया है.

आखिर में खास जानकारी

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