Halaman ini adalah panduan referensi untuk Bahasa Kueri Bazel yang digunakan
saat Anda menggunakan bazel query
untuk menganalisis dependensi build. Kode ini juga
menjelaskan format output yang didukung bazel query
.
Untuk kasus penggunaan praktis, lihat Cara Kerja Kueri Bazel.
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 pada Grafik Target Konfigurasi
pasca-analisis dan mengekspos informasi tentang Tindakan, Artefak, dan
hubungannya. aquery
berguna saat Anda tertarik dengan
properti Tindakan/Artifacts yang dihasilkan dari Grafik Target yang Dikonfigurasi.
Misalnya, perintah aktual dijalankan dan input, output, serta mnemoniknya.
Untuk mengetahui 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,
metode ini tidak me-resolve pernyataan select
dengan benar, tetapi menampilkan semua kemungkinan resolusi select. Namun, lingkungan kueri yang dapat dikonfigurasi, cquery
, menangani konfigurasi dengan benar tetapi
tidak menyediakan semua fungsi kueri asli ini.
Untuk mengetahui detail selengkapnya, lihat referensi kueri.
Contoh
Bagaimana cara orang menggunakan bazel query
? Berikut adalah contoh umumnya:
Mengapa hierarki //foo
bergantung pada //bar/baz
?
Tampilkan jalur:
somepath(foo/..., //bar/baz:all)
Library C++ apa yang menjadi dependensi semua pengujian foo
, sedangkan
target foo_bin
tidak?
kind("cc_library", deps(kind(".*test rule", foo/...)) except deps(//foo:foo_bin))
Token: Sintaks leksikal
Ekspresi dalam bahasa kueri terdiri dari token berikut:
Kata kunci, seperti
let
. Kata kunci adalah kata yang dicadangkan dalam bahasa bahasa tersebut, dan setiap katanya dijelaskan di bawah. Kumpulan lengkap kata kunci adalah:Kata, seperti "
foo/...
" atau ".*test rule
" atau "//bar/baz:all
". Jika urutan karakter "dikutip" (dimulai dan diakhiri dengan tanda kutip tunggal ' atau dimulai dan diakhiri dengan tanda kutip ganda "), itu adalah kata. Jika urutan karakter tidak diapit tanda kutip, urutan tersebut mungkin masih diuraikan sebagai kata. Kata yang tidak dikutip adalah urutan karakter yang digambar dari karakter alfabet A-Za-z, angka 0-9, dan karakter khusus*/@.-_:$~[]
(tanda bintang, garis miring, at, titik, tanda hubung, garis bawah, titik dua, tanda dolar, tanda gelombang, tanda kurung siku kiri, kurung siku kanan). Namun, kata tanpa tanda kutip tidak boleh diawali dengan tanda hubung-
atau tanda bintang*
meskipun nama target relatif dapat diawali dengan karakter tersebut. Sebagai aturan khusus yang dimaksudkan untuk menyederhanakan penanganan label yang merujuk ke repositori eksternal, kata tanpa tanda kutip yang diawali dengan@@
dapat berisi+
karakter.Kata yang tidak dikutip juga tidak boleh menyertakan karakter tanda plus
+
atau sama dengan tanda=
, meskipun karakter tersebut diizinkan dalam nama target. Saat menulis kode yang menghasilkan ekspresi kueri, nama target harus diberi tanda kutip.Pengutipan 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 kutipan ini merupakan tambahan untuk pemberian tanda kutip yang mungkin diperlukan oleh shell Anda, seperti:
bazel query ' "//foo:bar=wiz" ' # single-quotes for shell, double-quotes for Bazel.
Kata kunci dan operator, jika dikutip, diperlakukan sebagai kata biasa. Misalnya,
some
adalah kata kunci, tetapi "some" adalah kata.foo
dan "foo" adalah kata.Namun, berhati-hatilah saat menggunakan tanda kutip tunggal atau ganda dalam nama target. Saat mengutip satu atau beberapa nama target, hanya gunakan satu jenis tanda kutip (baik tanda kutip tunggal maupun tanda kutip ganda).
Berikut adalah contoh dari string kueri Java yang akan menjadi:
'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 {i>syntax<i} ini sehingga tanda kutip tidak diperlukan dalam kebanyakan kasus. Contoh
".*test rule"
(yang tidak biasa) memerlukan tanda kutip: contoh ini diawali dengan titik dan berisi spasi. Mengutip"cc_library"
tidak diperlukan, tetapi tidak berbahaya.Tanda baca, seperti tanda kurung
()
, titik.
, dan koma,
. Kata-kata yang berisi tanda baca (selain pengecualian yang tercantum di atas) harus diapit tanda petik.
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 setara dengan, grafik (DAG) target. Ini adalah satu-satunya jenis data.
Kumpulan dan grafik merujuk pada tipe data yang sama, tetapi menekankan aspek yang berbeda, misalnya:
- Tetapkan: Urutan sebagian target tidak menarik.
- Grafik: Urutan sebagian target bersifat signifikan.
Siklus dalam grafik dependensi
Grafik dependensi build harus asiklik.
Algoritma yang digunakan oleh bahasa kueri dimaksudkan untuk digunakan dalam grafik acyclic, tetapi tahan terhadap siklus. Detail tentang cara perlakuan siklus tidak ditentukan dan tidak boleh diandalkan.
Dependensi implisit
Selain dependensi build yang ditentukan secara eksplisit dalam file BUILD
,
Bazel juga 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
.
Secara default, bazel query
memperhitungkan dependensi implisit
saat menghitung hasil kueri. Perilaku ini dapat diubah dengan
opsi --[no]implicit_deps
. Perhatikan bahwa, karena kueri tidak mempertimbangkan
konfigurasi, toolchain potensial tidak pernah dipertimbangkan.
Tingkat kesehatan
Ekspresi bahasa kueri Bazel beroperasi pada grafik
dependensi build, yang merupakan grafik yang ditentukan secara implisit oleh semua
deklarasi aturan di semua file BUILD
. Penting untuk dipahami bahwa grafik ini agak abstrak, dan bukan merupakan deskripsi lengkap tentang cara menjalankan semua langkah build. Agar dapat menjalankan build, konfigurasi juga diperlukan; lihat bagian configurations dalam Panduan Pengguna untuk mengetahui detail selengkapnya.
Hasil evaluasi ekspresi dalam bahasa kueri Bazel adalah benar untuk semua konfigurasi, yang berarti bahwa hal ini mungkin merupakan perkiraan berlebihan yang konservatif, dan tidak terlalu akurat. Jika Anda menggunakan alat kueri untuk menghitung kumpulan semua file sumber yang diperlukan selama build, alat tersebut dapat melaporkan lebih dari yang sebenarnya diperlukan karena, misalnya, alat kueri akan menyertakan semua file yang diperlukan untuk mendukung terjemahan pesan, meskipun Anda tidak ingin menggunakan fitur tersebut dalam build.
Tentang pelestarian urutan grafik
Operasi mempertahankan batasan
urutan yang diwarisi dari subekspresinya. Anda dapat menganggapnya sebagai "hukum kekekalan urutan parsial". Pertimbangkan sebuah contoh: 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 agar
hanya menyertakan target dari jenis file
, hubungan pengurutan parsial
transitif yang sama akan berlaku di antara setiap
pasangan target dalam subset yang dihasilkan, meskipun tidak ada
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 yang ditetapkan tidak memperkenalkan batasan pengurutannya sendiri. Pertimbangkan ekspresi ini:
deps(x) union y
Urutan kumpulan hasil akhir dijamin untuk mempertahankan semua
batasan pengurutan subekspresinya, yaitu, bahwa semua
dependensi transitif x
diurutkan dengan benar
secara relatif satu sama lain. Namun, kueri tidak menjamin apa pun tentang
urutan target di y
, atau tentang
urutan target di deps(x)
relatif terhadap target di
y
(kecuali untuk target tersebut di
y
yang juga kebetulan ada di deps(x)
).
Operator yang menerapkan batasan pengurutan mencakup:
allpaths
, deps
, rdeps
, somepath
, dan karakter pengganti pola target
package:*
, dir/...
, dll.
Kueri langit
Sky Query adalah mode kueri yang beroperasi di seluruh cakupan alam semesta yang ditentukan.
Fungsi khusus hanya tersedia di SkyQuery
Mode Sky Query memiliki fungsi kueri tambahan allrdeps
dan
rbuildfiles
. Fungsi ini beroperasi di seluruh cakupan semesta (itulah mengapa fungsi ini tidak masuk akal untuk Kueri normal).
Menentukan cakupan semesta
Mode Sky Query 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
menjadi aditif 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 ini 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 memperlakukannya sama seperti pemanggilan:
bazel query --universe_scope=//my:target --order_output=no "allrdeps(//my:target)"
Namun, hasil kueri dengan --universe_scope
tersebut hanyalah //my:target
;
tidak satu pun dari dependensi terbalik //my:target
yang ada di alam semesta, berdasarkan
konstruksi. 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
ekspansi tests
target di beberapa direktori yang
bergantung secara transitif pada target yang definisinya menggunakan file .bzl
tertentu. Di sini,
--infer_universe_scope
adalah kenyamanan, terutama jika pilihan
--universe_scope
mengharuskan Anda untuk mengurai ekspresi kueri sendiri.
Jadi, untuk ekspresi kueri yang menggunakan operator cakupan alam semesta seperti
allrdeps
dan
rbuildfiles
, pastikan Anda menggunakan
--infer_universe_scope
hanya jika perilakunya sesuai dengan yang Anda inginkan.
Sky Query memiliki beberapa kelebihan dan kekurangan dibandingkan dengan kueri default. Kekurangan
utama adalah tidak dapat mengurutkan outputnya sesuai dengan urutan grafik, sehingga
format output tertentu dilarang. Keunggulannya adalah menyediakan
dua operator (allrdeps
dan
rbuildfiles
) yang tidak tersedia dalam kueri default.
Selain itu, Sky Query melakukan tugasnya dengan menginspeksi
grafik Skyframe, bukan membuat grafik
baru, yang merupakan hal yang dilakukan implementasi default. Dengan demikian, ada beberapa situasi saat
proses ini lebih cepat dan menggunakan lebih sedikit memori.
Ekspresi: Sintaksis dan semantik tata bahasa
Ini adalah tata bahasa dari 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 menjelaskan setiap produksi tata bahasa ini secara berurutan.
Pola target
expr ::= word
Secara sintaksis, pola target hanyalah sebuah kata. Ini ditafsirkan sebagai
kumpulan target (tidak diurutkan). Pola target yang paling sederhana adalah label, yang
mengidentifikasi satu target (file atau aturan). Misalnya, pola target
//foo:bar
mengevaluasi ke set yang berisi satu elemen, yaitu target, aturan
bar
.
Pola target menggeneralisasi label untuk menyertakan karakter pengganti di atas paket dan target. Misalnya, foo/...:all
(atau hanya foo/...
) adalah pola target
yang dievaluasi ke kumpulan yang berisi semua aturan di setiap paket secara rekursif
di bawah direktori foo
; bar/baz:all
adalah pola target yang dievaluasi
ke kumpulan yang berisi semua aturan dalam paket bar/baz
, tetapi bukan
subpaketnya.
Demikian pula, foo/...:*
adalah pola target yang dievaluasi menjadi kumpulan yang berisi
semua target (file dan aturan) di setiap paket secara rekursif di bawah
direktori foo
; bar/baz:*
dievaluasi menjadi kumpulan yang berisi semua target dalam
paket bar/baz
, tetapi bukan subpaketnya.
Karena karakter pengganti :*
cocok dengan file dan aturan, karakter pengganti 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 mengevaluasi ke kumpulan singleton (dalam kasus label), ke kumpulan yang berisi banyak elemen (seperti dalam kasus foo/...
, yang memiliki ribuan elemen), atau ke kumpulan kosong, jika pola target tidak cocok dengan target apa pun.
Semua node dalam hasil ekspresi pola target diurutkan dengan benar
secara relatif satu sama lain sesuai dengan hubungan dependensi. Jadi, hasil
foo:*
bukan hanya kumpulan target dalam paket foo
, tetapi juga
grafik atas target tersebut. (Tidak ada jaminan yang diberikan tentang 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/...
.
Kejadian referensi variabel name
selain dalam
ekspresi let name = ...
yang melingkupi adalah
error. Dengan kata lain, ekspresi kueri tingkat teratas tidak boleh memiliki variabel
bebas.
Dalam produksi tata bahasa di atas, name
mirip dengan word, tetapi dengan
batasan tambahan bahwa name
adalah ID yang valid dalam bahasa
pemrograman C. Referensi ke variabel harus diawali dengan karakter "$".
Setiap ekspresi let
hanya menentukan satu variabel, tetapi Anda dapat menyusunnya secara bertingkat.
pola target dan referensi variabel hanya terdiri dari satu token, sebuah kata, sehingga menciptakan ambiguitas sintaksis. Namun, tidak ada ambiguitas semantik karena subset kata yang merupakan nama variabel hukum terpisah dari subset kata yang merupakan pola target hukum.
Secara teknis, ekspresi let
tidak meningkatkan
ekspresi bahasa kueri: kueri apa pun yang dapat dinyatakan dalam
bahasa juga dapat dinyatakan tanpanya. Namun, cara ini
akan meningkatkan keringkasan banyak kueri, dan juga dapat menghasilkan
evaluasi kueri yang lebih efisien.
Ekspresi dalam tanda kurung
expr ::= (expr)
Tanda kurung mengaitkan subekspresi untuk memaksa urutan evaluasi. Ekspresi dalam tanda kurung dievaluasi menjadi nilai argumennya.
Operasi himpunan aljabar: irisan, gabungan, perbedaan himpunan
expr ::= expr intersect expr
| expr ^ expr
| expr union expr
| expr + expr
| expr except expr
| expr - expr
Ketiga operator ini menghitung operasi set biasa pada argumennya.
Setiap operator memiliki dua bentuk, bentuk nominal, seperti intersect
, dan
bentuk simbolis, seperti ^
. Kedua bentuk tersebut setara; bentuk simbolis lebih cepat diketik. (Agar lebih jelas, bagian lain dari 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 sebagai:
foo/... - foo/bar/...
Operasi intersect
(^
) dan union
(+
) bersifat komutatif (simetris);
except
(-
) bersifat asimetris. Parser memperlakukan ketiga operator tersebut sebagai
asosiatif kiri dan memiliki prioritas sama, sehingga Anda perlu menggunakan tanda kurung. Misalnya, dua ekspresi pertama adalah setara, tetapi yang ketiga tidak:
x intersect y union z
(x intersect y) union z
x intersect (y union z)
Membaca target dari sumber eksternal: ditetapkan
expr ::= set(word *)
Operator set(a b c ...)
menghitung gabungan kumpulan nol atau beberapa pola target, yang dipisahkan oleh spasi kosong (tanpa koma).
Bersama dengan fitur $(...)
shell Bourne, set()
menyediakan
cara menyimpan hasil 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
selanjutnya. 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 dari $(cat foo)
, tetapi perintah
shell selain cat
juga dapat digunakan—seperti perintah awk
sebelumnya.
Fungsi
expr ::= word '(' int | word | expr ... ')'
Bahasa kueri menentukan 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: deps
expr ::= deps(expr)
| deps(expr, depth)
Operator deps(x)
dievaluasi menjadi grafik yang dibentuk
oleh penutupan transitif dependensi dari kumpulan argumennya
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 di 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 mengetahui detail selengkapnya, lihat bagian urutan grafik.
Operator deps
menerima argumen kedua opsional, yang merupakan literal bilangan bulat
yang menentukan batas atas kedalaman penelusuran. Jadi,
deps(foo:*, 0)
menampilkan semua target dalam paket foo
, sedangkan
deps(foo:*, 1)
lebih lanjut menyertakan prasyarat langsung dari target apa pun dalam
paket foo
, dan deps(foo:*, 2)
lebih lanjut menyertakan 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 memiliki batas: penelusuran akan menghitung penutupan transitif refleksif prasyarat.
Penutupan transitif dependensi terbalik: rdeps
expr ::= rdeps(expr, expr)
| rdeps(expr, expr, depth)
Operator rdeps(u, x)
mengevaluasi ke dependensi terbalik dari kumpulan argumen
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
bilangan bulat yang menentukan batas atas pada kedalaman penelusuran. Grafik yang dihasilkan
hanya menyertakan node dalam jarak kedalaman yang ditentukan dari node
apa pun dalam kumpulan argumen. Jadi, rdeps(//foo, //common, 1)
dievaluasi 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 dibatasi.
Penutupan transitif semua dependensi terbalik: allrdeps
expr ::= allrdeps(expr)
| allrdeps(expr, depth)
Operator allrdeps
berperilaku sama seperti operator rdeps
, kecuali bahwa "set semesta" adalah apa pun yang dievaluasi oleh tanda --universe_scope
, bukan ditentukan secara terpisah. Jadi, jika
--universe_scope=//foo/...
diteruskan, allrdeps(//bar)
setara dengan rdeps(//foo/..., //bar)
.
Dependensi balik 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 ada dalam paket yang sama dengan target dalam kumpulan argumen, dan yang bergantung langsung padanya.
Menangani paket target: saudara
expr ::= siblings(expr)
Operator siblings(x)
mengevaluasi ke kumpulan target lengkap yang ada dalam
paket yang sama sebagai target dalam kumpulan argumen.
Pilihan arbitrer: beberapa
expr ::= some(expr)
| some(expr, count )
Operator some(x, k)
memilih maksimum k target secara arbitrer dari kumpulan argumen x, dan mengevaluasi ke set yang hanya berisi target tersebut. Parameter k bersifat opsional; jika
tidak ada, hasilnya akan berupa 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 menjadi
set singleton yang berisi //foo:main
atau //bar:baz
—meskipun
mana 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
.
Error akan terjadi 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
di antara dua kumpulan target. Kedua kueri menerima dua
argumen, satu S titik awal dan satu kumpulan
E titik akhir. somepath
menampilkan
grafik node pada beberapa jalur arbitrer dari target di
S ke target di E; allpaths
menampilkan grafik node pada semua jalur dari target mana pun di
S ke target mana pun di E.
Grafik yang dihasilkan diurutkan sesuai dengan relasi 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 bukan jenis yang diharapkan. 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 diilustrasikan dalam tabel:
Kode | 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/...)
dievaluasi menjadi kumpulan
semua target aturan cc_library
, cc_binary
, dsb.,
di bawah foo
, dan kind("source file", deps(//foo))
dievaluasi menjadi kumpulan semua file sumber dalam penutupan transitif
dependensi target //foo
.
Tanda kutip argumen pattern sering kali diperlukan
karena tanpanya, banyak ekspresi reguler, seperti source
file
dan .*_test
, tidak dianggap sebagai kata oleh parser.
Saat mencocokkan package group
, target yang diakhiri dengan
:all
mungkin tidak menghasilkan 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 ini
dievaluasi ke subkumpulan inputnya.
Argumen pertama, pattern adalah kata yang berisi
ekspresi reguler di atas nama target. Ekspresi filter
dievaluasi ke set yang berisi semua target x sehingga
x adalah anggota set input dan
label (dalam bentuk absolut, seperti //foo:bar
)
dari 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 daripada 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-tama akan menghitung kumpulan dependensi //foo
, lalu
hanya akan memfilter target yang cocok dengan pola yang diberikan—dengan kata lain,
target dengan nama yang berisi //bar
sebagai substring.
Penggunaan umum lainnya dari operator filter(pattern,
expr)
adalah untuk memfilter file tertentu berdasarkan namanya atau ekstensi. Misalnya,
filter("\.cc$", deps(//foo))
akan memberikan daftar semua file .cc
yang digunakan untuk membangun //foo
.
Pemfilteran atribut aturan: attr
expr ::= attr(word, word, expr)
Operator
attr(name, pattern, input)
menerapkan filter ke kumpulan target, dan menghapus target yang bukan
aturan, target aturan yang tidak memiliki atribut name
yang ditentukan, atau target aturan dengan nilai atribut yang tidak cocok dengan
ekspresi reguler pattern yang diberikan; operator ini dievaluasi
ke subkumpulan inputnya.
Argumen pertama, name adalah nama atribut aturan
yang harus dicocokkan dengan pola
ekspresi reguler yang disediakan. Argumen kedua,
pattern adalah ekspresi reguler atas nilai
atribut. Ekspresi attr
dievaluasi ke kumpulan yang berisi semua target
x sehingga x adalah
anggota kumpulan input, merupakan aturan dengan atribut
name yang ditentukan, dan nilai atribut berisi
kecocokan (tanpa penempatan) 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 untuk memiliki
atribut linkshared (seperti, aturan cc_binary
) dan menetapkannya
secara eksplisit ke 0 atau tidak menetapkannya sama sekali, tetapi nilai defaultnya adalah 0 (seperti 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 absolut label. Misalnya, atribut deps=[":foo",
"//otherpkg:bar", "wiz"]
akan dikonversi menjadi
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, sedangkan
attr("data", ".{3,}", deps(//foo))
akan memilih semua aturan di antara dependensi //foo
yang menentukan setidaknya satu nilai dalam atribut data
(setiap label minimal memiliki 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))
Ini berfungsi karena karakter sebelum value
akan berupa [
atau spasi dan
karakter setelah value
akan berupa koma atau ]
.
Pemfilteran visibilitas aturan: terlihat
expr ::= visible(expr, expr)
Operator visible(predicate, input)
menerapkan filter ke kumpulan target, dan menghapus target tanpa visibilitas
yang diperlukan.
Argumen pertama, predicate, adalah kumpulan target yang harus terlihat oleh semua target dalam output. Ekspresi visible dievaluasi ke kumpulan yang berisi semua target x sehingga x adalah anggota dari input yang ditetapkan, dan untuk semua target y di predicate x dapat dilihat oleh y. Contoh:
visible(//foo, //bar:*)
akan memilih semua target dalam paket //bar
yang dapat
diandalkan oleh //foo
tanpa melanggar batasan visibilitas.
Evaluasi atribut aturan 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 di kumpulan inputs.
Misalnya, labels(srcs, //foo)
menampilkan kumpulan target yang muncul dalam atribut srcs
aturan //foo
. Jika ada beberapa aturan dengan atribut srcs
dalam kumpulan inputs, gabungan dari srcs
-nya akan ditampilkan.
Meluaskan dan memfilter test_suites: pengujian
expr ::= tests(expr)
Operator tests(x)
menampilkan kumpulan semua aturan pengujian dalam kumpulan x, yang memperluas aturan test_suite
ke dalam 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
. Error 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 adalah (menurut
definisi) 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 dirujuk melalui load
. Perhatikan bahwa tindakan ini
juga akan menampilkan file BUILD
dari paket yang berisi
file load
ini.
Operator ini biasanya digunakan saat menentukan file atau
paket yang diperlukan untuk mem-build 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 menjadi dependensi //foo
secara transitif.
File definisi paket: rbuildfiles
expr ::= rbuildfiles(word, ...)
Operator rbuildfiles
mengambil daftar fragmen jalur yang dipisahkan koma dan menampilkan
kumpulan file BUILD
yang bergantung secara transitif pada fragmen jalur ini. Misalnya, jika
//foo
adalah sebuah 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 file BUILD
lainnya yang
memuat //bar:file.bzl
Cakupan operator --universe_scope
. File yang tidak berkaitan langsung dengan file BUILD
dan file .bzl
tidak akan memengaruhi hasilnya. Misalnya, file sumber (seperti foo.cc
) diabaikan,
meskipun disebutkan secara eksplisit dalam file BUILD
. Namun, Symlink dipatuhi 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
bertahan lebih kuat dalam satu arah: output rbuildfiles
sama seperti
input buildfiles
; yang pertama hanya akan berisi target file BUILD
dalam paket,
dan yang kedua dapat berisi target tersebut. Di arah lain, korelasi ini lebih lemah. Output
operator buildfiles
adalah target yang sesuai dengan semua paket dan .File bzl
yang diperlukan oleh input tertentu. Namun, input operator rbuildfiles
bukanlah target tersebut, melainkan fragmen jalur yang sesuai dengan target tersebut.
File definisi paket: loadfile
expr ::= loadfiles(expr)
Operator loadfiles(x)
menampilkan kumpulan
file Starlark yang diperlukan untuk memuat paket setiap target dalam
set x. Dengan kata lain, untuk setiap paket, sistem akan menampilkan file .bzl yang direferensikan dari file BUILD
-nya.
Format keluaran
bazel query
menghasilkan grafik.
Anda menentukan konten, format, dan pengurutan yang digunakan
bazel query
menyajikan grafik ini
melalui opsi command line --output
.
Saat berjalan 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
berlaku, sehingga --graph:factored
hanya berlaku
jika --output=graph
sedang digunakan; dan tidak berpengaruh jika
format output selain graph
digunakan. Demikian pula,
--xml:line_numbers
hanya berlaku saat --output=xml
digunakan.
Tentang pengurutan hasil
Meskipun ekspresi kueri selalu mengikuti "hukum
kekekalan urutan grafik", presentasi hasilnya dapat dilakukan
dengan cara yang berurutan atau tidak berurutan. Hal ini tidak memengaruhi target dalam set hasil atau cara kueri dihitung. Hal ini hanya
memengaruhi cara hasil dicetak ke stdout. Selain itu, node yang
setara dalam urutan dependensi mungkin atau mungkin tidak diurutkan menurut abjad.
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, saat somepath(a,b)
digunakan, hasilnya akan dicetak dalam
urutan deps
.
Jika flag 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. Namun, hal ini tidak didukung jika
--output
adalah salah satu dari graph
, minrank
, atau
maxrank
: dengan format ini, Bazel selalu mencetak hasil
yang diurutkan berdasarkan urutan atau peringkat dependensi.
Jika tanda ini adalah deps
, Bazel akan mencetak hasil dalam beberapa urutan topologi—yaitu,
dependensi terlebih dahulu. Namun, node yang tidak diurutkan menurut urutan dependensi
(karena tidak ada jalur dari satu node ke node lainnya) dapat dicetak dalam urutan apa pun.
Jika flag ini adalah full
, Bazel akan mencetak node dengan urutan (total) yang sepenuhnya deterministik.
Pertama, semua node diurutkan menurut abjad. Kemudian, setiap node dalam daftar akan digunakan sebagai awal
penelusuran depth-first pasca-urutan, dengan tepi keluar ke node yang tidak dikunjungi akan dilintasi dalam
urutan abjad dari node pengganti. Terakhir, node dicetak dalam urutan
berbalik dari urutan kunjungannya.
Mencetak node dalam urutan ini mungkin lebih lambat, sehingga hanya boleh digunakan jika determinisme bersifat penting.
Cetak bentuk sumber target seperti yang akan terlihat 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 efektif melaporkan
nilai generator_name
dan/atau generator_function
,
sehingga memberikan nama makro yang dievaluasi untuk menghasilkan aturan yang efektif.
Meskipun output menggunakan sintaksis yang sama dengan file BUILD
, output tersebut tidak
dijamin akan menghasilkan file BUILD
yang valid.
Mencetak label setiap target
--output label
Dengan opsi ini, kumpulan nama (atau label) setiap target
dalam grafik yang dihasilkan akan dicetak, satu label per baris, dalam
urutan topologis (kecuali jika --noorder_results
ditentukan, lihat
catatan tentang urutan hasil).
(Pengurutan topologi adalah pengurutan yang node
grafiknya muncul lebih awal daripada semua penerusnya.) Tentu saja ada
banyak kemungkinan pengurutan topologi grafik (postorder
terbalik hanyalah salah satunya); mana yang dipilih tidak ditentukan.
Saat mencetak output kueri somepath
, urutan
pencetakan node adalah urutan jalur.
Catatan: dalam beberapa kasus ekstrem, mungkin ada dua target berbeda dengan
label yang sama; misalnya, aturan sh_binary
dan
file srcs
satu-satunya (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: kedua target memiliki
nama yang sama, tetapi salah satunya memiliki jenis sh_binary rule
dan
jenis lainnya source file
.
Mencetak 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.
Mencetak target dalam format buffering protokol
--output proto
Mencetak output kueri sebagai
buffering protokol QueryResult
.
Mencetak target dalam format buffering protokol yang dibatasi panjang
--output streamed_proto
Mencetak
stream
yang dibatasi panjang
dari buffer protokol
Target
. Hal ini berguna untuk (i) mengatasi
batasan ukuran
buffering protokol jika ada terlalu banyak target untuk dimuat dalam satu
QueryResult
atau (ii) untuk memulai pemrosesan saat Bazel masih dalam proses output.
Cetak target dalam format proto teks
--output textproto
Serupa dengan --output proto
, mencetak buffering protokol
QueryResult
tetapi dalam
format teks.
Cetak target dalam format ndjson
--output streamed_jsonproto
Serupa dengan --output streamed_proto
, mencetak aliran data buffering protokol
Target
tetapi dalam format ndjson.
Mencetak 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, tetapi bukan muncul dalam
urutan topologi, label tersebut muncul dalam urutan peringkat, didahului oleh
nomor peringkatnya. Hal ini tidak terpengaruh oleh flag --[no]order_results
pengurutan hasil (lihat catatan tentang
pengurutan hasil).
Ada dua varian format ini: minrank
mengurutkan
setiap node berdasarkan panjang jalur terpendek dari node root ke node root.
Node "Root" (yang tidak memiliki tepi masuk) memiliki peringkat 0,
penggantinya memiliki peringkat 1, dll. (Seperti biasa, tepi mengarah 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 lainnya memiliki peringkat yang satu lebih besar dari peringkat maksimum semua
pendahulunya.
Semua node dalam siklus dianggap memiliki peringkat yang sama. (Sebagian besar grafik bersifat asiklik, tetapi siklus memang terjadi hanya karena file BUILD
berisi siklus yang salah.)
Format output ini berguna untuk mengetahui kedalaman grafik.
Jika digunakan untuk hasil kueri deps(x)
, rdeps(x)
,
atau allpaths
, maka nomor peringkat sama dengan
panjang jalur terpendek (dengan minrank
) atau terpanjang
(dengan maxrank
) dari x
ke node di
peringkat tersebut. maxrank
dapat digunakan untuk menentukan
urutan langkah build terpanjang yang diperlukan untuk mem-build 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 mencetak, untuk setiap
target dalam hasil, jenis dan label target, tetapi
diawali oleh string yang menjelaskan lokasi target tersebut, sebagai
nama file dan nomor baris. Formatnya menyerupai output
grep
. Dengan demikian, alat yang dapat mengurai yang terakhir ini (seperti Emacs
atau vi) juga dapat menggunakan output kueri untuk menelusuri serangkaian
kecocokan, yang memungkinkan alat kueri Bazel digunakan sebagai
"grep for BUILD" yang berbasis 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 menghasilkan file tersebut akan dicetak. (Alat kueri tidak memiliki informasi
yang memadai untuk menemukan lokasi sebenarnya dari file yang dihasilkan, dan
dalam hal apa pun, alat ini mungkin tidak ada jika build belum dilakukan.)
Mencetak kumpulan paket
--output package
Opsi ini mencetak nama semua paket yang berisi beberapa target dalam set 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 kumpulan 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 diinstal di workstation, Anda
dapat menginstalnya menggunakan perintah sudo apt-get install graphviz
.)
Lihat contoh bagian di bawah untuk contoh panggilan.
Format output ini sangat berguna untuk kueri allpaths
,
deps
, atau rdeps
, dengan hasil
yang menyertakan serangkaian jalur yang tidak dapat divisualisasi dengan mudah saat
dirender dalam bentuk linear, seperti dengan --output label
.
Secara default, grafik dirender dalam bentuk yang difaktorkan. Artinya,
node yang setara secara topologi digabungkan menjadi satu
node dengan beberapa label. Hal ini akan 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 yang semuanya dihasilkan oleh
genrule
yang sama; dalam grafik terfaktorkan, semua file ini
direpresentasikan 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, label node mungkin sangat panjang. GraphViz tidak dapat menangani label yang melebihi 1.024 karakter, yang merupakan nilai default 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.
Jika --nograph:factored
ditentukan, grafik
akan dicetak tanpa faktorisasi. Hal ini membuat 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
sedang digunakan.
XML
--output xml
Opsi ini menyebabkan target yang dihasilkan dicetak dalam bentuk XML. Outputnya dimulai dengan header XML seperti ini
<?xml version="1.0" encoding="UTF-8"?>
<query version="2">
lalu melanjutkan dengan elemen XML untuk setiap target dalam grafik hasil, dalam urutan topologi (kecuali jika hasil yang tidak diurutkan diminta), lalu diakhiri dengan elemen akhir
</query>
Entri sederhana dimunculkan untuk target jenis file
:
<source-file name='//foo:foo_main.cc' .../>
<generated-file name='//foo:libfoo.so' .../>
Namun, untuk aturan, XML disusun dan berisi definisi semua
atribut aturan, termasuk atribut yang nilainya tidak
ditentukan secara eksplisit dalam file BUILD
aturan.
Selain itu, hasilnya mencakup 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
disediakan 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,
hasil kueri akan menyertakan dependensi ini. Misalnya,
jika //foo:bar
bergantung pada @other-repo//baz:lib
, maka
bazel query 'deps(//foo:bar)'
akan mencantumkan @other-repo//baz:lib
sebagai
dependensi.