Halaman ini adalah panduan referensi untuk Bahasa Kueri Bazel yang digunakan
saat Anda menggunakan bazel query
untuk menganalisis dependensi build. 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 di grafik target fase pasca-pemuatan,
Bazel menyertakan kueri grafik tindakan dan kueri yang dapat dikonfigurasi.
Kueri grafik tindakan
Kueri grafik tindakan (aquery
) beroperasi berdasarkan analisis pasca-analisis Dikonfigurasi
Grafik Target dan menampilkan informasi tentang Actions, Artifacts, serta
hubungan mereka. aquery
berguna jika Anda tertarik dengan
properti Tindakan/Artefak 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 dan
sehingga tidak memiliki konsep konfigurasi
dan konsep yang terkait dengannya. Secara khusus,
tindakan ini tidak menyelesaikan pernyataan pilihan dengan benar
dan sebagai gantinya mengembalikan semua
resolusi yang memungkinkan dari pemilihan. Namun,
lingkungan kueri yang dapat dikonfigurasi, cquery
, menangani konfigurasi dengan benar, tetapi
tidak menyediakan semua fungsi dari kueri awal 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++ yang melakukan semua pengujian foo
bergantung pada hal tersebut
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 hal-hal berikut token:
Kata kunci, seperti
let
. Kata kunci adalah kata yang dicadangkan dari bahasa yang berbeda, dan setiap bahasa tersebut dijelaskan di bawah ini. Set lengkap kata kunci adalah:Kata, seperti "
foo/...
" atau ".*test rule
" atau "//bar/baz:all
". Jika urutan karakter adalah "diberi tanda kutip" (dimulai dan diakhiri dengan tanda kutip tunggal ' atau dimulai dan diakhiri dengan tanda kutip ganda "), kata tersebut adalah sebuah kata. Jika urutan karakter tidak dikutip, mungkin masih diurai sebagai sebuah kata. Kata yang tidak dikutip adalah urutan yang digambar dari karakter alfabet A-Za-z, angka 0-9, dan karakter khusus*/@.-_:$~[]
(tanda bintang, garis miring, @, titik, tanda hubung, garis bawah, titik dua, tanda dolar, tanda gelombang, kurung kurawal buka, kotak kanan kurung kurawal). Namun, kata yang tidak dikutip tidak boleh diawali dengan tanda hubung-
atau tanda bintang*
meskipun nama target relatif dapat diawali dengan karakter tersebut.Kata yang tidak dikutip juga tidak boleh menyertakan karakter plus tanda tambah
+
atau sama dengan menandatangani=
, meskipun karakter tersebut diizinkan dalam nama target. Kapan menulis kode yang menghasilkan ekspresi kueri, nama target harus diberi tanda kutip.Pengutipan diperlukan saat menulis skrip yang membentuk kueri Bazel ekspresi 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 kutipan apa pun yang mungkin diperlukan oleh {i>shell<i} 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 "beberapa" adalah sebuah kata.foo
dan "foo" adalah kata-kata.Namun, berhati-hatilah saat menggunakan tanda kutip tunggal atau ganda dalam nama target. Kapan mengutip satu atau lebih nama target, hanya gunakan satu jenis tanda kutip (baik semua tanda kutip tunggal atau ganda semua).
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. Tujuan Contoh
".*test rule"
(tidak biasa) memerlukan tanda kutip: diawali 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 diberi tanda kutip.
Karakter spasi kosong di luar kata yang dikutip akan diabaikan.
Konsep bahasa kueri Bazel
Bahasa kueri Bazel adalah bahasa ekspresi. Setiap ekspresi dievaluasi ke kumpulan target yang diurutkan sebagian, atau yang setara, grafik (DAG) target. Ini adalah satu-satunya {i>datatype<i}.
{i>Dataset<i} dan grafik mengacu pada {i>datatype<i} yang sama, tetapi menekankan perbedaan aspeknya, 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 asiklik (acyclic graph), tetapi kuat terhadap siklus. Detail tentang bagaimana siklus ini 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. Dependensi implisit
dapat didefinisikan oleh:
Secara default, bazel query
mempertimbangkan dependensi implisit
saat menghitung hasil kueri. Perilaku ini
dapat diubah dengan
opsi --[no]implicit_deps
.
Perhatikan bahwa, karena kueri tidak mempertimbangkan konfigurasi, toolchain potensial implementations tidak dianggap sebagai dependensi, hanya jenis toolchain yang diperlukan. Lihat dokumentasi toolchain.
Tingkat kesehatan
Ekspresi bahasa kueri Bazel beroperasi pada seluruh build
grafik dependensi, yakni 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 menjalankan semua langkah build. Di beberapa
agar dapat menjalankan build, konfigurasi juga diperlukan;
lihat bagian konfigurasi
dalam Panduan Pengguna untuk informasi lebih lanjut.
Hasil evaluasi ekspresi dalam bahasa kueri Bazel benar untuk semua konfigurasi, yang berarti mungkin perkiraan berlebihan yang konservatif, dan tidak terlalu tepat. Jika Anda menggunakan alat kueri untuk menghitung set yang berisi semua file sumber yang dibutuhkan selama build, mungkin akan ada laporan lebih banyak dari yang sebenarnya diperlukan karena, misalnya, alat kueri akan menyertakan semua file yang diperlukan untuk mendukung terjemahan pesan, meskipun Anda tidak bermaksud untuk menggunakan fitur tersebut dalam build Anda.
Tentang mempertahankan urutan grafik
Operasi mempertahankan setiap urutan
batasan yang diwarisi dari subekspresinya. Anda dapat
membayangkan
ini sebagai "hukum kekekalan urutan parsial". Pertimbangkan
contoh: jika Anda mengeluarkan kueri untuk menentukan penutupan transitif
dependensi target tertentu, set yang dihasilkan akan diurutkan
sesuai dengan grafik dependensinya. Jika Anda filter
yang ditetapkan ke
hanya menyertakan target file
jenis, hal yang sama
hubungan pengurutan parsial transitif antara setiap
pasangan target dalam subset yang dihasilkan - meskipun tidak ada
pasangan ini sebenarnya
terhubung langsung dalam grafik asli.
(Tidak ada tepi file-file dalam grafik dependensi build).
Akan tetapi, meskipun semua operator mempertahankan pesanan, beberapa seperti operasi set tidak memperkenalkan batasan pengurutan mereka sendiri. Pertimbangkan ekspresi ini:
deps(x) union y
Urutan kumpulan hasil akhir dijamin mempertahankan semua
batasan pengurutan subekspresinya, yaitu
dependensi transitif x
diurutkan dengan benar dengan
saling menghormati satu sama lain. Namun, kueri itu tidak menjamin
apa pun tentang
urutan target di y
, maupun tentang
urutan target di deps(x)
dibandingkan dengan target di
y
(kecuali untuk target dalam
y
yang juga terjadi di deps(x)
).
Operator yang menerapkan batasan pengurutan meliputi:
allpaths
, deps
, rdeps
, somepath
, dan karakter pengganti pola target
package:*
, dir/...
, dll.
Kueri terkait Sky
Sky Query adalah mode kueri yang beroperasi melalui cakupan alam semesta yang ditentukan.
Fungsi khusus hanya tersedia di SkyQuery
Mode Sky Query memiliki fungsi kueri tambahan, allrdeps
, dan
rbuildfiles
. Fungsi-fungsi ini beroperasi di seluruh
cakupan semesta (karena alasan tersebut 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
melakukan pramuat penutupan transitif pola target yang ditentukan oleh pola target, yang dapat
bersifat aditif dan subtraktif. Semua kueri kemudian dievaluasi dalam "cakupan" ini. Secara khusus, kita akan membuat
allrdeps
dan
Operator rbuildfiles
hanya menampilkan hasil dari cakupan ini.
--infer_universe_scope
memberi tahu Bazel untuk menyimpulkan nilai untuk --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"]
, jadi
Bazel memperlakukannya sama seperti pemanggilan:
bazel query --universe_scope=//my:target --order_output=no "allrdeps(//my:target)"
Namun, hasil kueri dengan --universe_scope
hanya //my:target
;
tidak ada satu pun dependensi terbalik dari //my:target
yang ada di alam semesta,
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 penting yang mencoba menghitung target pengujian dalam
tests
perluasan target di beberapa direktori yang
secara transitif bergantung pada target yang definisinya menggunakan file .bzl
tertentu. Di sini,
--infer_universe_scope
adalah kenyamanan, terutama jika pilihan
--universe_scope
akan mengharuskan Anda untuk mengurai ekspresi kueri sendiri.
Jadi, untuk ekspresi kueri yang menggunakan
operator cakupan alam semesta seperti
allrdeps
dan
pastikan Anda menggunakan rbuildfiles
--infer_universe_scope
hanya jika perilakunya sesuai dengan yang Anda inginkan.
Sky Query memiliki beberapa kelebihan dan kekurangan dibandingkan dengan kueri default. Utama
kerugiannya adalah ia tidak dapat mengurutkan {i>outputnya<i}
sesuai dengan urutan grafik, dan dengan demikian
format output dilarang. Kelebihannya, ia dapat menyediakan
dua operator (allrdeps
dan
rbuildfiles
) yang tidak tersedia di kueri default.
Selain itu, Sky Query melakukan pekerjaannya dengan
Skyframe, bukan membuat grafik baru
, yang merupakan fungsi dari implementasi default. Jadi, ada beberapa keadaan di mana
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, target, dan bar
aturan.
Pola target menggeneralisasi label untuk menyertakan
karakter pengganti di atas paket dan
target. Misalnya, foo/...:all
(atau hanya foo/...
) adalah pola target
yang mengevaluasi ke set yang berisi semua aturan di setiap paket secara rekursif
di bawah direktori foo
; bar/baz:all
adalah pola target yang mengevaluasi
ke set yang berisi semua aturan dalam paket bar/baz
, tetapi bukan
sub-paket.
Demikian pula, foo/...:*
adalah pola target yang dievaluasi ke kumpulan yang berisi
semua target (aturan dan file) di setiap paket secara rekursif di bawah
Direktori foo
; bar/baz:*
mengevaluasi ke kumpulan yang berisi semua target di
paket bar/baz
, tetapi bukan sub-paketnya.
Karena karakter pengganti :*
cocok dengan file serta aturan, biasanya lebih
berguna dari :all
untuk kueri. Sebaliknya, karakter pengganti :all
(implisit di
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 mengevaluasi ke set singleton (dalam kasus label), ke
kumpulan yang berisi banyak elemen (seperti dalam kasus foo/...
, yang memiliki ribuan
) atau ke kumpulan kosong, jika pola target tidak cocok dengan target apa pun.
Semua node dalam hasil ekspresi pola target diurutkan dengan benar
relatif satu sama lain sesuai
dengan relasi ketergantungan. Hasil dari
foo:*
bukan hanya kumpulan target dalam paket foo
, tetapi juga merupakan
grafik di atas target tersebut. (Tidak ada jaminan yang dibuat terkait pemesanan relatif
node hasil terhadap node lain.) Untuk mengetahui detail selengkapnya, lihat
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
dari expr2, dengan semua kemunculan gratis
variabel name diganti dengan nilai
expr1.
Misalnya, let v = foo/... in allpaths($v, //common) intersect $v
adalah
setara dengan allpaths(foo/...,//common) intersect foo/...
.
Kejadian referensi variabel name
selain pada
ekspresi let name = ...
yang disertakan adalah
{i>error<i}. Dengan kata lain, ekspresi kueri tingkat
atas tidak bisa memiliki
variabel.
Pada produksi tata bahasa di atas, name
seperti kata, tetapi dengan
batasan tambahan sebagai pengidentifikasi
yang sah dalam pemrograman C
di bahasa target. Referensi ke variabel harus diawali dengan "$" karakter.
Setiap ekspresi let
hanya menentukan satu variabel, tetapi Anda dapat menyusunnya bertingkat.
Baik pola target dan referensi variabel terdiri dari hanya satu token, sebuah kata, menciptakan ambiguitas sintaksis. Namun, ada tidak ada ambiguitas semantik, karena subset kata-kata yang merupakan variabel hukum nama terpisah dari subset kata yang merupakan pola target hukum.
Secara teknis, ekspresi let
tidak akan meningkat
ekspresif bahasa kueri: kueri apa pun yang dapat dinyatakan dalam
bahasa juga dapat diekspresikan tanpa tanda-tanda tersebut. Namun, mereka
meningkatkan keringkasan banyak kueri, dan juga dapat menghasilkan
evaluasi kueri yang efisien.
Ekspresi dalam tanda kurung
expr ::= (expr)
Tanda kurung mengaitkan subekspresi untuk memaksa urutan evaluasi. Ekspresi dalam tanda kurung mengevaluasi 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 argumen mereka.
Setiap operator memiliki dua bentuk, bentuk nominal, seperti intersect
, dan
bentuk simbolis, seperti ^
. Kedua formulir bersifat setara; bentuk simbolis adalah
lebih cepat untuk mengetik. (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 dengan:
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, jadi Anda mungkin memerlukan tanda kurung. Sebagai
contoh, 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 *)
set(a b c ...)
operator menghitung gabungan dari
serangkaian nol atau lebih
pola target, yang dipisahkan oleh spasi kosong (tanpa koma).
Bersama dengan fitur $(...)
shell Bourne, set()
menyediakan
berarti menyimpan hasil dari satu kueri
dalam file teks biasa, memanipulasi
file teks tersebut menggunakan program lain (seperti alat {i>shell<i} UNIX standar), lalu
memasukkan hasilnya kembali ke dalam
alat kueri sebagai nilai untuk
diproses. 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))
adalah
dihitung dengan memfilter nilai maxrank
menggunakan program awk
.
bazel query 'deps(//some_dir/foo:main)' --output maxrank | awk '($1 < 5) { print $2;} ' > foo
bazel query "kind(cc_library, set($(<foo)))"
Dalam contoh ini, $(<foo)
adalah singkatan untuk $(cat foo)
, tetapi shell
perintah selain cat
dapat digunakan juga—seperti perintah awk
sebelumnya.
Fungsi
expr ::= word '(' int | word | expr ... ')'
Bahasa kueri menentukan beberapa fungsi. Nama {i>function<i} menentukan jumlah dan jenis argumen yang dibutuhkan. Hal berikut fungsi tersebut tersedia:
allpaths
attr
buildfiles
rbuildfiles
deps
filter
kind
labels
loadfiles
rdeps
allrdeps
same_pkg_direct_rdeps
siblings
some
somepath
tests
visible
Penutupan transitif dependensi: dependensi
expr ::= deps(expr)
| deps(expr, depth)
Operator deps(x)
mengevaluasi ke grafik yang dibentuk
oleh penutupan transitif dependensi kumpulan argumennya
x. Misalnya, nilai deps(//foo)
adalah
grafik dependensi yang di-root pada node tunggal foo
, termasuk semua
dependensi. Nilai deps(foo/...)
adalah grafik dependensi yang root-nya
adalah semua aturan di setiap paket di bawah direktori foo
. Dalam konteks ini,
'ketergantungan' hanya berarti aturan dan target file, oleh karena itu BUILD
dan
File Starlark yang diperlukan untuk membuat target tersebut tidak disertakan di sini. Untuk itu
Anda harus menggunakan operator buildfiles
.
Grafik yang dihasilkan diurutkan sesuai dengan relasi ketergantungan. Untuk selengkapnya detail, lihat bagian tentang urutan grafik.
Operator deps
menerima argumen kedua opsional, yaitu bilangan bulat
yang menetapkan batas atas
dalam penelusuran. Namun
deps(foo:*, 0)
menampilkan semua target dalam paket foo
, sedangkan
deps(foo:*, 1)
lebih lanjut menyertakan prasyarat langsung untuk target apa pun dalam
paket foo
, dan deps(foo:*, 2)
selanjutnya menyertakan node secara langsung
yang 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 akan
tidak terbatas: menghitung penutupan transitif refleksif terhadap prasyarat.
Penutupan transitif dependensi terbalik: rdeps
expr ::= rdeps(expr, expr)
| rdeps(expr, expr, depth)
rdeps(u, x)
operator mengevaluasi ke dependensi terbalik dari set argumen
x dalam penutupan transitif alam semesta disetel
u.
Grafik yang dihasilkan diurutkan sesuai dengan relasi ketergantungan. Lihat di urutan grafik untuk mengetahui detail selengkapnya.
Operator rdeps
menerima argumen ketiga opsional, yaitu bilangan bulat
yang menetapkan batas atas
dalam penelusuran. Hasil
grafik hanya menyertakan node pada jarak dengan kedalaman yang ditentukan dari
di set argumen. Jadi, rdeps(//foo, //common, 1)
mengevaluasi ke semua node
dalam penutupan transitif //foo
yang secara langsung bergantung pada //common
. (Iklan
angka sesuai dengan peringkat yang ditampilkan dalam output minrank
format.) Jika parameter depth dihilangkan,
pencarian tak terbatas.
Penutupan transitif semua dependensi terbalik: allrdeps
expr ::= allrdeps(expr)
| allrdeps(expr, depth)
Operator allrdeps
berperilaku seperti rdeps
operator, kecuali bahwa "semesta disetel" apa pun flag --universe_scope
dievaluasi, alih-alih ditentukan secara terpisah. Jadi, jika
--universe_scope=//foo/...
diteruskan, maka allrdeps(//bar)
adalah
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 target lengkap
yang berada 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
paket yang sama sebagai target
dalam kumpulan argumen.
Pilihan arbitrer: beberapa
expr ::= some(expr)
| some(expr, count )
Operator some(x, k)
memilih maksimal k target secara acak dari
yang ditetapkan ke x, dan mengevaluasi ke set yang berisi
target tersebut. Parameter k bersifat opsional; jika
tidak ada, hasilnya adalah kumpulan singleton yang hanya berisi satu target
dipilih secara arbitrer. Jika ukuran kumpulan argumen x adalah
lebih kecil dari k, seluruh kumpulan argumen
x akan ditampilkan.
Misalnya, ekspresi some(//foo:main union //bar:baz)
dievaluasi ke
kumpulan singleton yang berisi //foo:main
atau //bar:baz
—meskipun
satu 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
menghitung fungsi identitas: some(//foo:main)
adalah
setara dengan //foo:main
.
Terjadi error jika set argumen yang ditentukan kosong, seperti dalam
ekspresi some(//foo:main intersect //bar:baz)
.
Operator jalur: somepath, allpaths
expr ::= somepath(expr, expr)
| allpaths(expr, expr)
somepath(S, E)
dan
Komputasi operator allpaths(S, E)
jalur antara dua kumpulan target. Kedua kueri menerima dua
argumen, kumpulan S titik awal, dan kumpulan
E titik akhir. somepath
akan menampilkan
grafik node pada beberapa jalur arbitrer dari target dalam
S ke target di E; allpaths
menampilkan grafik node pada semua jalur dari target mana pun dalam
S ke target apa pun di E.
Grafik yang dihasilkan diurutkan sesuai dengan relasi dependensi. Lihat bagian 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)
kind(pattern, input)
operator menerapkan filter ke kumpulan target, dan menghapus target tersebut
yang tidak seperti
yang diharapkan. pattern
menentukan jenis target yang akan dicocokkan.
Misalnya, jenis untuk empat target yang ditentukan oleh file BUILD
(untuk paket p
) yang ditampilkan di bawah ini diilustrasikan dalam tabel:
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 dibuat | |
//p:BUILD |
file sumber |
Dengan demikian, kind("cc_.* rule", foo/...)
mengevaluasi ke kumpulan
dari 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
.
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 untuk package group
, target yang diakhiri dengan
:all
mungkin tidak memberikan hasil apa pun. Gunakan :all-targets
sebagai gantinya.
Pemfilteran nama target: filter
expr ::= filter(word, expr)
filter(pattern, input)
operator menerapkan filter ke kumpulan target, dan menghapus target yang
label (dalam bentuk absolut) tidak sesuai dengan pola; ini
mengevaluasi ke subset inputnya.
Argumen pertama, pattern adalah kata yang berisi
ekspresi reguler di atas nama target. Ekspresi filter
mengevaluasi ke kumpulan yang berisi semua target x sehingga
x adalah anggota kumpulan input dan
label (dalam bentuk absolut, seperti //foo:bar
)
dari x berisi pencocokan (unanchored)
untuk ekspresi reguler pattern. Karena semua
nama target yang diawali dengan //
, ini dapat digunakan sebagai alternatif
ke anchor ekspresi reguler ^
.
Operator ini sering kali memberikan alternatif yang
jauh lebih cepat dan lebih tangguh daripada
Operator intersect
. Misalnya, untuk melihat semua
bar
dependensi 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 pada
file BUILD
yang tidak relevan. Alternatifnya adalah:
filter(//bar, deps(//foo))
yang terlebih dahulu akan menghitung kumpulan dependensi //foo
dan
maka hanya target yang cocok dengan pola yang diberikan,
kata, target dengan nama yang berisi //bar
sebagai substring.
Penggunaan umum lainnya dari operator filter(pattern,
expr)
adalah untuk memfilter file tertentu berdasarkan
nama 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)
Tujuan
attr(name, pattern, input)
operator menerapkan filter pada kumpulan target, dan menghapus target yang tidak
aturan, target aturan yang tidak memiliki atribut name
target aturan atau yang ditetapkan dengan nilai atribut yang tidak cocok dengan
ekspresi reguler pattern; yang dievaluasi
ke subset inputnya.
Argumen pertama, name adalah nama aturan
yang harus dicocokkan dengan atribut
ekspresi reguler. Argumen kedua,
pattern adalah ekspresi reguler pada atribut
masing-masing. Ekspresi attr
dievaluasi ke kumpulan yang berisi semua target
x sehingga x adalah
dari kumpulan input, merupakan aturan dengan
name dan nilai atribut berisi
kecocokan (unanchored) untuk ekspresi reguler
pattern. Jika name adalah
aturan dan atribut opsional tidak menentukannya secara eksplisit kemudian default
nilai atribut akan digunakan untuk perbandingan. Misalnya,
attr(linkshared, 0, deps(//foo))
akan memilih semua dependensi //foo
yang diizinkan untuk memiliki
atribut bersama link (seperti, aturan cc_binary
) dan memiliki
secara eksplisit atur ke 0 atau tidak di atur sama sekali namun nilai defaultnya adalah 0 (seperti
cc_binary
).
Atribut jenis daftar (seperti srcs
, data
, dll.) adalah
dikonversi menjadi string bentuk [value<sub>1</sub>, ..., value<sub>n</sub>]
,
dimulai dengan tanda kurung [
, dan 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]
.
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
kosong atribut srcs
, sedangkan
attr("data", ".{3,}", deps(//foo))
akan memilih semua aturan di antara dependensi //foo
yang menentukan pada
setidaknya satu nilai dalam atribut data
(setiap label setidaknya
Panjang 3 karakter karena //
dan :
).
Untuk memilih semua aturan di antara dependensi //foo
dengan value
tertentu dalam
atribut {i>list-type<i}, 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 semua target dalam output harus terlihat. Ekspresi visible mengevaluasi ke kumpulan yang berisi semua target x sehingga x merupakan anggota dari kumpulan input, dan untuk semua target y dalam predicate x terlihat oleh y. Contoh:
visible(//foo, //bar:*)
akan memilih semua target dalam paket //bar
yang //foo
dapat diandalkan tanpa melanggar batasan visibilitas.
Evaluasi atribut aturan label jenis: label
expr ::= labels(word, expr)
labels(attr_name, inputs)
mengembalikan serangkaian target yang ditentukan dalam
atribut attr_name dari jenis "label" atau "daftar label" inci
beberapa aturan dalam kumpulan inputs.
Misalnya, labels(srcs, //foo)
menampilkan kumpulan
target yang muncul dalam atribut srcs
aturan //foo
. Jika ada beberapa aturan
dengan atribut srcs
dalam kumpulan inputs,
gabungan dari srcs
-nya akan ditampilkan.
Meluaskan dan memfilter test_suites: pengujian
expr ::= tests(expr)
Operator tests(x)
menampilkan kumpulan dari semua pengujian
aturan dalam kumpulan x, yang memperluas test_suite
aturan menjadi
serangkaian tes individu yang mereka rujuk, dan menerapkan penyaringan dengan
tag
dan size
.
Secara default, evaluasi kueri
mengabaikan target non-pengujian di semua aturan test_suite
. Dapat berupa
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 (dengan
definisi) paket foo
. Sebaliknya,
kueri tests(foo:*)
akan mengembalikan semua
tes individu yang akan dijalankan oleh bazel test
foo:*
: ini mungkin termasuk tes milik paket lain,
yang dirujuk langsung atau tidak langsung
melalui aturan test_suite
.
File definisi paket: buildfiles
expr ::= buildfiles(expr)
Operator buildfiles(x)
akan menampilkan set
file yang mendefinisikan paket
dari setiap target dalam
tetapkan x; dengan kata lain, untuk setiap paket, file BUILD
-nya,
plus file .bzl apa pun yang menjadi referensinya melalui load
. Perhatikan bahwa
juga menampilkan file BUILD
dari paket yang berisi
File load
.
Operator ini biasanya digunakan
saat menentukan file atau
paket diperlukan untuk membangun target yang ditentukan, sering kali bersama
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 secara transitif bergantung pada fragmen jalur ini. Misalnya, jika
//foo
adalah sebuah paket, maka rbuildfiles(foo/BUILD)
akan menampilkan
Target //foo:BUILD
. Jika file foo/BUILD
memiliki
load('//bar:file.bzl'...
di dalamnya, lalu rbuildfiles(bar/file.bzl)
akan
menampilkan target //foo:BUILD
, serta target untuk file BUILD
lainnya yang
muat //bar:file.bzl
Cakupan operator --universe_scope
. File yang tidak berkaitan langsung dengan file BUILD
dan .bzl
file tidak akan mempengaruhi hasil. Misalnya, file sumber (seperti foo.cc
) diabaikan,
meskipun hal tersebut disebutkan secara eksplisit dalam file BUILD
. Namun demikian, Symlink
dihormati, sehingga
jika foo/BUILD
adalah symlink ke bar/BUILD
, maka
rbuildfiles(bar/BUILD)
akan menyertakan //foo:BUILD
dalam hasilnya.
Secara moral, operator rbuildfiles
hampir merupakan kebalikan dari
Operator buildfiles
. Namun, inversi moral ini
lebih kuat dalam satu arah: output rbuildfiles
sama seperti
input dari buildfiles
; yang pertama hanya akan berisi
BUILD
target file dalam paket,
dan yang terakhir mungkin berisi target tersebut. Di arah lain, korespondensi akan lebih lemah. Tujuan
output dari operator buildfiles
adalah target yang sesuai dengan semua paket dan .bzl
file yang dibutuhkan 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)
akan menampilkan kumpulan
File Starlark yang diperlukan untuk
memuat paket setiap target di
setel x. Dengan kata lain, untuk setiap paket, ia mengembalikan
File .bzl yang direferensikan dari file BUILD
-nya.
Format keluaran
bazel query
membuat grafik.
Anda menentukan konten, format, dan pengurutan yang digunakan
bazel query
menyajikan grafik ini
dengan opsi command line --output
.
Saat dijalankan dengan Sky Query, hanya format output yang kompatibel dengan
output yang tidak berurutan diizinkan. Khususnya, graph
, minrank
, dan
Format output maxrank
dilarang.
Beberapa format output menerima opsi tambahan. Nama
setiap opsi output diawali dengan format output
berlaku, jadi --graph:factored
hanya berlaku
saat --output=graph
sedang digunakan; tidak akan berpengaruh jika
format output selain graph
yang digunakan. Demikian pula,
--xml:line_numbers
hanya berlaku jika --output=xml
digunakan.
Pada urutan hasil
Meskipun ekspresi kueri selalu mematuhi "hukum
konservasi urutan grafik", mempresentasikan hasil dapat dilakukan
baik dengan cara yang tergantung
atau tidak berurutan. Hal ini tidak
memengaruhi target dalam kumpulan hasil atau cara penghitungan kueri. Hanya
mempengaruhi bagaimana
hasilnya dicetak ke {i>stdout<i}. Selain itu, {i>node<i} yang
setara dalam urutan dependensi mungkin atau tidak
akan diurutkan menurut abjad.
Flag --order_output
dapat digunakan untuk mengontrol perilaku ini.
(Flag --[no]order_results
memiliki subset fungsi
dari flag --order_output
dan tidak digunakan lagi.)
Nilai default flag ini adalah auto
, yang mencetak hasil dalam bahasa leksikografis
pesanan. Namun, jika somepath(a,b)
digunakan, hasilnya akan dicetak dalam
Pesanan deps
.
Jika tanda ini adalah no
dan --output
adalah salah satu dari
build
, label
, label_kind
, location
, package
, proto
, atau
xml
, output akan dicetak dalam urutan arbitrer. Ini adalah
yang secara umum menjadi opsi tercepat. Fitur ini tidak didukung saat
--output
adalah salah satu dari graph
, minrank
, atau
maxrank
: dengan format ini, Bazel selalu mencetak hasil
diurutkan berdasarkan tingkat
ketergantungan atau peringkat.
Jika flag ini adalah deps
, Bazel akan mencetak hasil dalam urutan topologis—yaitu,
dependensi terlebih dahulu dan dependensi
setelahnya. Akan tetapi, node yang tidak diurutkan oleh
urutan dependensi (karena tidak ada jalur
dari salah satu ke yang lain) mungkin
yang 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 {i>node<i} dalam daftar
digunakan sebagai awal dari sebuah
penelusuran depth-first pascaurutan di mana tepi keluar ke node yang tidak dikunjungi dilintasi
urutan abjad dari simpul penerusnya. Terakhir, node dicetak dalam urutan terbalik
tempat mereka dikunjungi.
Mencetak node dalam urutan ini mungkin lebih lambat, sehingga hanya boleh digunakan jika determinisme sangatlah penting.
Cetak bentuk sumber target seperti yang akan terlihat di BUILD
--output build
Dengan opsi ini, representasi setiap target seolah-olah
dalam bahasa BUILD. Semua variabel dan panggilan fungsi
(seperti glob, makro) diperluas, yang berguna untuk melihat efeknya
makro Starlark. Selain itu, setiap aturan efektif melaporkan
generator_name
dan/atau generator_function
),
memberikan nama makro yang dievaluasi untuk menghasilkan aturan yang efektif.
Meskipun output menggunakan sintaksis yang sama dengan file BUILD
,
dijamin akan 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 jika --noorder_results
ditentukan, lihat
catatan tentang urutan hasil).
(Pengurutan topologis adalah
urutan di mana grafik
node akan muncul lebih awal daripada semua penggantinya.) Tentu saja ada
ada banyak kemungkinan pengurutan topologi grafik (pembalikan
postorder hanyalah satu); yang dipilih tidak ditentukan.
Saat mencetak output kueri somepath
, urutan
tempat node dicetak adalah urutan jalur.
Peringatan: dalam beberapa kasus sudut, mungkin ada dua target yang berbeda dengan
label yang sama; misalnya, aturan sh_binary
dan
satu-satunya file srcs
(implisit) dapat dipanggil
foo.sh
. Jika hasil kueri berisi kedua
target ini, output-nya (dalam format label
) akan muncul
untuk memuat duplikasi. Saat menggunakan label_kind
(lihat
berikut), perbedaannya menjadi jelas: kedua target tersebut memiliki
dengan nama yang sama, tetapi yang satu memiliki jenis sh_binary rule
dan
source file
jenis 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 topologis, tetapi
mendahului label dengan jenis target.
Target cetak dalam format buffering protokol
--output proto
Mencetak output kueri sebagai
QueryResult
{i>buffering<i} protokol.
Cetak target dalam format buffering protokol yang dibatasi-panjang
--output streamed_proto
Mencetak
dibatasi panjang
aliran data
Target
{i>buffer<i} protokol. Hal ini berguna untuk (i) berkeliling
batasan ukuran
{i>buffer<i} protokol ketika 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
QueryResult
penyangga protokol, tetapi di
format teks.
Cetak target dalam format ndjson
--output streamed_jsonproto
Serupa dengan --output streamed_proto
, mencetak aliran data
Target
buffering protokol kecuali dalam format ndjson.
Cetak label setiap target dalam urutan peringkat
--output minrank --output maxrank
Seperti label
, minrank
dan maxrank
format output mencetak label masing-masing
target di grafik yang dihasilkan, tetapi alih-alih muncul di
urutan topologis, mereka muncul dalam urutan peringkat, didahului
nomor peringkat. Ini tidak terpengaruh oleh pengurutan hasil
Flag --[no]order_results
(lihat catatan di
urutan hasil).
Ada dua varian dari format ini: peringkat minrank
setiap {i>node<i} dengan panjang jalur
terpendek dari {i>node<i} {i>root<i} ke sana.
"Root" {i>node<i} (yang tidak memiliki tepian masuk) adalah peringkat 0,
penerusnya berperingkat 1, dst. (Seperti biasa, titik tepi dari
target ke prasyaratnya: target yang diperlukan.)
maxrank
mengurutkan setiap node berdasarkan panjang terpanjang
jalur dari sebuah {i>
node<i} {i>root<i} ke sana. Sekali lagi, "{i>root<i}" memiliki peringkat 0, semua
node memiliki peringkat yang lebih besar satu dari peringkat maksimum semua
seperti pendahulunya.
Semua node dalam siklus dianggap memiliki peringkat yang sama. (Sebagian besar grafik
asiklik, tetapi siklus memang terjadi
hanya karena file BUILD
berisi siklus yang salah.)
Format output ini berguna untuk menemukan seberapa dalam grafik.
Jika digunakan untuk hasil deps(x)
, rdeps(x)
,
atau allpaths
, maka nomor peringkat sama dengan
panjang terpendek (dengan minrank
) atau terpanjang
(dengan maxrank
) jalur dari x
ke node di
pada peringkat tersebut. maxrank
dapat digunakan untuk menentukan
urutan langkah build terpanjang yang diperlukan untuk membangun target.
Misalnya, grafik di sebelah kiri menghasilkan output di sebelah kanan
saat --output minrank
dan --output maxrank
ditentukan masing-masing.
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 dicetak, untuk setiap
target dalam hasilnya, yaitu jenis dan label target, tetapi
diawali dengan string yang menjelaskan lokasi target tersebut, sebagai
nama file dan nomor baris. Format ini menyerupai {i>output<i} dari
grep
. Dengan demikian, alat yang dapat mengurai yang terakhir (seperti Emacs
atau vi) juga dapat menggunakan {i>output<i} kueri untuk melangkah melalui serangkaian
cocok, memungkinkan alat kueri Bazel digunakan sebagai
"grep for BUILD files" yang sadar grafik dependensinya.
Informasi lokasi bervariasi menurut jenis target (lihat operator jenis). Untuk aturan,
lokasi deklarasi aturan dalam file BUILD
dicetak.
Untuk {i>file<i} sumber, lokasi baris 1 dari file yang sebenarnya
dicetak. Untuk file yang dibuat, lokasi aturan yang
akan dicetak. (Alat kueri tidak memiliki
informasi untuk menemukan lokasi
sebenarnya dari file yang dihasilkan, dan
dalam kasus apa pun, aktivitas itu mungkin tidak ada jika build belum dijalankan.)
Mencetak kumpulan paket
--output package
Opsi ini mencetak nama semua paket yang beberapa target dalam kumpulan hasil tersebut. Nama-nama tersebut dicetak dalam urutan leksikografis; duplikat akan dikecualikan. Secara formal, ini adalah proyeksi dari kumpulan label (paket, target) ke paket.
Paket dalam repositori eksternal diformat sebagai
@repo//foo/bar
saat paket di repositori utama
diformat sebagai foo/bar
.
Bersama dengan kueri deps(...)
, output ini
opsi yang 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 dalam format
AT&T GraphViz yang populer. Biasanya,
hasil 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 bagian contoh di bawah untuk contoh panggilan.
Format output ini sangat berguna untuk allpaths
,
kueri deps
, atau rdeps
, dengan hasil
mencakup sekumpulan jalur yang tidak dapat dengan mudah divisualisasikan saat
dirender dalam bentuk linear, seperti dengan --output label
.
Secara default, grafik dirender dalam bentuk yang difaktorkan. Yaitu,
node yang setara secara topologi digabungkan
menjadi satu
{i>node <i}dengan beberapa label. Ini membuat grafik lebih ringkas
dan dapat dibaca, karena grafik hasil biasanya berisi
pola yang repetitif. Misalnya, aturan java_library
mungkin bergantung pada ratusan file sumber Java yang semuanya dihasilkan oleh
genrule
yang sama; pada grafik terfaktor, semua file ini
diwakili oleh satu {i>node<i}. Perilaku ini mungkin dinonaktifkan
dengan opsi --nograph:factored
.
--graph:node_limit n
Opsi ini menetapkan panjang maksimum {i>string<i} label untuk
{i>node<i} grafik dalam output. Label yang lebih panjang akan terpotong; -1
menonaktifkan pemotongan. Dikarenakan bentuk faktor
yang mana grafiknya
biasanya dicetak, label {i>node<i}
mungkin sangat panjang. GraphViz tidak dapat
menangani label yang melebihi 1.024 karakter, yang merupakan nilai default
opsi ini. Opsi ini tidak berpengaruh kecuali
--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 pemfaktoran. Hal ini membuat visualisasi menggunakan GraphViz
tidak praktis, tetapi format yang lebih sederhana
dapat memudahkan pemrosesan data oleh
(seperti grep). Opsi ini tidak berpengaruh
kecuali jika --output=graph
sedang digunakan.
XML
--output xml
Opsi ini menyebabkan target yang dihasilkan dicetak dalam XML formulir. 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 topologis (kecuali hasil yang tidak diurutkan diminta), dan diakhiri dengan
</query>
Entri sederhana dimunculkan untuk target jenis file
:
<source-file name='//foo:foo_main.cc' .../>
<generated-file name='//foo:libfoo.so' .../>
Tetapi untuk aturan, XML merupakan
struktur dan berisi definisi dari semua
atribut aturan, termasuk yang nilainya tidak
secara eksplisit ditentukan dalam file BUILD
aturan.
Selain itu, hasilnya mencakup rule-input
dan
elemen rule-output
sehingga topologi jaringan
grafik dependensi dapat direkonstruksi
tanpa harus mengetahui hal itu,
misalnya, elemen dari atribut srcs
dependensi maju (prasyarat) dan isi dari
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 name
, yang nilainya adalah label target, dan
atribut location
yang nilainya adalah
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 defaultnya adalah
diberikan secara eksplisit). Opsi ini menyebabkan nilai atribut tersebut
disertakan dalam output XML.
Ekspresi reguler
Ekspresi reguler dalam bahasa kueri menggunakan pustaka ekspresi reguler Java, jadi Anda dapat menggunakan
sintaks lengkap untuk
java.util.regex.Pattern
Membuat kueri dengan repositori eksternal
Jika build bergantung pada aturan dari repositori eksternal
maka hasil kueri akan
menyertakan dependensi ini. Sebagai
misalnya, jika //foo:bar
bergantung pada @other-repo//baz:lib
, maka
bazel query 'deps(//foo:bar)'
akan mencantumkan @other-repo//baz:lib
sebagai
dependensi.