Halaman ini adalah 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 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 yang Dikonfigurasi
setelah analisis dan menampilkan informasi tentang Tindakan, Artefak, dan
hubungannya. aquery
berguna saat Anda tertarik dengan
properti Action/Artifact yang dihasilkan dari Grafik Target yang Dikonfigurasi.
Misalnya, perintah sebenarnya berjalan beserta input, output, dan mnemoniknya.
Untuk mengetahui detail lebih lanjut, lihat referensi kueri.
Kueri yang dapat dikonfigurasi
Kueri Bazel tradisional berjalan pada grafik target fase pasca-pemuatan, sehingga tidak ada konsep konfigurasi serta konsep terkaitnya. Khususnya,
tindakan ini tidak me-resolve pernyataan tertentu
dengan benar dan menampilkan semua kemungkinan resolusi pemilihan. Namun, lingkungan kueri yang dapat dikonfigurasi, cquery
, menangani konfigurasi dengan benar, tetapi tidak menyediakan semua fungsi kueri asli ini.
Untuk mengetahui detail lebih lanjut, baca 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
dan target foo_bin
tidak?
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 untuk bahasa ini, dan setiap kata kunci dijelaskan di bawah ini. Kumpulan kata kunci lengkap adalah:Kata, seperti "
foo/...
" atau ".*test rule
" atau "//bar/baz:all
". Jika urutan karakter "dikutip" (diawali dan diakhiri dengan tanda kutip tunggal 'atau dimulai dan diakhiri dengan tanda kutip ganda "), ini adalah kata. Jika urutan karakter tidak dikutip, nilai tersebut mungkin masih diuraikan sebagai kata. Kata-kata tanpa tanda kutip 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, kurung kurawal kiri, kurung siku kanan). Namun, kata-kata tanpa tanda kutip tidak boleh diawali dengan tanda hubung-
atau tanda bintang*
meskipun [nama target][(/concepts/labels#target-names) relatif dapat dimulai dengan karakter tersebut.Kata-kata tanpa tanda kutip juga tidak boleh menyertakan karakter plus tanda
+
atau sama dengan tanda=
, meskipun karakter tersebut diizinkan dalam nama target. Saat menulis kode yang menghasilkan ekspresi kueri, nama target harus dikutip.Mengutip diperlukan saat menulis skrip yang membuat ekspresi kueri Bazel dari nilai yang diberikan 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 dari kutipan apa pun 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-kata biasa. Misalnya,
some
adalah kata kunci, tetapi "beberapa" adalah sebuah 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, gunakan hanya satu jenis tanda kutip (semua tanda kutip tunggal atau ganda).
Berikut adalah contoh 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 sintaksis ini sehingga tanda kutip tidak diperlukan dalam kebanyakan kasus. Contoh (tidak biasa)
".*test rule"
memerlukan tanda kutip: dimulai dengan titik dan berisi spasi. Mengutip"cc_library"
tidak diperlukan 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 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.
Set dan grafik merujuk pada jenis data yang sama, tetapi menekankan aspek yang berbeda, misalnya:
- Kumpulan: Urutan target sebagian tidak menarik.
- Grafik: Urutan parsial target sangat signifikan.
Siklus dalam grafik dependensi
Grafik dependensi build harus siklik.
Algoritme 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 dependensi build 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 dimulai 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, potensi toolchain tidak akan pernah dipertimbangkan.
Kesehatan
Ekspresi bahasa kueri Bazel beroperasi melalui grafik dependensi
build, yang merupakan grafik yang secara implisit ditentukan oleh semua
deklarasi aturan di semua file BUILD
. Penting untuk memahami
bahwa grafik ini agak abstrak, dan bukan merupakan
deskripsi lengkap tentang cara melakukan semua langkah build. Agar
dapat melakukan build, konfigurasi juga diperlukan;
lihat bagian konfigurasi
dalam Panduan Pengguna untuk detail selengkapnya.
Hasil evaluasi ekspresi dalam bahasa kueri Bazel adalah benar untuk semua konfigurasi, yang berarti bahwa ekspresi ini mungkin merupakan perkiraan berlebihan yang konservatif, dan tidak sepenuhnya akurat. Jika Anda menggunakan alat kueri untuk menghitung kumpulan semua file sumber yang diperlukan selama build, alat ini mungkin akan melaporkan lebih banyak 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 dalam build.
Tentang pemeliharaan urutan grafik
Operasi mempertahankan batasan pengurutan yang diwarisi dari subekspresinya. Anda dapat menganggapnya
sebagai "hukum konservasi pesanan sebagian". Pertimbangkan
contoh: jika Anda mengeluarkan kueri untuk menentukan penutupan transitif
dependensi target tertentu, kumpulan yang dihasilkan akan diurutkan
sesuai dengan grafik dependensi. Jika Anda memfilter kumpulan tersebut agar hanya menyertakan target dari jenis file
, hubungan pengurutan parsial transitif yang sama akan terjadi di 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 pesanan, beberapa operasi, seperti operasi yang ditetapkan, tidak memperkenalkan batasan pengurutannya sendiri. Perhatikan ekspresi ini:
deps(x) union y
Urutan kumpulan hasil akhir dijamin untuk mempertahankan semua
batasan urutan subekspresinya, yaitu, bahwa semua
dependensi transitif x
diurutkan dengan benar
dengan saling menghormati. Namun, kueri tersebut tidak menjamin pengurutan target di y
, atau pengurutan target di deps(x)
jika dibandingkan dengan target di y
(kecuali untuk target di y
yang juga berada di deps(x)
).
Operator yang memperkenalkan batasan pengurutan mencakup:
allpaths
, deps
, rdeps
, somepath
, dan karakter pengganti pola target
package:*
, dir/...
, dll.
Kueri Sky
Sky Query adalah mode kueri yang beroperasi pada 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 alam semesta (itulah sebabnya tidak cocok 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
penutupan transitif pola target yang ditentukan oleh pola target, yang dapat
menjadi aditif dan subduktif. 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 untuk --universe_scope
dari ekspresi kueri. Inferensi nilai 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 memperlakukan hal ini sama seperti pemanggilan:
bazel query --universe_scope=//my:target --order_output=no "allrdeps(//my:target)"
Namun, hasil kueri tersebut dengan --universe_scope
hanya //my:target
;
tidak ada dependensi terbalik dari //my:target
yang ada di dunia, melalui
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 perluasan tests
target di beberapa direktori yang secara transitif bergantung pada target yang definisinya menggunakan file .bzl
tertentu. Di sini,
--infer_universe_scope
adalah cara yang praktis, terutama jika pilihan
--universe_scope
mengharuskan Anda mengurai ekspresi kueri sendiri.
Jadi, untuk ekspresi kueri yang menggunakan operator dengan cakupan universe seperti
allrdeps
dan
rbuildfiles
, pastikan untuk menggunakan
--infer_universe_scope
hanya jika perilakunya sesuai dengan yang Anda inginkan.
Sky Query memiliki beberapa kelebihan dan kekurangan dibandingkan dengan kueri default. Kelemahan utamanya adalah tidak dapat mengurutkan output-nya sesuai urutan grafik, sehingga format output tertentu dilarang. Keuntungannya adalah menyediakan
dua operator (allrdeps
dan
rbuildfiles
) yang tidak tersedia dalam kueri default.
Selain itu, Sky Query melakukan pekerjaannya dengan memperkenalkan grafik
Skyframe, bukan membuat grafik
baru, yang dilakukan oleh penerapan default. Oleh karena itu, ada beberapa situasi di mana
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. Hal tersebut ditafsirkan sebagai kumpulan target (yang tidak diurutkan). 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, aturan bar
.
Pola target menggeneralisasi label untuk menyertakan karakter pengganti daripada 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 dievaluasi
ke kumpulan yang berisi semua aturan dalam paket bar/baz
, tetapi bukan
sub-paketnya.
Demikian pula, foo/...:*
adalah pola target yang dievaluasi ke kumpulan yang berisi semua target (file dan aturan) di setiap paket secara rekursif di bawah direktori foo
; bar/baz:*
mengevaluasi ke kumpulan yang berisi semua target dalam paket bar/baz
, tetapi bukan subpaketnya.
Karena karakter pengganti :*
cocok dengan file serta aturan, karakter pengganti 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 detail selengkapnya, lihat Pola Target, atau
ketik bazel help target-syntax
.
Pola target dapat dievaluasi ke kumpulan tunggal (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 relatif terhadap satu sama lain sesuai dengan hubungan dependensi. Jadi, hasil
foo:*
tidak hanya berupa kumpulan target dalam paket foo
, tetapi juga
grafik pada target tersebut. (Tidak ada jaminan atas urutan relatif dari node hasil terhadap node lain.) Untuk mengetahui 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
hasil expr2, dengan semua kemunculan gratis
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 melingkupi adalah error. Dengan kata lain, ekspresi kueri level teratas tidak boleh memiliki variabel bebas.
Dalam produksi tata bahasa di atas, name
mirip dengan kata, tetapi dengan
batasan tambahan bahwa kode tersebut merupakan ID hukum dalam bahasa
pemrograman C. Referensi ke variabel harus diawali dengan karakter "$".
Setiap ekspresi let
hanya menentukan variabel tunggal, tetapi Anda dapat membuatnya bertingkat.
Pola target dan referensi variabel hanya terdiri dari satu token, sebuah kata, yang menciptakan 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: setiap kueri yang dapat dinyatakan dalam bahasa juga dapat dinyatakan tanpanya. Namun, metode tersebut
akan meningkatkan ke ringkasan 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: persimpangan, gabungan, perbedaan himpunan
expr ::= expr intersect expr
| expr ^ expr
| expr union expr
| expr + expr
| expr except expr
| expr - expr
Ketiga operator ini menghitung operasi yang ditetapkan seperti biasa pada argumennya.
Setiap operator memiliki dua bentuk, yaitu bentuk nominal, seperti intersect
, dan
bentuk simbolis, seperti ^
. Kedua formulir setara; bentuk simbolis
lebih cepat diketik. (Untuk lebih jelasnya, bagian selanjutnya dari halaman ini menggunakan bentuk nominal.)
Misalnya,
foo/... except foo/bar/...
mengevaluasi kumpulan target yang cocok dengan foo/...
tetapi tidak foo/bar/...
.
Anda dapat menulis kueri yang sama seperti:
foo/... - foo/bar/...
Operasi intersect
(^
) dan union
(+
) bersifat komutatif (simetris);
except
(-
) bersifat asimetris. Parser memperlakukan ketiga operator tersebut sebagai
asosiasi kiri dan memiliki prioritas yang sama, sehingga Anda mungkin perlu tanda kurung. Misalnya, dua dari dua ekspresi pertama ini 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 dari nol atau beberapa pola target, yang dipisahkan oleh spasi kosong (tanpa koma).
Dalam kaitannya dengan fitur $(...)
shell Bourne, set()
menyediakan
cara menyimpan hasil dari satu kueri dalam file teks biasa, memanipulasi
file teks tersebut menggunakan program lain (seperti alat shell UNIX standar), lalu
memperkenalkan kembali hasilnya 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 nama pendek untuk $(cat foo)
, tetapi perintah
shell selain cat
juga dapat digunakan—seperti perintah awk
sebelumnya.
Functions
expr ::= word '(' int | word | expr ... ')'
Bahasa kueri menentukan beberapa fungsi. Nama fungsi menentukan jumlah dan jenis argumen yang dibutuhkan. 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 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 dalam setiap paket di bawah direktori foo
. Dalam konteks ini,
'dependensi' hanya berarti aturan dan target file. Oleh karena itu, file BUILD
dan
Starlark yang diperlukan untuk membuat target ini tidak disertakan di sini. Untuk itu,
Anda harus menggunakan operator buildfiles
.
Grafik yang dihasilkan diurutkan menurut hubungan dependensi. Untuk detail selengkapnya, lihat bagian tentang urutan grafik.
Operator deps
menerima argumen kedua opsional, yang merupakan literal bilangan bulat yang menentukan batas atas pada kedalaman penelusuran. Jadi,
deps(foo:*, 0)
menampilkan semua target dalam paket foo
, sementara
deps(foo:*, 1)
lebih lanjut menyertakan prasyarat langsung dari setiap target 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 terikat: parameter tersebut akan menghitung penutupan transitif prasyarat refleksif.
Penutupan transitif dari dependensi terbalik: rdeps
expr ::= rdeps(expr, expr)
| rdeps(expr, expr, depth)
Operator rdeps(u, x)
mengevaluasi dependensi terbalik dari kumpulan argumen x dalam penutupan transitif kumpulan universal u.
Grafik yang dihasilkan diurutkan menurut 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 mencakup 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 terikat.
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 oleh flag --universe_scope
, bukan ditentukan secara terpisah. Jadi, jika
--universe_scope=//foo/...
diteruskan, allrdeps(//bar)
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 kumpulan target lengkap
yang berada dalam paket yang sama dengan target dalam kumpulan argumen, dan yang bergantung secara langsung 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
argumennya x, dan mengevaluasi ke kumpulan yang hanya berisi
target tersebut. Parameter k bersifat opsional; jika tidak ada, hasilnya akan berupa kumpulan tunggal yang hanya berisi satu target yang dipilih secara arbitrer. Jika ukuran argumen x lebih kecil dari k, seluruh kumpulan argumen x akan ditampilkan.
Misalnya, ekspresi some(//foo:main union //bar:baz)
bernilai satu
kumpulan tunggal yang berisi //foo:main
atau //bar:baz
—meskipun
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 argumen berupa 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, allpath
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, satu set S dari titik awal dan satu E titik akhir. somepath
menampilkan
grafik node pada 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 di E.
Grafik yang dihasilkan diurutkan berdasarkan hubungan dependensi. Lihat bagian tentang urutan grafik untuk detail selengkapnya.
somepath(S1 + S2, E) , satu kemungkinan hasil. |
somepath(S1 + S2, E) , kemungkinan hasil lainnya. |
allpaths(S1 + S2, E) |
Pemfilteran jenis target: jenis
expr ::= kind(word, expr)
Operator kind(pattern, input)
menerapkan filter ke kumpulan target, dan menghapus target tersebut dari jenis yang tidak 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/...)
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.
Jika cocok dengan package group
, target yang diakhiri dengan :all
tidak dapat 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 dievaluasi ke subset inputnya.
Argumen pertama, pattern adalah kata yang berisi ekspresi reguler di atas nama target. Ekspresi filter
mengevaluasi kumpulan yang berisi semua target x, sehingga x adalah anggota dari kumpulan input dan label (dalam bentuk absolut, seperti //foo:bar
) dari x berisi kecocokan (tanpa anchor) untuk ekspresi reguler pattern. Karena semua
nama target dimulai dengan //
, nama tersebut dapat digunakan sebagai alternatif
untuk anchor ekspresi reguler ^
.
Operator ini sering kali menyediakan 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
di
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
memfilter hanya 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 memfilter file tertentu berdasarkan
nama atau ekstensinya. Misalnya,
filter("\.cc$", deps(//foo))
akan memberikan daftar semua file .cc
yang digunakan untuk membuat //foo
.
Pemfilteran atribut aturan: atribut
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 disediakan; nilai ini dievaluasi
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 di atas nilai
atribut. Ekspresi attr
mengevaluasi set yang berisi semua target
x sehingga x adalah
anggota input yang ditetapkan, adalah aturan dengan atribut
name yang ditentukan dan nilai atribut berisi
pencocokan (tanpa anchor) untuk ekspresi reguler
pattern. Jika name adalah atribut opsional dan aturan tidak menentukannya secara eksplisit, maka 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 menyetelnya
secara eksplisit ke 0 atau tidak menetapkannya sama sekali, tetapi 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 dengan menggunakan bentuk absolut label. Misalnya, atribut deps=[":foo",
"//otherpkg:bar", "wiz"]
akan dikonversi menjadi
string [//thispkg:foo, //otherpkg:bar, //thispkg:wiz]
.
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 panjangnya 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))
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 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 set input, 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 //foo
tanpa melanggar pembatasan 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" di
beberapa aturan dalam kumpulan inputs.
Misalnya, labels(srcs, //foo)
menampilkan kumpulan target yang muncul di atribut srcs
dari aturan //foo
. Jika ada beberapa aturan dengan atribut srcs
dalam kumpulan inputs, gabungan srcs
-nya akan ditampilkan.
Luaskan dan filter test_suite: pengujian
expr ::= tests(expr)
Operator tests(x)
menampilkan kumpulan semua aturan pengujian dalam kumpulan x, yang memperluas aturan test_suite
apa pun ke dalam kumpulan pengujian individual yang direferensikan, dan menerapkan pemfilteran berdasarkan tag
dan size
.
Secara default, evaluasi kueri mengabaikan target non-pengujian di semua aturan test_suite
. Hal ini dapat diubah menjadi error dengan opsi --strict_test_suite
.
Misalnya, kind(test, foo:*)
kueri 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:*
: kueri ini dapat mencakup pengujian milik paket lain,
yang direferensikan secara langsung atau tidak langsung
melalui aturan test_suite
.
File definisi paket: buildfile
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
,
ditambah file .bzl yang direferensikan melalui load
. Perhatikan bahwa tindakan ini juga menampilkan file BUILD
dari paket yang berisi file load
ini.
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 bergantung pada //foo
secara transitif.
File definisi paket: rbuildfiles
expr ::= rbuildfiles(word, ...)
Operator rbuildfiles
mengambil daftar fragmen jalur yang dipisahkan koma dan menampilkan
serangkaian file BUILD
yang secara transitif bergantung pada fragmen jalur tersebut. Misalnya, jika
//foo
adalah paket, rbuildfiles(foo/BUILD)
akan menampilkan
target //foo:BUILD
. Jika file foo/BUILD
memiliki
load('//bar:file.bzl'...
di dalamnya, maka 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 hasil. Misalnya, file sumber (seperti foo.cc
) akan diabaikan,
meskipun file tersebut disebutkan secara eksplisit dalam file BUILD
. Namun, Symlink dihormati, sehingga jika foo/BUILD
adalah symlink ke bar/BUILD
, rbuildfiles(bar/BUILD)
akan menyertakan //foo:BUILD
dalam hasilnya.
Operator rbuildfiles
hampir secara kebalikan dari operator
buildfiles
. Namun, inversi integritas ini
berada 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 sisi lain, korespondensi lebih lemah. Output
operator buildfiles
adalah target yang sesuai dengan semua paket dan .File bzl
yang diperlukan oleh input tertentu. Namun, input operator rbuildfiles
bukan 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
kumpulan x. Dengan kata lain, untuk setiap paket, metode ini menampilkan
file .bzl yang dirujuk dari file BUILD
-nya.
a/b.bzl
=> target //a:b.bzl
), tetapi hal ini tidak harus dilakukan. Oleh karena itu, loadfiles
tidak dapat menulis dengan baik dengan operator kueri
lain, dan hasilnya dapat menyesatkan jika diformat dengan cara yang terstruktur, seperti
[--output=xml](#output-xml)
.Format output
bazel query
membuat grafik.
Anda menentukan konten, format, dan urutan saat 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
diterapkan, sehingga --graph:factored
hanya berlaku
saat --output=graph
digunakan; nama tersebut tidak berpengaruh jika
format output selain graph
digunakan. Demikian pula,
--xml:line_numbers
hanya berlaku saat --output=xml
digunakan.
Di urutan hasil
Meskipun ekspresi kueri selalu mengikuti "hukum
pengurutan urutan grafik", presentasi hasilnya dapat dilakukan
dengan cara yang diurutkan atau tidak berurutan. Hal ini tidak
memengaruhi target dalam kumpulan hasil atau cara kueri dihitung. Ini hanya
memengaruhi cara hasil dicetak ke stdout. Selain itu, node yang
setara dalam urutan dependensi mungkin diurutkan atau mungkin tidak diurutkan berdasarkan 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 tanda ini adalah no
dan --output
adalah salah satu
build
, label
, label_kind
, location
, package
, proto
, atau
xml
, output akan dicetak dalam urutan arbitrer. Ini
umumnya adalah opsi tercepat. Hal ini tidak didukung meskipun
--output
adalah salah satu dari graph
, minrank
, atau
maxrank
: dengan format ini, Bazel selalu mencetak hasil
yang diurutkan berdasarkan urutan dependensi atau peringkat.
Jika tanda ini bernilai deps
, Bazel akan mencetak hasil dalam urutan topologi—yaitu, dependensi terlebih dahulu. Namun, node yang tidak diurutkan berdasarkan urutan dependensi (karena tidak ada jalur dari satu ke jalur lainnya) dapat dicetak dalam urutan apa pun.
Jika tanda ini adalah 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 kedalaman pertama pasca-pemesanan di mana tepi keluar ke node yang tidak dikunjungi dilintasi dalam
urutan abjad dari node pengganti. Terakhir, node dicetak dalam urutan terbalik
saat dikunjungi.
Mencetak node dalam urutan ini mungkin lebih lambat, sehingga hanya boleh 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 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
), dengan memberikan nama makro yang dievaluasi untuk menghasilkan aturan efektif.
Meskipun menggunakan sintaksis yang sama dengan file BUILD
, output-nya tidak dijamin 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 topologis (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
beberapa kemungkinan urutan topologi pada grafik (urutan terbalik hanyalah salah satu di antaranya); urutan yang dipilih tidak ditentukan.
Saat mencetak output kueri somepath
, urutan node dicetak adalah urutan jalur.
Peringatan: dalam beberapa kasus sudut, mungkin ada dua target berbeda dengan
label yang sama; misalnya, aturan sh_binary
dan
file srcs
tunggal (implisitnya) 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 satu target memiliki jenis sh_binary rule
dan jenis source file
lainnya.
Cetak label dan jenis setiap target
--output label_kind
Seperti label
, format output ini mencetak label
setiap target dalam grafik yang dihasilkan, dalam urutan topologi, 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, tetapi bukan muncul dalam
urutan topologi, keduanya muncul dalam urutan peringkat, yang didahului dengan
nomor peringkat. Hal ini tidak terpengaruh oleh flag pengurutan pesan --[no]order_results
(lihat catatan tentang pengurutan hasil).
Ada dua varian untuk format ini: minrank
memberi peringkat
setiap node berdasarkan panjang jalur terpendek dari node root ke node tersebut.
Node "Root" (yang tidak memiliki tepi masuk) berada di peringkat 0,
penerusnya peringkat 1, dll. (Seperti biasa, edge menunjuk dari
target ke prasyaratnya: target yang menjadi targetnya.)
maxrank
memberi peringkat pada setiap node berdasarkan panjang jalur terpanjang dari node root ke node tersebut. Sekali lagi, "root" memiliki peringkat 0, semua node
lain memiliki peringkat yang lebih besar dari peringkat maksimum semua
pendahulunya.
Semua node dalam satu siklus dianggap memiliki peringkat yang sama. (Sebagian besar grafik bersifat asiklik, tetapi siklus hanya terjadi karena file BUILD
berisi siklus yang salah.)
Format output ini berguna untuk menemukan seberapa dalam grafik.
Jika digunakan untuk hasil kueri deps(x)
, rdeps(x)
,
atau allpaths
, angka peringkatnya sama dengan
panjang jalur terpendek (dengan minrank
) atau terpanjang
(dengan maxrank
) dari x
ke node di
peringkat tersebut. maxrank
dapat digunakan untuk menentukan urutan terpanjang dari langkah build yang diperlukan untuk mem-build target.
somepath
pada dasarnya tidak berarti karena somepath
tidak menjamin akan menampilkan jalur terpendek atau terpanjang, dan mungkin menyertakan tepi "transitif" dari satu node jalur ke node jalur lainnya, yang bukan merupakan tepi langsung dalam grafik asli.Misalnya, grafik di sebelah kiri menghasilkan output di sebelah kanan
saat --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 |
Cetak 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. Formatnya menyerupai output
grep
. Dengan demikian, alat yang dapat mengurai kueri terakhir (seperti Emacs
atau vi) juga dapat menggunakan output kueri untuk melangkah melalui serangkaian
kecocokan, yang memungkinkan alat kueri Bazel digunakan sebagai
"grep yang berbasis grafik dependensi untuk file BUILD".
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 yang 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 bagaimanapun juga, alat ini mungkin tidak ada jika build belum dijalankan.)
Cetak kumpulan paket
--output package
Opsi ini mencetak nama semua paket yang mencakup beberapa target dalam set hasil. Nama-nama tersebut dicetak dalam urutan leksikografis; tidak termasuk duplikat. Secara formal, ini adalah proyeksi dari kumpulan label (paket, target) ke paket.
Paket dalam repositori eksternal diformat sebagai
@repo//foo/bar
, sedangkan paket dalam repositori utama
diformat sebagai foo/bar
.
Bersama dengan kueri deps(...)
, opsi output
ini dapat digunakan untuk menemukan kumpulan paket yang harus diperiksa
untuk membuat 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 terinstal di workstation Anda, Anda
dapat menginstalnya menggunakan perintah sudo apt-get install graphviz
.)
Lihat bagian contoh di bawah untuk contoh panggilan.
Format output ini sangat berguna untuk kueri allpaths
,
deps
, atau rdeps
, yang hasilnya
mencakup kumpulan jalur yang tidak dapat dengan mudah divisualisasikan saat
dirender dalam bentuk linear, seperti dengan --output label
.
Secara default, grafik dirender dalam bentuk yang faktor. 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 yang semuanya dihasilkan oleh genrule
yang sama; dalam grafik yang difaktorkan, 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
akan menonaktifkan pemotongan. Karena bentuk faktor yang digunakan untuk grafik biasanya dicetak, 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.
Saat --nograph:factored
ditentukan, grafik
akan dicetak tanpa pemfaktoran. Hal ini membuat visualisasi menggunakan GraphViz tidak praktis, tetapi format yang lebih sederhana dapat mempermudah 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. Output-nya akan dimulai dengan header XML seperti ini
<?xml version="1.0" encoding="UTF-8"?>
<query version="2">
lalu dilanjutkan dengan elemen XML untuk setiap target dalam grafik hasil, dalam urutan topologi (kecuali jika hasil yang tidak diurutkan diminta), lalu diakhiri dengan akhiran
</query>
Entri sederhana dikeluarkan untuk target jenis file
:
<source-file name='//foo:foo_main.cc' .../>
<generated-file name='//foo:libfoo.so' .../>
Namun, untuk aturan, XML memiliki struktur dan berisi definisi semua
atribut aturan, termasuk 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 penerusan (prasyarat) dan konten
atribut outs
adalah dependensi mundur (konsumen).
Elemen rule-input
untuk dependensi implisit 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
, maka bazel query 'deps(//foo:bar)'
akan mencantumkan @other-repo//baz:lib
dan //external:some-lib
sebagai dependensi.
Repositori eksternal itu sendiri bukan dependensi build. Artinya, dalam
contoh di atas, //external:other-repo
bukan dependensi. Paket 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