Halaman ini merupakan panduan referensi untuk Bahasa Kueri Bazel yang digunakan
saat Anda menggunakan bazel query
untuk menganalisis dependensi build. Bagian ini juga
menjelaskan format output yang didukung bazel query
.
Untuk kasus penggunaan praktis, lihat Petunjuk Bazel Query.
Referensi kueri tambahan
Selain query
, yang berjalan pada grafik target fase pasca-pemuatan,
Bazel menyertakan kueri grafik tindakan dan kueri yang dapat dikonfigurasi.
Kueri grafik tindakan
Kueri grafik tindakan (aquery
) beroperasi di Grafik Target
yang Dikonfigurasi setelah analisis dan menampilkan informasi tentang Tindakan, Artefak, dan
hubungannya. aquery
berguna saat Anda tertarik dengan
properti Actions/Artifacts yang dihasilkan dari Grafik Target yang Dikonfigurasi.
Misalnya, perintah aktual berjalan beserta input, output, dan mnemoniknya.
Untuk detail selengkapnya, lihat referensi kueri.
Kueri yang dapat dikonfigurasi
Kueri Bazel tradisional berjalan pada grafik target fase pasca-pemuatan sehingga
tidak memiliki konsep konfigurasi dan konsep terkaitnya. Secara khusus, fungsi ini tidak menyelesaikan pernyataan pilih dengan benar dan menampilkan semua kemungkinan resolusi pilihan. Namun, lingkungan kueri yang dapat dikonfigurasi, cquery
, menangani konfigurasi dengan benar, tetapi tidak menyediakan semua fungsi kueri asli ini.
Untuk detail selengkapnya, lihat referensi cquery.
Contoh
Bagaimana cara orang menggunakan bazel query
? Berikut adalah contoh umumnya:
Mengapa pohon //foo
bergantung pada //bar/baz
?
Menampilkan jalur:
somepath(foo/..., //bar/baz:all)
Library C++ apa yang menjadi dependensi dari semua pengujian foo
yang
tidak bergantung pada target foo_bin
?
kind("cc_library", deps(kind(".*test rule", foo/...)) except deps(//foo:foo_bin))
Token: Sintaksis leksikal
Ekspresi dalam bahasa kueri terdiri dari token berikut:
Kata kunci, seperti
let
. Kata kunci adalah kata khusus dalam bahasa tersebut, dan masing-masing dijelaskan di bawah ini. Rangkaian kata kunci lengkap adalah:Kata, seperti "
foo/...
" atau ".*test rule
" atau "//bar/baz:all
". Jika urutan karakter "diberi tanda kutip" (diawali dan diakhiri dengan tanda kutip tunggal ' atau diawali dan diakhiri dengan tanda kutip ganda "), itu adalah kata. Jika urutan karakter tidak dikutip, urutan tersebut masih dapat diurai sebagai kata. Kata yang tidak dikutip adalah urutan karakter yang diambil dari karakter alfabet A-Za-z, angka 0-9, dan karakter khusus*/@.-_:$~[]
(tanda bintang, garis miring ke depan, di, titik, tanda hubung, garis bawah, titik dua, tanda dolar, tanda gelombang, kurung kurawal buka, tanda kurung kuadrat kanan). Namun, kata yang tidak dikutip mungkin tidak diawali dengan tanda hubung-
atau tanda bintang*
meskipun [nama target][(/konsep/label#target-names) relatif mungkin dimulai dengan karakter tersebut.Kata yang tidak dikutip juga tidak boleh menyertakan karakter tanda plus
+
atau tanda sama dengan=
, meskipun karakter tersebut diizinkan dalam nama target. Saat menulis kode yang menghasilkan ekspresi kueri, nama target harus dikutip.Kutipan diperlukan saat menulis skrip yang membuat ekspresi kueri Bazel dari nilai yang disediakan pengguna.
//foo:bar+wiz # WRONG: scanned as //foo:bar + wiz. //foo:bar=wiz # WRONG: scanned as //foo:bar = wiz. "//foo:bar+wiz" # OK. "//foo:bar=wiz" # OK.
Perhatikan bahwa penawaran ini merupakan tambahan untuk penawaran apa pun yang mungkin diperlukan oleh shell Anda, seperti:
bazel query ' "//foo:bar=wiz" ' # single-quotes for shell, double-quotes for Bazel.
Kata kunci, jika dikutip, dianggap sebagai kata-kata biasa. Misalnya,
some
adalah kata kunci, tetapi "beberapa" adalah kata.foo
dan "foo" adalah kata.Namun, berhati-hatilah saat menggunakan tanda kutip tunggal atau ganda pada nama target. Saat mengutip satu atau beberapa nama target, gunakan hanya satu jenis tanda kutip (baik semua tanda kutip tunggal maupun ganda).
Berikut adalah contoh dari apa yang akan menjadi string kueri Java:
'a"'a' # WRONG: Error message: unclosed quotation. "a'"a" # WRONG: Error message: unclosed quotation. '"a" + 'a'' # WRONG: Error message: unexpected token 'a' after query expression '"a" + ' "'a' + "a"" # WRONG: Error message: unexpected token 'a' after query expression ''a' + ' "a'a" # OK. 'a"a' # OK. '"a" + "a"' # OK "'a' + 'a'" # OK
Kami memilih sintaks ini sehingga dalam kebanyakan kasus, tanda kutip tidak diperlukan. Contoh
".*test rule"
(yang tidak biasa) memerlukan tanda kutip: yang dimulai dengan titik dan berisi spasi. Mengutip"cc_library"
tidak perlu, tetapi tidak berbahaya.Tanda baca, seperti tanda kurung
()
, titik.
, dan koma,
. Kata yang berisi tanda baca (selain pengecualian yang tercantum di atas) harus dikutip.
Karakter spasi kosong di luar kata yang dikutip akan diabaikan.
Konsep bahasa kueri Bazel
Bahasa kueri Bazel adalah bahasa ekspresi. Setiap ekspresi dievaluasi ke kumpulan target yang diurutkan sebagian, atau yang setara, grafik (DAG) target. Ini adalah satu-satunya datatype.
Kumpulan dan grafik merujuk pada jenis data yang sama, tetapi menekankan aspek yang berbeda dari data tersebut, misalnya:
- Tetapkan: Urutan sebagian target tidaklah menarik.
- Grafik: Urutan parsial target bersifat signifikan.
Siklus dalam grafik dependensi
Grafik dependensi build harus bersifat asiklik.
Algoritma yang digunakan oleh bahasa kueri ditujukan untuk digunakan dalam grafik asiklik, tetapi kuat terhadap siklus. Detail tentang cara siklus diperlakukan tidak ditentukan dan tidak boleh diandalkan.
Dependensi implisit
Selain membuat dependensi yang ditentukan secara eksplisit dalam file BUILD
,
Bazel menambahkan dependensi implisit tambahan ke aturan. Misalnya,
setiap aturan Java secara implisit bergantung pada JavaBuilder. Dependensi implisit
dibuat menggunakan atribut yang diawali dengan $
dan
tidak dapat diganti dalam file BUILD
.
Per default bazel query
memperhitungkan dependensi implisit
saat menghitung hasil kueri. Perilaku ini dapat diubah dengan
opsi --[no]implicit_deps
. Perlu diperhatikan bahwa, karena kueri tidak mempertimbangkan konfigurasi, toolchain potensial tidak akan pernah dipertimbangkan.
Tingkat Kesehatan
Ekspresi bahasa kueri Bazel beroperasi di atas grafik
dependensi build, yang merupakan grafik yang secara implisit ditentukan oleh semua
deklarasi aturan dalam semua file BUILD
. Penting untuk dipahami
bahwa grafik ini agak abstrak, dan bukan merupakan
deskripsi lengkap tentang cara melakukan semua langkah build. Untuk menjalankan build, konfigurasi juga diperlukan. Lihat bagian konfigurasi pada Panduan Pengguna untuk mengetahui detail lebih lanjut.
Hasil evaluasi ekspresi dalam bahasa kueri Bazel benar untuk semua konfigurasi, yang berarti mungkin pendekatan berlebihan konservatif, dan tidak terlalu akurat. Jika Anda menggunakan alat kueri untuk menghitung kumpulan semua file sumber yang diperlukan selama build, alat tersebut mungkin melaporkan lebih dari yang sebenarnya diperlukan karena, misalnya, alat kueri akan menyertakan semua file yang diperlukan untuk mendukung terjemahan pesan, meskipun Anda tidak bermaksud menggunakan fitur tersebut di build Anda.
Tentang pemeliharaan urutan grafik
Operasi mempertahankan batasan pengurutan apa pun yang diwarisi dari subekspresinya. Anda dapat menganggapnya
sebagai "hukum kekekalan urutan parsial". Pertimbangkan contohnya: jika Anda mengeluarkan kueri untuk menentukan penutupan transitif dependensi target tertentu, kumpulan yang dihasilkan akan diurutkan sesuai dengan grafik dependensi. Jika Anda memfilter yang ditetapkan untuk hanya menyertakan target jenis file
, hubungan pengurutan parsial transitif yang sama akan berlaku antara setiap pasangan target dalam subset yang dihasilkan, meskipun tidak satu pun dari pasangan ini yang benar-benar terhubung langsung dalam grafik asli.
(Tidak ada tepi file-file dalam grafik dependensi build).
Namun, meskipun semua operator mempertahankan urutan, beberapa operasi, seperti operasi kumpulan tidak memperkenalkan batasan pengurutannya sendiri. Pertimbangkan ekspresi ini:
deps(x) union y
Urutan kumpulan hasil akhir dijamin akan mempertahankan semua batasan pengurutan subekspresinya, yaitu, semua dependensi transitif x
diurutkan dengan benar satu sama lain. Namun, kueri ini tidak menjamin apa pun terkait pengurutan target di y
, atau tentang urutan target di deps(x)
dibandingkan dengan target di y
(kecuali untuk target di y
yang juga ada di deps(x)
).
Operator yang menerapkan batasan pengurutan meliputi: allpaths
, deps
, rdeps
, somepath
, dan karakter pengganti pola target package:*
, dir/...
, dll.
Kueri terkait langit
Kueri Langit adalah mode kueri yang beroperasi pada cakupan alam semesta yang ditentukan.
Fungsi khusus hanya tersedia di SkyQuery
Mode Kueri Sky memiliki fungsi kueri tambahan allrdeps
dan
rbuildfiles
. Fungsi ini beroperasi di seluruh cakupan alam semesta (itulah sebabnya fungsi ini tidak masuk akal untuk Kueri normal).
Menentukan cakupan alam semesta
Mode Kueri Sky diaktifkan dengan meneruskan dua flag berikut: (--universe_scope
atau --infer_universe_scope
) dan --order_output=no
.
--universe_scope=<target_pattern1>,...,<target_patternN>
memberi tahu kueri untuk
memuat sebelumnya penutupan transitif pola target yang ditentukan oleh pola target, yang dapat
bersifat tambahan dan subtraktif. Semua kueri kemudian dievaluasi dalam "cakupan" ini. Secara khusus, operator allrdeps
dan rbuildfiles
hanya menampilkan hasil dari cakupan ini.
--infer_universe_scope
memberi tahu Bazel untuk menyimpulkan nilai --universe_scope
dari ekspresi kueri. Nilai yang disimpulkan ini adalah daftar pola target unik dalam
ekspresi kueri, tetapi mungkin bukan yang Anda inginkan. Contoh:
bazel query --infer_universe_scope --order_output=no "allrdeps(//my:target)"
Daftar pola target unik dalam ekspresi kueri ini adalah ["//my:target"]
, sehingga
Bazel memperlakukan ini sama seperti panggilan:
bazel query --universe_scope=//my:target --order_output=no "allrdeps(//my:target)"
Namun, hasil kueri dengan --universe_scope
tersebut hanya //my:target
;
tidak satu pun dependensi terbalik //my:target
ada di alam semesta, melalui
konstruksi tersebut. Di sisi lain, pertimbangkan:
bazel query --infer_universe_scope --order_output=no "tests(//a/... + b/...) intersect allrdeps(siblings(rbuildfiles(my/starlark/file.bzl)))"
Ini adalah pemanggilan kueri yang bermakna yang mencoba menghitung target pengujian dalam perluasan target tests
di beberapa direktori yang secara transitif bergantung pada target yang definisinya menggunakan file .bzl
tertentu. Di sini, --infer_universe_scope
sangat membantu, terutama dalam kasus ketika pilihan --universe_scope
akan mengharuskan Anda untuk mengurai ekspresi kueri sendiri.
Jadi, untuk ekspresi kueri yang menggunakan operator cakupan alam semesta seperti
allrdeps
dan
rbuildfiles
, pastikan untuk menggunakan
--infer_universe_scope
hanya jika perilakunya sesuai dengan keinginan Anda.
Sky Query memiliki beberapa kelebihan dan kekurangan dibandingkan dengan kueri {i>default<i}. Kelemahan utamanya
adalah tidak dapat mengurutkan output sesuai dengan urutan grafik sehingga format output tertentu dilarang. Keuntungannya adalah adanya
dua operator (allrdeps
dan
rbuildfiles
) yang tidak tersedia di kueri default.
Selain itu, Sky Query melakukan tugasnya dengan memasukkan grafik Skyframe, bukan membuat grafik baru, yang merupakan fungsi dari implementasi default. Oleh karena itu, ada beberapa situasi saat proses ini
lebih cepat dan menggunakan lebih sedikit memori.
Ekspresi: Sintaksis dan semantik tata bahasa
Ini adalah tata bahasa bahasa kueri Bazel, yang dinyatakan dalam notasi EBNF:
expr ::= word
| let name = expr in expr
| (expr)
| expr intersect expr
| expr ^ expr
| expr union expr
| expr + expr
| expr except expr
| expr - expr
| set(word *)
| word '(' int | word | expr ... ')'
Bagian berikut ini menjelaskan setiap pembuatan tata bahasa ini secara berurutan.
Pola target
expr ::= word
Secara sintaksis, pola target hanyalah sebuah kata. Hal ini ditafsirkan sebagai kumpulan target (tidak berurutan). Pola target yang paling sederhana adalah label, yang mengidentifikasi satu target (file atau aturan). Misalnya, pola target //foo:bar
dievaluasi ke kumpulan yang berisi satu elemen, target, dan aturan bar
.
Pola target menggeneralisasi label untuk menyertakan karakter pengganti dibandingkan paket dan
target. Misalnya, foo/...:all
(atau hanya foo/...
) adalah pola target yang mengevaluasi ke kumpulan yang berisi semua aturan di setiap paket secara rekursif di bawah direktori foo
; bar/baz:all
adalah pola target yang mengevaluasi ke kumpulan yang berisi semua aturan dalam paket bar/baz
, tetapi bukan sub-paketnya.
Demikian pula, foo/...:*
adalah pola target yang mengevaluasi kumpulan yang berisi
semua target (aturan dan file) di setiap paket secara berulang di bawah
direktori foo
; bar/baz:*
mengevaluasi ke kumpulan yang berisi semua target dalam
paket bar/baz
, tetapi bukan sub-paketnya.
Karena karakter pengganti :*
cocok dengan file serta aturan, karakter ini sering kali lebih berguna daripada :all
untuk kueri. Sebaliknya, karakter pengganti :all
(implisit dalam
pola target seperti foo/...
) biasanya lebih berguna untuk build.
Pola target bazel query
berfungsi sama seperti target build bazel build
.
Untuk mengetahui detail selengkapnya, lihat Pola Target, atau
ketik bazel help target-syntax
.
Pola target dapat dievaluasi ke kumpulan singleton (dalam kasus label), ke kumpulan yang berisi banyak elemen (seperti pada kasus foo/...
, yang memiliki ribuan elemen) atau kumpulan kosong, jika pola target tidak cocok dengan target.
Semua node dalam hasil ekspresi pola target diurutkan dengan benar
secara relatif terhadap satu sama lain sesuai dengan hubungan dependensi. Jadi, hasil dari
foo:*
bukan hanya kumpulan target dalam paket foo
, tetapi juga merupakan
grafik atas target tersebut. (Tidak ada jaminan yang dibuat terkait pengurutan relatif node hasil terhadap node lain.) Untuk detail selengkapnya, lihat bagian
urutan grafik.
Variabel
expr ::= let name = expr1 in expr2
| $name
Bahasa kueri Bazel memungkinkan definisi dan referensi ke variabel. Hasil evaluasi ekspresi let
sama dengan
expr2, dengan semua kemunculan bebas
variabel name diganti dengan nilai
expr1.
Misalnya, let v = foo/... in allpaths($v, //common) intersect $v
setara dengan allpaths(foo/...,//common) intersect foo/...
.
Kemunculan referensi variabel name
selain dalam
ekspresi let name = ...
yang disertakan merupakan
error. Dengan kata lain, ekspresi kueri tingkat atas tidak boleh memiliki variabel bebas.
Dalam produksi tata bahasa di atas, name
seperti word, tetapi dengan
batasan tambahan, kata tersebut menjadi ID hukum dalam bahasa
pemrograman C. Referensi ke variabel tersebut harus diawali dengan karakter "$".
Setiap ekspresi let
hanya menentukan variabel tunggal, tetapi Anda dapat menyarangkannya.
Baik pola target maupun referensi variabel hanya terdiri dari satu token, sebuah kata, yang menimbulkan ambiguitas sintaksis. Namun, tidak ada ambiguitas semantik, karena subkumpulan kata yang merupakan nama variabel hukum terpisah dari subkumpulan kata yang merupakan pola target hukum.
Secara teknis, ekspresi let
tidak meningkatkan
ekspresi bahasa kueri: kueri apa pun yang dapat dinyatakan dalam
bahasa tersebut juga dapat diekspresikan tanpanya. Namun, kueri tersebut
akan meningkatkan keringkasan banyak kueri, dan juga dapat menghasilkan evaluasi kueri
yang lebih efisien.
Ekspresi yang diberi tanda kurung
expr ::= (expr)
Tanda kurung mengaitkan subekspresi untuk memaksa urutan evaluasi. Ekspresi yang diberi tanda kurung mengevaluasi nilai argumennya.
Operasi himpunan aljabar: intersection, union, set difference
expr ::= expr intersect expr
| expr ^ expr
| expr union expr
| expr + expr
| expr except expr
| expr - expr
Ketiga operator ini menghitung operasi kumpulan yang biasa dilakukan melalui argumen mereka.
Setiap operator memiliki dua bentuk, bentuk nominal, seperti intersect
, dan
bentuk simbolis, seperti ^
. Kedua bentuk itu setara;
bentuk simbolik lebih cepat diketik. (Agar lebih jelas, bagian lain halaman ini menggunakan bentuk nominal.)
Misalnya,
foo/... except foo/bar/...
mengevaluasi ke kumpulan target yang cocok dengan foo/...
, tetapi tidak cocok dengan foo/bar/...
.
Anda dapat menulis kueri yang sama dengan:
foo/... - foo/bar/...
Operasi intersect
(^
) dan union
(+
) bersifat komutatif (simetris);
except
(-
) bersifat asimetris. Parser memperlakukan ketiga operator sebagai
terkait kiri dan memiliki prioritas sama sehingga Anda mungkin memerlukan tanda kurung. Misalnya, dua ekspresi pertama ini setara, tetapi yang ketiga tidak:
x intersect y union z
(x intersect y) union z
x intersect (y union z)
Baca target dari sumber eksternal: ditetapkan
expr ::= set(word *)
Operator set(a b c ...)
menghitung gabungan dari nol atau beberapa pola target, yang dipisahkan oleh spasi kosong (tanpa koma).
Bersama dengan fitur $(...)
shell Bourne, set()
menyediakan
cara untuk menyimpan hasil dari satu kueri dalam file teks biasa, memanipulasi
file teks tersebut menggunakan program lain (seperti alat shell UNIX standar), lalu
memperkenalkan hasilnya kembali ke alat kueri sebagai nilai untuk
pemrosesan lebih lanjut. Contoh:
bazel query deps(//my:target) --output=label | grep ... | sed ... | awk ... > foo
bazel query "kind(cc_binary, set($(<foo)))"
Pada contoh berikutnya,kind(cc_library, deps(//some_dir/foo:main, 5))
dihitung dengan memfilter nilai maxrank
menggunakan program awk
.
bazel query 'deps(//some_dir/foo:main)' --output maxrank | awk '($1 < 5) { print $2;} ' > foo
bazel query "kind(cc_library, set($(<foo)))"
Dalam contoh ini, $(<foo)
adalah singkatan untuk $(cat foo)
, tetapi perintah
shell selain cat
juga dapat digunakan—seperti perintah awk
sebelumnya.
Fungsi
expr ::= word '(' int | word | expr ... ')'
Bahasa kueri mendefinisikan beberapa fungsi. Nama fungsi menentukan jumlah dan jenis argumen yang diperlukan. Fungsi berikut tersedia:
allpaths
attr
buildfiles
rbuildfiles
deps
filter
kind
labels
loadfiles
rdeps
allrdeps
same_pkg_direct_rdeps
siblings
some
somepath
tests
visible
Penutupan transitif dependensi: dependensi
expr ::= deps(expr)
| deps(expr, depth)
Operator deps(x)
mengevaluasi ke grafik yang dibentuk oleh penutupan transitif dependensi kumpulan argumen x. Misalnya, nilai deps(//foo)
adalah grafik dependensi yang di-root pada foo
node tunggal, termasuk semua dependensinya. Nilai deps(foo/...)
adalah grafik dependensi yang root-nya
adalah semua aturan dalam setiap paket di bawah direktori foo
. Dalam konteks ini, 'dependensi' hanya berarti target aturan dan file, sehingga file BUILD
dan Starlark yang diperlukan untuk membuat target tersebut tidak disertakan di sini. Untuk itu,
Anda harus menggunakan operator buildfiles
.
Grafik yang dihasilkan diurutkan sesuai dengan hubungan dependensi. Untuk detail selengkapnya, lihat bagian tentang urutan grafik.
Operator deps
menerima argumen kedua opsional, yang merupakan literal integer yang menentukan batas atas pada kedalaman penelusuran. Jadi,
deps(foo:*, 0)
menampilkan semua target dalam paket foo
, sementara
deps(foo:*, 1)
selanjutnya menyertakan prasyarat langsung target apa pun dalam
paket foo
, dan deps(foo:*, 2)
selanjutnya mencakup node yang langsung
dapat dijangkau dari node di deps(foo:*, 1)
, dan seterusnya. (Angka ini
sesuai dengan peringkat yang ditampilkan dalam format output minrank
.)
Jika parameter depth dihilangkan, penelusuran tidak akan dibatasi: penelusuran akan menghitung penutupan transitif refleksif prasyarat.
Penutupan transitif dependensi terbalik: rdeps
expr ::= rdeps(expr, expr)
| rdeps(expr, expr, depth)
Operator rdeps(u, x)
bernilai dependensi terbalik dari argumen yang ditetapkan
x dalam penutupan transitif kumpulan alam semesta
u.
Grafik yang dihasilkan diurutkan sesuai dengan hubungan dependensi. Lihat bagian urutan grafik untuk detail selengkapnya.
Operator rdeps
menerima argumen ketiga opsional, yang merupakan literal integer yang menentukan batas atas pada kedalaman penelusuran. Grafik yang dihasilkan hanya menyertakan node dalam jarak kedalaman yang ditentukan dari node mana pun dalam kumpulan argumen. Jadi, rdeps(//foo, //common, 1)
mengevaluasi ke semua node dalam penutupan transitif //foo
yang secara langsung bergantung pada //common
. (Angka
ini sesuai dengan peringkat yang ditampilkan dalam format output
minrank
.) Jika parameter depth dihilangkan, penelusuran tidak akan dibatasi.
Penutupan transitif dari semua dependensi terbalik: allrdeps
expr ::= allrdeps(expr)
| allrdeps(expr, depth)
Operator allrdeps
berperilaku seperti operator rdeps
, kecuali bahwa "universe set" adalah apa pun yang dievaluasi dari flag --universe_scope
, bukan ditentukan secara terpisah. Jadi, jika --universe_scope=//foo/...
diteruskan, allrdeps(//bar)
akan setara dengan rdeps(//foo/..., //bar)
.
Dependensi terbalik langsung dalam paket yang sama: same_pkg_direct_rdeps
expr ::= same_pkg_direct_rdeps(expr)
Operator same_pkg_direct_rdeps(x)
mengevaluasi ke kumpulan lengkap target
yang berada dalam paket yang sama dengan target dalam kumpulan argumen, dan yang langsung bergantung padanya.
Berurusan dengan paket target: saudara kandung
expr ::= siblings(expr)
Operator siblings(x)
mengevaluasi kumpulan target lengkap yang ada dalam
paket yang sama dengan target dalam kumpulan argumen.
Pilihan arbitrer: beberapa
expr ::= some(expr)
| some(expr, count )
Operator some(x, k)
memilih maksimal k target secara acak dari
kumpulan argumennya x, dan mengevaluasi ke kumpulan yang hanya berisi
target tersebut. Parameter k bersifat opsional; jika tidak ada, hasilnya adalah kumpulan singleton yang hanya berisi satu target yang dipilih secara arbitrer. Jika ukuran kumpulan argumen x lebih kecil dari k, seluruh kumpulan argumen x akan ditampilkan.
Misalnya, ekspresi some(//foo:main union //bar:baz)
dievaluasi ke
kumpulan singleton yang berisi //foo:main
atau //bar:baz
—meskipun
ada yang tidak ditentukan. Ekspresi some(//foo:main union //bar:baz, 2)
atau
some(//foo:main union //bar:baz, 3)
menampilkan //foo:main
dan
//bar:baz
.
Jika argumennya adalah singleton, some
akan menghitung fungsi identitas: some(//foo:main)
setara dengan //foo:main
.
Akan terjadi error jika kumpulan argumen yang ditentukan kosong, seperti dalam ekspresi some(//foo:main intersect //bar:baz)
.
Operator jalur: somepath, allpaths
expr ::= somepath(expr, expr)
| allpaths(expr, expr)
Operator somepath(S, E)
dan
allpaths(S, E)
menghitung jalur antara dua kumpulan target. Kedua kueri menerima dua
argumen, yaitu kumpulan S titik awal dan
kumpulan E titik akhir. somepath
menampilkan grafik node di beberapa jalur arbitrer dari target di S ke target di E; allpaths
menampilkan grafik node di semua jalur dari target mana pun di S ke target mana pun di E.
Grafik yang dihasilkan diurutkan sesuai dengan hubungan dependensi. Lihat bagian urutan grafik untuk detail selengkapnya.
Pemfilteran jenis target: jenis
expr ::= kind(word, expr)
Operator kind(pattern, input)
menerapkan filter ke kumpulan target, dan menghapus target yang tidak sesuai dengan harapan. Parameter pattern
menentukan jenis target yang akan dicocokkan.
Misalnya, jenis untuk empat target yang ditentukan oleh file BUILD
(untuk paket p
) yang ditampilkan di bawah ini diilustrasikan dalam tabel:
Code | Target | Jenis |
---|---|---|
genrule( name = "a", srcs = ["a.in"], outs = ["a.out"], cmd = "...", ) |
//p:a |
aturan genrule |
//p:a.in |
file sumber | |
//p:a.out |
file yang dihasilkan | |
//p:BUILD |
file sumber |
Dengan demikian, kind("cc_.* rule", foo/...)
mengevaluasi ke kumpulan
semua cc_library
, cc_binary
, dll.,
target aturan di bawah foo
, dan kind("source file", deps(//foo))
mengevaluasi ke kumpulan semua file sumber dalam penutupan
transitif dependensi target //foo
.
Kutipan argumen pattern sering kali diperlukan karena tanpanya, banyak ekspresi reguler, seperti source
file
dan .*_test
, tidak dianggap sebagai kata oleh parser.
Saat mencocokkan dengan package group
, target yang diakhiri dengan :all
mungkin tidak memberikan hasil apa pun. Gunakan :all-targets
sebagai gantinya.
Pemfilteran nama target: filter
expr ::= filter(word, expr)
Operator filter(pattern, input)
menerapkan filter ke kumpulan target, dan menghapus target yang labelnya (dalam bentuk absolut) tidak cocok dengan pola; operator akan mengevaluasi ke subset inputnya.
Argumen pertama, pattern adalah kata yang berisi
ekspresi reguler daripada nama target. Ekspresi filter
dievaluasi ke kumpulan yang berisi semua target x sedemikian rupa sehingga
x merupakan anggota kumpulan input dan
label (dalam bentuk absolut, seperti //foo:bar
)
x berisi kecocokan (tanpa anchor) untuk ekspresi reguler pattern. Karena semua
nama target diawali dengan //
, nama ini dapat digunakan sebagai alternatif
untuk anchor ekspresi reguler ^
.
Operator ini sering kali memberikan alternatif yang jauh lebih cepat dan lebih andal untuk
operator intersect
. Misalnya, untuk melihat semua dependensi bar
dari target //foo:foo
, seseorang dapat mengevaluasi
deps(//foo) intersect //bar/...
Namun, pernyataan ini akan memerlukan penguraian semua file BUILD
dalam
hierarki bar
, yang akan lambat dan rentan terhadap error dalam
file BUILD
yang tidak relevan. Alternatifnya adalah:
filter(//bar, deps(//foo))
yang pertama akan menghitung kumpulan dependensi //foo
, lalu hanya memfilter target yang cocok dengan pola yang diberikan—dengan kata lain, target dengan nama yang berisi //bar
sebagai substring.
Penggunaan umum lain dari operator filter(pattern,
expr)
adalah untuk memfilter file tertentu berdasarkan nama atau ekstensinya. Misalnya,
filter("\.cc$", deps(//foo))
akan menyediakan daftar semua file .cc
yang digunakan untuk membuat //foo
.
Pemfilteran atribut aturan: attr
expr ::= attr(word, word, expr)
Operator
attr(name, pattern, input)
menerapkan filter ke kumpulan target, dan menghapus target yang tidak memiliki aturan, target aturan yang tidak memiliki atribut name
yang ditentukan, atau target aturan yang nilai atributnya tidak cocok dengan
ekspresi reguler pattern yang diberikan; operator tersebut mengevaluasi
ke subset inputnya.
Argumen pertama, name adalah nama atribut aturan
yang harus dicocokkan dengan pola
ekspresi reguler yang diberikan. Argumen kedua,
pattern adalah ekspresi reguler pada nilai
atribut. Ekspresi attr
dievaluasi ke kumpulan yang berisi semua target
x sedemikian rupa sehingga x adalah
anggota dari kumpulan input, merupakan aturan dengan atribut
yang ditentukan name, dan nilai atribut berisi
kecocokan (tanpa jangkar) untuk ekspresi reguler
pattern. Jika name adalah
atribut opsional dan aturan tidak menentukannya secara eksplisit, nilai atribut
default akan digunakan untuk perbandingan. Misalnya,
attr(linkshared, 0, deps(//foo))
akan memilih semua dependensi //foo
yang diizinkan memiliki atribut linkshared (seperti aturan cc_binary
) dan menyetelnya secara eksplisit ke 0 atau tidak menyetelnya sama sekali, kecuali nilai defaultnya adalah 0 (misalnya untuk aturan cc_binary
).
Atribut jenis daftar (seperti srcs
, data
, dll.)
dikonversi menjadi string bentuk [value<sub>1</sub>, ..., value<sub>n</sub>]
,
dimulai dengan tanda kurung [
, diakhiri dengan tanda kurung ]
dan menggunakan ",
" (koma, spasi) untuk membatasi beberapa nilai.
Label dikonversi menjadi string menggunakan bentuk label absolut. Misalnya, atribut deps=[":foo",
"//otherpkg:bar", "wiz"]
akan dikonversi ke
string [//thispkg:foo, //otherpkg:bar, //thispkg:wiz]
.
Tanda kurung selalu ada, sehingga daftar kosong akan menggunakan nilai string []
untuk tujuan pencocokan. Misalnya,
attr("srcs", "\[\]", deps(//foo))
akan memilih semua aturan di antara dependensi //foo
yang memiliki
atribut srcs
kosong, sementara
attr("data", ".{3,}", deps(//foo))
akan memilih semua aturan di antara dependensi //foo
yang menentukan
setidaknya satu nilai dalam atribut data
(setiap label memiliki panjang minimal
3 karakter karena //
dan :
).
Untuk memilih semua aturan di antara dependensi //foo
dengan value
tertentu dalam atribut jenis daftar, gunakan
attr("tags", "[\[ ]value[,\]]", deps(//foo))
Cara ini berfungsi karena karakter sebelum value
akan menjadi [
atau spasi dan
karakter setelah value
akan menjadi koma atau ]
.
Pemfilteran visibilitas aturan: terlihat
expr ::= visible(expr, expr)
Operator visible(predicate, input)
menerapkan filter ke kumpulan target, dan menghapus target yang tidak memiliki visibilitas yang diperlukan.
Argumen pertama, predicate, adalah kumpulan target yang harus dapat dilihat oleh semua target dalam output. Ekspresi visible akan dievaluasi ke kumpulan yang berisi semua target x sehingga x adalah anggota dari input yang ditetapkan, dan untuk semua target y dalam predicate x dapat dilihat oleh y. Contoh:
visible(//foo, //bar:*)
akan memilih semua target dalam paket //bar
yang dapat diandalkan //foo
tanpa melanggar pembatasan visibilitas.
Evaluasi atribut aturan dari label jenis: label
expr ::= labels(word, expr)
Operator labels(attr_name, inputs)
menampilkan kumpulan target yang ditentukan dalam atribut attr_name dari jenis "label" atau "daftar label" dalam beberapa aturan dalam kumpulan inputs.
Misalnya, labels(srcs, //foo)
menampilkan kumpulan target yang muncul dalam atribut srcs
aturan //foo
. Jika ada beberapa aturan
dengan atribut srcs
di dalam kumpulan inputs, gabungan srcs
-nya akan ditampilkan.
Memperluas dan memfilter test_suites: pengujian
expr ::= tests(expr)
Operator tests(x)
menampilkan kumpulan semua aturan
pengujian dalam kumpulan x, yang memperluas aturan test_suite
apa pun ke
kumpulan pengujian individual yang dirujuk, dan menerapkan pemfilteran menurut
tag
dan size
.
Secara default, evaluasi kueri
mengabaikan target non-pengujian di semua aturan test_suite
. Ini dapat diubah menjadi error dengan opsi --strict_test_suite
.
Misalnya, kueri kind(test, foo:*)
mencantumkan semua aturan *_test
dan test_suite
dalam paket foo
. Semua hasilnya (menurut
definisi) merupakan anggota paket foo
. Sebaliknya,
kueri tests(foo:*)
akan menampilkan semua
pengujian individual yang akan dijalankan oleh bazel test
foo:*
: ini dapat mencakup pengujian milik paket lain,
yang direferensikan secara langsung atau tidak langsung
melalui aturan test_suite
.
File definisi paket: buildfiles
expr ::= buildfiles(expr)
Operator buildfiles(x)
menampilkan kumpulan
file yang menentukan paket setiap target dalam
kumpulan x; dengan kata lain, untuk setiap paket, file BUILD
-nya,
ditambah file .bzl yang direferensikannya melalui load
. Perhatikan bahwa cara ini
juga menampilkan file BUILD
dari paket yang berisi
file load
tersebut.
Operator ini biasanya digunakan saat menentukan file atau
paket yang diperlukan untuk membuat target yang ditentukan, sering kali bersama dengan
opsi --output package
, di bawah). Misalnya,
bazel query 'buildfiles(deps(//foo))' --output package
menampilkan kumpulan semua paket yang secara transitif bergantung //foo
.
File definisi paket: rbuildfiles
expr ::= rbuildfiles(word, ...)
Operator rbuildfiles
mengambil daftar fragmen jalur yang dipisahkan koma dan menampilkan
kumpulan file BUILD
yang secara transitif bergantung pada fragmen jalur ini. Misalnya, jika
//foo
adalah paket, rbuildfiles(foo/BUILD)
akan menampilkan
target //foo:BUILD
. Jika file foo/BUILD
memiliki
load('//bar:file.bzl'...
di dalamnya, rbuildfiles(bar/file.bzl)
akan
menampilkan target //foo:BUILD
, serta target untuk semua file BUILD
lainnya yang
memuat //bar:file.bzl
Cakupan operator --universe_scope
. File yang tidak berhubungan langsung dengan file BUILD
dan file .bzl
tidak memengaruhi hasil. Misalnya, file sumber (seperti foo.cc
) akan diabaikan,
meskipun disebutkan secara eksplisit dalam file BUILD
. Namun, Symlink diterapkan, sehingga jika foo/BUILD
adalah symlink ke bar/BUILD
, rbuildfiles(bar/BUILD)
akan menyertakan //foo:BUILD
dalam hasilnya.
Operator rbuildfiles
secara moral hampir merupakan kebalikan dari operator buildfiles
. Namun, inversi moral ini
berpegang lebih kuat dalam satu arah: output rbuildfiles
sama seperti
input buildfiles
; yang pertama hanya akan berisi target file BUILD
dalam paket,
dan yang kedua mungkin berisi target tersebut. Di sisi lain, korespondensinya lebih lemah. Output
operator buildfiles
adalah target yang sesuai dengan semua paket danFile bzl
yang dibutuhkan oleh input tertentu. Namun, input operator rbuildfiles
bukan target tersebut, melainkan fragmen jalur yang sesuai dengan target tersebut.
File definisi paket: loadfiles
expr ::= loadfiles(expr)
Operator loadfiles(x)
menampilkan kumpulan file Starlark yang diperlukan untuk memuat paket dari setiap target dalam kumpulan x. Dengan kata lain, untuk setiap paket, metode ini akan menampilkan file .bzl yang direferensikan dari file BUILD
miliknya.
Format output
bazel query
menghasilkan grafik.
Anda menentukan konten, format, dan pengurutan yang digunakan
bazel query
untuk menyajikan grafik ini
menggunakan opsi command line --output
.
Saat menjalankan dengan Sky Query, hanya format output yang kompatibel dengan output yang tidak diurutkan yang diizinkan. Secara khusus, format output graph
, minrank
, dan
maxrank
dilarang.
Beberapa format output menerima opsi tambahan. Nama
setiap opsi output diawali dengan format output yang
berlakunya, sehingga --graph:factored
hanya berlaku
saat --output=graph
sedang digunakan; tidak ada pengaruh jika
format output selain graph
digunakan. Demikian pula,
--xml:line_numbers
hanya berlaku jika --output=xml
digunakan.
Mengurutkan hasil
Meskipun ekspresi kueri selalu mengikuti "hukum
pengamanan urutan grafik", presentasi hasil dapat dilakukan
dengan cara yang sesuai dengan dependensi atau tidak berurutan. Hal ini tidak
memengaruhi target dalam kumpulan hasil atau cara kueri dihitung. Hal ini hanya
memengaruhi cara hasil dicetak ke stdout. Selain itu, node yang setara dalam urutan dependensi mungkin diurutkan berdasarkan abjad, atau mungkin juga tidak.
Flag --order_output
dapat digunakan untuk mengontrol perilaku ini.
(Flag --[no]order_results
memiliki subset fungsi
flag --order_output
dan tidak digunakan lagi.)
Nilai default flag ini adalah auto
, yang mencetak hasil dalam urutan leksikografis. Namun, jika somepath(a,b)
digunakan, hasilnya akan dicetak dalam
urutan deps
.
Jika tanda ini adalah no
dan --output
adalah salah satu dari
build
, label
, label_kind
, location
, package
, proto
, atau
xml
, output akan dicetak dalam urutan arbitrer. Umumnya, ini adalah opsi tercepat. Meskipun jika
--output
adalah salah satu dari graph
, minrank
, atau
maxrank
: dengan format tersebut, Bazel selalu mencetak hasil
yang diurutkan berdasarkan urutan atau peringkat dependensi.
Jika flag ini adalah deps
, Bazel akan mencetak beberapa urutan topologis—yaitu, dependensi terlebih dahulu. Namun, node yang tidak diurutkan berdasarkan urutan dependensi
(karena tidak ada jalur dari salah satunya) dapat dicetak dalam urutan apa pun.
Jika flag ini full
, Bazel akan mencetak node dalam urutan yang sepenuhnya deterministik (total).
Pertama, semua node diurutkan menurut abjad. Kemudian, setiap node dalam daftar digunakan sebagai awal
penelusuran depth-first setelah urutan, dengan tepi keluar ke node yang tidak dikunjungi
sesuai urutan abjad dari node penerus. Akhirnya, {i>node<i} dicetak dengan kebalikan
urutan kunjungannya.
Node pencetakan dalam urutan ini mungkin lebih lambat, sehingga sebaiknya hanya digunakan jika determinisme penting.
Cetak bentuk sumber target seperti yang akan muncul di BUILD
--output build
Dengan opsi ini, representasi setiap target seolah-olah
ditulis dengan tangan dalam bahasa BUILD. Semua variabel dan panggilan fungsi (seperti glob, makro) diperluas, yang berguna untuk melihat efek makro Starlark. Selain itu, setiap aturan yang efektif melaporkan
nilai generator_name
dan/atau generator_function
),
sehingga memberi nama makro yang dievaluasi untuk membuat aturan yang efektif.
Meskipun output menggunakan sintaksis yang sama dengan file BUILD
, tidak ada jaminan untuk menghasilkan file BUILD
yang valid.
Cetak label setiap target
--output label
Dengan opsi ini, kumpulan nama (atau label) dari setiap target
dalam grafik yang dihasilkan akan dicetak, satu label per baris, dalam
urutan topologi (kecuali --noorder_results
ditentukan, lihat
catatan tentang urutan hasil).
(Pengurutan topologi adalah urutan saat node grafik muncul lebih awal dari semua penerusnya.) Tentu saja ada banyak kemungkinan pengurutan topologi grafik (kebalikan urutan hanya satu); yang mana yang dipilih tidak ditentukan.
Saat mencetak output kueri somepath
, urutan
pencetakan node adalah urutan jalur.
Peringatan: dalam beberapa kasus, mungkin ada dua target yang berbeda dengan
label yang sama; misalnya, aturan sh_binary
dan
satu-satunya file srcs
(implisit) dapat disebut
foo.sh
. Jika hasil kueri berisi kedua target ini, output (dalam format label
) akan tampak berisi duplikat. Saat menggunakan format label_kind
(lihat
di bawah), perbedaannya menjadi jelas: dua target memiliki
nama yang sama, tetapi satu target memiliki jenis sh_binary rule
dan
jenis lainnya source file
.
Cetak label dan jenis setiap target
--output label_kind
Seperti label
, format output ini mencetak label
setiap target dalam grafik yang dihasilkan, dalam urutan topologis, tetapi
juga mendahului label dengan jenis target.
Cetak label setiap target, dalam urutan peringkat
--output minrank --output maxrank
Seperti label
, format output minrank
dan maxrank
mencetak label setiap
target dalam grafik yang dihasilkan. Namun, format tersebut muncul dalam urutan peringkat yang diawali dengan
nomor peringkat, bukan muncul dalam
urutan topologi. Hal ini tidak terpengaruh oleh flag --[no]order_results
pengurutan hasil (lihat catatan tentang urutan hasil).
Ada dua varian dari format ini: minrank
memberi peringkat
setiap node berdasarkan panjang jalur terpendek dari node root ke node tersebut.
Node "Root" (yang tidak memiliki tepi yang masuk) berperingkat 0,
penerusnya berada di peringkat 1, dst. (Seperti biasa, tepi menunjuk dari
target ke prasyaratnya: target yang menjadi dependensinya.)
maxrank
memberi peringkat setiap node berdasarkan panjang jalur terpanjang
dari node root ke node tersebut. Sekali lagi, "root" memiliki peringkat 0, semua node lain memiliki peringkat yang satu lebih besar dari peringkat maksimum semua pendahulunya.
Semua {i>node<i} dalam siklus dianggap memiliki peringkat yang sama. (Sebagian besar grafik
bersifat asiklik, tetapi siklus terjadi
hanya karena file BUILD
berisi siklus yang salah.)
Format output ini berguna untuk mengetahui seberapa dalam grafik.
Jika digunakan untuk hasil kueri deps(x)
, rdeps(x)
,
atau allpaths
, nomor peringkat sama dengan
panjang jalur terpendek (dengan minrank
) atau terpanjang
(dengan maxrank
) dari x
ke node dalam
peringkat tersebut. maxrank
dapat digunakan untuk menentukan
urutan langkah build terpanjang yang diperlukan untuk membuat target.
Misalnya, grafik di sebelah kiri menghasilkan output di sebelah kanan
jika --output minrank
dan --output maxrank
ditentukan.
minrank 0 //c:c 1 //b:b 1 //a:a 2 //b:b.cc 2 //a:a.cc |
maxrank 0 //c:c 1 //b:b 2 //a:a 2 //b:b.cc 3 //a:a.cc |
Mencetak lokasi setiap target
--output location
Seperti label_kind
, opsi ini akan mencetak, untuk setiap
target dalam hasil, jenis dan label target, tetapi diawali dengan string yang menjelaskan lokasi target tersebut, sebagai
nama file dan nomor baris. Format ini menyerupai output
grep
. Dengan demikian, alat yang dapat mengurai yang kedua (seperti Emacs
atau vi) juga dapat menggunakan output kueri untuk menelusuri serangkaian
kecocokan, sehingga alat kueri Bazel dapat digunakan sebagai "grep for BUILD files" yang peka terhadap grafik dependensi.
Informasi lokasi bervariasi menurut jenis target (lihat operator jenis). Untuk aturan, lokasi deklarasi aturan dalam file BUILD
akan dicetak.
Untuk file sumber, lokasi baris 1 file sebenarnya
akan dicetak. Untuk file yang dihasilkan, lokasi aturan yang menghasilkannya akan dicetak. (Alat kueri tidak memiliki informasi yang memadai untuk menemukan lokasi sebenarnya dari file yang dihasilkan, dan dalam kasus apa pun, alat ini mungkin tidak ada jika build belum dijalankan.)
Mencetak kumpulan paket
--output package
Opsi ini mencetak nama semua paket yang memiliki beberapa target dalam kumpulan hasil. Nama dicetak dalam urutan leksikografis; duplikat dikecualikan. Secara formal, ini adalah proyeksi dari kumpulan label (paket, target) ke paket.
Paket di repositori eksternal diformat sebagai
@repo//foo/bar
sedangkan paket di repositori utama
diformat sebagai foo/bar
.
Bersama dengan kueri deps(...)
, opsi output ini dapat digunakan untuk menemukan kumpulan paket yang harus diperiksa untuk membangun serangkaian target tertentu.
Menampilkan grafik hasil
--output graph
Opsi ini menyebabkan hasil kueri dicetak sebagai grafik terarah dalam format AT&T GraphViz yang populer. Biasanya,
hasilnya disimpan ke file, seperti .png
atau .svg
.
(Jika program dot
tidak terinstal di workstation, Anda dapat menginstalnya menggunakan perintah sudo apt-get install graphviz
.) Lihat contoh bagian di bawah untuk mengetahui contoh pemanggilan.
Format output ini sangat berguna untuk kueri allpaths
,
deps
, atau rdeps
, ketika hasilnya
menyertakan kumpulan jalur yang tidak dapat divisualisasikan dengan mudah saat
dirender dalam bentuk linear, seperti dengan --output label
.
Secara default, grafik dirender dalam bentuk difaktorkan. Artinya,
node yang setara secara topologis digabungkan menjadi satu
node dengan beberapa label. Hal ini membuat grafik lebih ringkas
dan mudah dibaca, karena grafik hasil standar berisi pola yang
sangat berulang. Misalnya, aturan java_library
mungkin bergantung pada ratusan file sumber Java, semuanya dihasilkan oleh genrule
yang sama; dalam grafik faktor, semua file ini diwakili oleh satu node. Perilaku ini dapat dinonaktifkan
dengan opsi --nograph:factored
.
--graph:node_limit n
Opsi ini menentukan panjang maksimum string label untuk node grafik dalam output. Label yang lebih panjang akan terpotong; -1
menonaktifkan pemotongan. Karena bentuk faktor yang biasanya digunakan untuk mencetak grafik, label node mungkin sangat panjang. GraphViz tidak dapat menangani label yang melebihi 1.024 karakter, yang merupakan nilai default dari opsi ini. Opsi ini tidak berpengaruh kecuali jika
--output=graph
sedang digunakan.
--[no]graph:factored
Secara default, grafik ditampilkan dalam bentuk faktor, seperti yang dijelaskan
di atas.
Saat --nograph:factored
ditentukan, grafik akan
dicetak tanpa pemfaktoran. Hal ini menjadikan visualisasi menggunakan GraphViz tidak praktis, tetapi format yang lebih sederhana dapat memudahkan pemrosesan oleh alat lain (seperti grep). Opsi ini tidak berpengaruh
kecuali jika --output=graph
digunakan.
XML
--output xml
Opsi ini menyebabkan target yang dihasilkan dicetak dalam bentuk XML. Output dimulai dengan header XML seperti ini
<?xml version="1.0" encoding="UTF-8"?>
<query version="2">
kemudian melanjutkan dengan elemen XML untuk setiap target dalam grafik hasil, dalam urutan topologi (kecuali hasil yang tidak berurutan diminta), lalu diakhiri dengan tanda
</query>
Entri sederhana akan dimunculkan untuk target jenis file
:
<source-file name='//foo:foo_main.cc' .../>
<generated-file name='//foo:libfoo.so' .../>
Namun, untuk aturan, XML terstruktur dan berisi definisi semua
atribut aturan, termasuk atribut yang nilainya tidak
ditentukan secara eksplisit dalam file BUILD
aturan.
Selain itu, hasilnya menyertakan elemen rule-input
dan
rule-output
sehingga topologi
grafik dependensi dapat direkonstruksi tanpa harus mengetahui bahwa,
misalnya, elemen atribut srcs
adalah
dependensi maju (prasyarat) dan konten atribut
outs
adalah dependensi mundur (konsumen).
Elemen rule-input
untuk dependensi implisit akan disembunyikan jika
--noimplicit_deps
ditentukan.
<rule class='cc_binary rule' name='//foo:foo' ...>
<list name='srcs'>
<label value='//foo:foo_main.cc'/>
<label value='//foo:bar.cc'/>
...
</list>
<list name='deps'>
<label value='//common:common'/>
<label value='//collections:collections'/>
...
</list>
<list name='data'>
...
</list>
<int name='linkstatic' value='0'/>
<int name='linkshared' value='0'/>
<list name='licenses'/>
<list name='distribs'>
<distribution value="INTERNAL" />
</list>
<rule-input name="//common:common" />
<rule-input name="//collections:collections" />
<rule-input name="//foo:foo_main.cc" />
<rule-input name="//foo:bar.cc" />
...
</rule>
Setiap elemen XML untuk target berisi atribut name
, yang nilainya adalah label target, dan
atribut location
, yang nilainya adalah lokasi target
seperti yang dicetak oleh --output location
.
--[no]xml:line_numbers
Secara default, lokasi yang ditampilkan dalam output XML berisi nomor baris.
Jika --noxml:line_numbers
ditentukan, nomor baris tidak akan dicetak.
--[no]xml:default_values
Secara default, output XML tidak menyertakan atribut aturan yang nilainya
adalah nilai default untuk jenis atribut tersebut (misalnya, jika
tidak ditentukan dalam file BUILD
, atau nilai default
diberikan secara eksplisit). Opsi ini menyebabkan nilai atribut tersebut
disertakan dalam output XML.
Ekspresi reguler
Ekspresi reguler dalam bahasa kueri menggunakan library ekspresi reguler Java, sehingga Anda dapat menggunakan sintaksis lengkap untuk java.util.regex.Pattern
.
Membuat kueri dengan repositori eksternal
Jika build bergantung pada aturan dari repositori eksternal (ditentukan dalam file WORKSPACE), hasil kueri akan menyertakan dependensi ini. Misalnya, jika //foo:bar
bergantung pada //external:some-lib
dan //external:some-lib
terikat ke @other-repo//baz:lib
, bazel query 'deps(//foo:bar)'
akan mencantumkan @other-repo//baz:lib
dan
//external:some-lib
sebagai dependensi.
Repositori eksternal sendiri bukanlah dependensi build. Artinya, dalam
contoh di atas, //external:other-repo
bukan dependensi. Objek ini
dapat dikueri sebagai anggota paket //external
,
misalnya:
# Querying over all members of //external returns the repository.
bazel query 'kind(http_archive, //external:*)'
//external:other-repo
# ...but the repository is not a dependency.
bazel query 'kind(http_archive, deps(//foo:bar))'
INFO: Empty results