क्वेरी गाइड

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

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

टारगेट मौजूद न होने जैसी गड़बड़ियों को अनदेखा करके क्वेरी चलाने के लिए, --keep_going फ़्लैग का इस्तेमाल करें.

किसी नियम की डिपेंडेंसी ढूंढना

//foo की डिपेंडेंसी देखने के लिए, bazel query में deps फ़ंक्शन का इस्तेमाल करें:

$ bazel query "deps(//foo)"
//foo:foo
//foo:foo-dep
...

यह //foo बनाने के लिए ज़रूरी सभी टारगेट का सेट है.

दो पैकेज के बीच डिपेंडेंसी चेन को ट्रेस करना

लाइब्रेरी //third_party/zlib:zlibonly, //foo के लिए BUILD फ़ाइल में नहीं है. हालांकि, यह एक अप्रत्यक्ष डिपेंडेंसी है. हम इस डिपेंडेंसी पाथ को कैसे ट्रेस कर सकते हैं? यहां दो काम के फ़ंक्शन दिए गए हैं: allpaths और somepath. अगर आपको सिर्फ़ यह जानना है कि आपके बनाए गए आर्टफ़ैक्ट में क्या-क्या शामिल है, न कि हर संभावित जॉब, तो आपको --notool_deps के साथ टूलिंग डिपेंडेंसी को भी बाहर रखना पड़ सकता है.

सभी डिपेंडेंसी का ग्राफ़ देखने के लिए, bazel query के आउटपुट को dot कमांड-लाइन टूल के ज़रिए पाइप करें:

$ bazel query "allpaths(//foo, third_party/...)" --notool_deps --output graph | dot -Tsvg > /tmp/deps.svg

जब डिपेंडेंसी ग्राफ़ बड़ा और जटिल होता है, तो एक पाथ से शुरुआत करना मददगार हो सकता है:

$ bazel query "somepath(//foo:foo, third_party/zlib:zlibonly)"
//foo:foo
//translations/tools:translator
//translations/base:base
//third_party/py/MySQL:MySQL
//third_party/py/MySQL:_MySQL.so
//third_party/mysql:mysql
//third_party/zlib:zlibonly

अगर आपने allpaths के साथ --output graph की जानकारी नहीं दी है, तो आपको डिपेंडेंसी ग्राफ़ की फ़्लैट की गई सूची मिलेगी.

$ bazel query "allpaths(//foo, third_party/...)"
  ...many errors detected in BUILD files...
//foo:foo
//translations/tools:translator
//translations/tools:aggregator
//translations/base:base
//tools/pkg:pex
//tools/pkg:pex_phase_one
//tools/pkg:pex_lib
//third_party/python:python_lib
//translations/tools:messages
//third_party/py/xml:xml
//third_party/py/xml:utils/boolean.so
//third_party/py/xml:parsers/sgmlop.so
//third_party/py/xml:parsers/pyexpat.so
//third_party/py/MySQL:MySQL
//third_party/py/MySQL:_MySQL.so
//third_party/mysql:mysql
//third_party/openssl:openssl
//third_party/zlib:zlibonly
//third_party/zlib:zlibonly_v1_2_3
//third_party/python:headers
//third_party/openssl:crypto

अन्य जानकारी: इंप्लिसिट डिपेंडेंसी

//foo के लिए BUILD फ़ाइल, //translations/tools:aggregator को कभी रेफ़रंस नहीं करती. तो, डायरेक्ट डिपेंडेंसी कहां है?

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

रिवर्स डिपेंडेंसी

आपको उन टारगेट के सेट के बारे में जानना पड़ सकता है जो किसी टारगेट पर निर्भर करते हैं. उदाहरण के लिए, अगर आपको कोई कोड बदलना है, तो आपको यह पता होना चाहिए कि कौनसे दूसरे कोड काम नहीं करेंगे. u के ट्रांज़िटिव क्लोज़र में, x में मौजूद टारगेट की रिवर्स डिपेंडेंसी ढूंढने के लिए, rdeps(u, x) का इस्तेमाल किया जा सकता है.

Bazel की स्काई क्वेरी में allrdeps फ़ंक्शन काम करता है. इसकी मदद से, तय किए गए यूनिवर्स में रिवर्स डिपेंडेंसी के बारे में क्वेरी की जा सकती है.

अन्य इस्तेमाल

bazel query का इस्तेमाल करके, कई डिपेंडेंसी रिलेशनशिप का विश्लेषण किया जा सकता है.

... क्या मौजूद है

foo के नीचे कौनसे पैकेज मौजूद हैं?

bazel query 'foo/...' --output package

foo पैकेज में कौनसे नियम तय किए गए हैं?

bazel query 'kind(rule, foo:*)' --output label_kind

foo पैकेज में मौजूद नियमों से कौनसी फ़ाइलें जनरेट होती हैं?

bazel query 'kind("generated file", //foo:*)'

starlark मैक्रो foo से कौनसे टारगेट जनरेट होते हैं?

bazel query 'attr(generator_function, foo, //path/to/search/...)'

//foo को बनाने के लिए, BUILD फ़ाइलों के किस सेट की ज़रूरत होती है?

bazel query 'buildfiles(deps(//foo))' | cut -f1 -d:

test_suite में कौन-कौनसे अलग-अलग टेस्ट शामिल होते हैं?

bazel query 'tests(//foo:smoke_tests)'

इनमें से C++ टेस्ट कौनसे हैं?

bazel query 'kind(cc_.*, tests(//foo:smoke_tests))'

इनमें से कौनसी छोटी हैं? मीडियम? बड़ा?

bazel query 'attr(size, small, tests(//foo:smoke_tests))'

bazel query 'attr(size, medium, tests(//foo:smoke_tests))'

bazel query 'attr(size, large, tests(//foo:smoke_tests))'

foo के नीचे मौजूद ऐसे कौनसे टेस्ट हैं जो किसी पैटर्न से मेल खाते हैं?

bazel query 'filter("pa?t", kind(".*_test rule", //foo/...))'

पैटर्न एक रेगुलर एक्सप्रेशन है और इसे नियम के पूरे नाम पर लागू किया जाता है. यह

bazel query 'kind(".*_test rule", //foo/...)' | grep -E 'pa?t'

path/to/file/bar.java फ़ाइल किस पैकेज में मौजूद है?

 bazel query path/to/file/bar.java --output=package

path/to/file/bar.java? के लिए बिल्ड लेबल क्या है

bazel query path/to/file/bar.java

किन नियमों के टारगेट में, फ़ाइल path/to/file/bar.java को सोर्स के तौर पर इस्तेमाल किया गया है?

fullname=$(bazel query path/to/file/bar.java)
bazel query "attr('srcs', $fullname, ${fullname//:*/}:*)"

इस पैकेज की कौनसी डिपेंडेंसी मौजूद हैं ...

foo किन पैकेज पर निर्भर करता है? (foo बनाने के लिए मुझे क्या देखना होगा)

bazel query 'buildfiles(deps(//foo:foo))' --output package

foo ट्री, foo/contrib को छोड़कर किन पैकेज पर निर्भर करता है?

bazel query 'deps(foo/... except foo/contrib/...)' --output package

नियम की कौनसी डिपेंडेंसी मौजूद हैं ...

बार, जनप्रोटो के किन नियमों पर निर्भर करता है?

bazel query 'kind(genproto, deps(bar/...))'

सर्वलेट ट्री में, Java बाइनरी नियम के ज़रिए ट्रांज़िटिव तौर पर निर्भर रहने वाली कुछ JNI (C++) लाइब्रेरी की परिभाषा ढूंढें.

bazel query 'some(kind(cc_.*library, deps(kind(java_binary, //java/com/example/frontend/...))))' --output location
...अब उन सभी Java बाइनरी की परिभाषाएं ढूंढें जो इन पर निर्भर हैं
bazel query 'let jbs = kind(java_binary, //java/com/example/frontend/...) in
  let cls = kind(cc_.*library, deps($jbs)) in
    $jbs intersect allpaths($jbs, $cls)'

फ़ाइल की निर्भरताएं क्या हैं ...

foo बनाने के लिए, Java की कौनसी सोर्स फ़ाइलें ज़रूरी हैं?

सोर्स फ़ाइलें:

bazel query 'kind("source file", deps(//path/to/target/foo/...))' | grep java$

जनरेट की गई फ़ाइलें:

bazel query 'kind("generated file", deps(//path/to/target/foo/...))' | grep java$

QUX के टेस्ट बनाने के लिए, Java की सोर्स फ़ाइलों का पूरा सेट क्या है?

सोर्स फ़ाइलें:

bazel query 'kind("source file", deps(kind(".*_test rule", javatests/com/example/qux/...)))' | grep java$

जनरेट की गई फ़ाइलें:

bazel query 'kind("generated file", deps(kind(".*_test rule", javatests/com/example/qux/...)))' | grep java$

X और Y के बीच डिपेंडेंसी में क्या अंतर है ...

//foo किन टारगेट पर निर्भर करता है, जबकि //foo:foolib उन पर निर्भर नहीं करता?

bazel query 'deps(//foo) except deps(//foo:foolib)'

foo टेस्ट, किन C++ लाइब्रेरी पर निर्भर करते हैं, जबकि //foo प्रोडक्शन बाइनरी उन पर निर्भर नहीं करती?

bazel query 'kind("cc_library", deps(kind(".*test rule", foo/...)) except deps(//foo))'

यह डिपेंडेंसी क्यों मौजूद है ...

bar, groups2 पर क्यों निर्भर करता है?

bazel query 'somepath(bar/...,groups2/...:*)'

इस क्वेरी के नतीजे मिलने के बाद, आपको अक्सर यह पता चलेगा कि एक टारगेट, bar की अनचाही या गंभीर और अवांछित डिपेंडेंसी के तौर पर अलग दिखता है. इसके बाद, क्वेरी को और बेहतर बनाया जा सकता है, ताकि:

मुझे docker/updater:updater_systest (एक py_test) से लेकर उन cc_library तक का पाथ दिखाओ जिन पर यह निर्भर करता है:

bazel query 'let cc = kind(cc_library, deps(docker/updater:updater_systest)) in
  somepath(docker/updater:updater_systest, $cc)'

लाइब्रेरी //photos/frontend:lib, एक ही लाइब्रेरी //third_party/jpeglib और //third_party/jpeg के दो वैरिएंट पर क्यों निर्भर करती है?

इस क्वेरी का मतलब यह है कि "मुझे //photos/frontend:lib का ऐसा सबग्राफ़ दिखाओ जो दोनों लाइब्रेरी पर निर्भर करता हो". टपॉलॉजिकल क्रम में दिखाए जाने पर, नतीजे का आखिरी एलिमेंट समस्या की वजह हो सकता है.

bazel query 'allpaths(//photos/frontend:lib, //third_party/jpeglib)
                intersect
               allpaths(//photos/frontend:lib, //third_party/jpeg)'
//photos/frontend:lib
//photos/frontend:lib_impl
//photos/frontend:lib_dispatcher
//photos/frontend:icons
//photos/frontend/modules/gadgets:gadget_icon
//photos/thumbnailer:thumbnail_lib
//third_party/jpeg/img:renderer

... किस पर निर्भर करता है

बार के नीचे मौजूद कौनसे नियम, Y पर निर्भर करते हैं?

bazel query 'bar/... intersect allpaths(bar/..., Y)'

टी के पैकेज में, कौनसे टारगेट सीधे तौर पर टी पर निर्भर करते हैं?

bazel query 'same_pkg_direct_rdeps(T)'

मैं किसी डिपेंडेंसी को कैसे हटाऊं ...

bar को X पर निर्भर न रहने देने के लिए, मुझे किन डिपेंडेंसी पाथ को तोड़ना होगा?

ग्राफ़ को svg फ़ाइल में आउटपुट करने के लिए:

bazel query 'allpaths(bar/...,X)' --output graph | dot -Tsvg > /tmp/dep.svg

अन्य सुविधाएं

//foo-tests बनाने के लिए, क्रम से कितने चरण होते हैं?

माफ़ करें, क्वेरी लैंग्वेज फ़िलहाल आपको x से y तक का सबसे लंबा पाथ नहीं दिखा सकती. हालांकि, यह शुरुआती नोड से सबसे दूर मौजूद नोड का पता लगा सकती है. इसके अलावा, यह आपको x से y तक के सबसे लंबे पाथ की लंबाई दिखा सकती है. maxrank का इस्तेमाल करें:

bazel query 'deps(//foo-tests)' --output maxrank | tail -1
85 //third_party/zlib:zutil.c

नतीजे से पता चलता है कि 85 की लंबाई वाले पाथ मौजूद हैं, जो इस बिल्ड में क्रम से होने चाहिए.