क्वेरी गाइड

संग्रह की मदद से व्यवस्थित रहें अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.
किसी समस्या की शिकायत करें स्रोत देखें

इस पेज पर, कोड में मौजूद डिपेंडेंसी का पता लगाने के लिए, Bazel की क्वेरी भाषा का इस्तेमाल शुरू करने का तरीका बताया गया है.

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

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

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

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

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

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

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

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

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

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

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

Bazel की Sky Query, 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:*)'

स्टारलाक मैक्रो foo की मदद से कौनसे टारगेट जनरेट किए गए हैं?

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

//foo बनाने के लिए बिल्ड फ़ाइलों का सेट क्या है?

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/contrib को छोड़कर, foo ट्री किन पैकेज पर निर्भर करता है?

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

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

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

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

कुछ JNI (C++) लाइब्रेरी की परिभाषा देखें जो सर्वलेट ट्री में Java बाइनरी नियम के आधार पर अस्थायी रूप से निर्भर होती है.

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 परीक्षण कितनी //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)'

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

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 तक का सबसे लंबा पाथ नहीं दे सकती. हालांकि, यह शुरुआत के पॉइंट से सबसे दूर के नोड (या a) को ढूंढ सकती है या आपको x से हर उस सबसे लंबी लंबाई का पाथ दिखा सकती है जो इस पर निर्भर करता है. maxrank का इस्तेमाल करें:

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

नतीजे बताते हैं कि इस बिल्ड के क्रम में, 85 वर्ण होने चाहिए.