Referensi Kueri Bazel

Laporkan masalah Lihat sumber Per malam · 7,3 · 7,2 · 7,1 · 7,0 · 6,5

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 Tindakan, Artefak, dan 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:

  • except

  • in

  • intersect

  • let

  • set

  • union

• 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 diwajibkan 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, gunakan hanya 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}.

Kumpulan dan grafik mengacu pada tipe data 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:

• Atribut pribadi
• Persyaratan Toolchain

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 expr₂, dengan semua kemunculan gratis variabel name diganti dengan nilai expr₁.

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)

Penting: Gunakan tanda kurung jika ada bahaya ambiguitas dalam membaca ekspresi kueri.

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 UNIX<i} standar), dan kemudian 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.

Catatan: set() tidak memperkenalkan batasan pengurutan grafik, sehingga informasi jalur mungkin hilang saat menyimpan dan memuat ulang kumpulan node yang menggunakannya. Untuk detail selengkapnya, lihat bagian urutan grafik di bawah.

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)

Catatan: Hanya tersedia dengan Sky Query

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 (tanpa tautan) 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.

Catatan: Upaya naif pada kueri di atas akan menghilangkan operator buildfiles dan hanya menggunakan deps, tetapi hasilnya memberikan hasil yang salah: meskipun hasilnya berisi mayoritas paket yang dibutuhkan, paket-paket yang hanya berisi file yang telah load() akan hilang.

Peringatan: Bazel berpura-pura setiap file .bzl yang dihasilkan oleh buildfiles memiliki target yang sesuai (misalnya, file a/b.bzl => target //a:b.bzl), namun belum tentu demikian. Oleh karena itu, buildfiles tidak dapat ditulis dengan baik dengan operator kueri lain dan hasilnya dapat menyesatkan ketika diformat dengan cara yang terstruktur, seperti --output=xml.

File definisi paket: rbuildfiles

expr ::= rbuildfiles(word, ...)

Catatan: Hanya tersedia dengan Sky Query.

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 rbuildfiles adalah alam semesta yang ditentukan oleh tanda --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.

Peringatan: Bazel berpura-pura bahwa setiap file .bzl ini memiliki target yang sesuai (misalnya, file a/b.bzl => target //a:b.bzl), tetapi ini bukan seharusnya terjadi. Oleh karena itu, loadfiles tidak cocok dengan kueri lain operator dan hasilnya bisa menyesatkan saat diformat dengan cara yang terstruktur, seperti --output=xml.

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.

Catatan: Output peringkat dari kueri somepath adalah pada dasarnya tidak berarti karena somepath tidak menjamin untuk mengembalikan jalur terpendek atau terpanjang, dan mungkin menyertakan "transitif" tepian dari satu {i>node<i} jalur ke {i>node<i} lainnya yang bukan tepi langsung dalam grafik asli.

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.