Referensi Kueri Bazel

7/0.9/2.5. Lihat sumber Nightly {/3/}

Halaman ini adalah panduan referensi untuk Bahasa Kueri Bazel yang digunakan saat Anda menggunakan bazel query untuk menganalisis dependensi build. Kode ini juga menjelaskan format output yang didukung bazel query.

Untuk kasus penggunaan praktis, lihat Cara Kerja Kueri Bazel.

Referensi kueri tambahan

Selain query, yang berjalan pada grafik target fase pasca-pemuatan, Bazel menyertakan kueri grafik tindakan dan kueri yang dapat dikonfigurasi.

Kueri grafik tindakan

Kueri grafik tindakan (aquery) beroperasi pada Grafik Target yang Dikonfigurasi pasca-analisis dan mengekspos informasi tentang Tindakan, Artefak, dan hubungannya. aquery berguna saat Anda tertarik dengan properti Tindakan/Artifacts yang dihasilkan dari Grafik Target yang Dikonfigurasi. Misalnya, perintah aktual dijalankan dan input, output, serta mnemoniknya.

Untuk mengetahui detail selengkapnya, lihat referensi kueri.

Kueri yang dapat dikonfigurasi

Kueri Bazel tradisional berjalan pada grafik target fase pasca-pemuatan, sehingga tidak memiliki konsep konfigurasi dan konsep terkaitnya. Secara khusus, ini tidak menyelesaikan pernyataan pilih dengan benar dan menampilkan semua kemungkinan resolusi pemilihan. Namun, lingkungan kueri yang dapat dikonfigurasi, cquery, menangani konfigurasi dengan benar tetapi tidak menyediakan semua fungsi kueri asli ini.

Untuk mengetahui detail selengkapnya, lihat referensi kueri.

Contoh

Bagaimana cara orang menggunakan bazel query? Berikut adalah contoh umumnya:

Mengapa hierarki //foo bergantung pada //bar/baz? Tampilkan jalur:

somepath(foo/..., //bar/baz:all)

Library C++ apa yang bergantung pada semua pengujian foo dan tidak dimiliki oleh target foo_bin?

kind("cc_library", deps(kind(".*test rule", foo/...)) except deps(//foo:foo_bin))

Token: Sintaks leksikal

Ekspresi dalam bahasa kueri terdiri dari token berikut:

• Kata kunci, seperti let. Kata kunci adalah kata yang dicadangkan dalam bahasa bahasa tersebut, dan setiap katanya dijelaskan di bawah. Kumpulan kata kunci yang lengkap adalah:

  • except

  • in

  • intersect

  • let

  • set

  • union

• Kata, seperti "foo/..." atau ".*test rule" atau "//bar/baz:all". Jika urutan karakter "kutip" (dimulai dan diakhiri dengan tanda kutip tunggal ' atau dimulai dan diakhiri dengan tanda kutip ganda "), kata tersebut adalah kata. Jika urutan karakter tidak dikutip, karakter tersebut mungkin masih diurai sebagai kata. Kata yang tidak dikutip adalah urutan karakter yang digambar dari karakter alfabet A-Za-z, angka 0-9, dan karakter khusus */@.-_:$~[] (tanda bintang, garis miring, at, titik, tanda hubung, garis bawah, titik dua, tanda dolar, tanda gelombang, tanda kurung siku kiri, kurung siku kanan). Namun, kata tanpa tanda kutip tidak boleh diawali dengan tanda hubung - atau tanda bintang * meskipun nama target relatif dapat diawali dengan karakter tersebut.

  Kata yang tidak dikutip juga tidak boleh menyertakan karakter tanda plus + atau sama dengan tanda =, meskipun karakter tersebut diizinkan dalam nama target. Saat menulis kode yang menghasilkan ekspresi kueri, nama target harus diberi tanda kutip.

  Pengutipan diperlukan saat menulis skrip yang membuat ekspresi kueri Bazel dari nilai yang disediakan pengguna.

   //foo:bar+wiz    # WRONG: scanned as //foo:bar + wiz.
   //foo:bar=wiz    # WRONG: scanned as //foo:bar = wiz.
   "//foo:bar+wiz"  # OK.
   "//foo:bar=wiz"  # OK.
  

  Perhatikan bahwa kutipan ini merupakan tambahan untuk pemberian tanda kutip yang mungkin diperlukan oleh shell Anda, seperti:

  bazel query ' "//foo:bar=wiz" '   # single-quotes for shell, double-quotes for Bazel.
  

  Kata kunci dan operator, jika dikutip, diperlakukan sebagai kata biasa. Misalnya, some adalah kata kunci, tetapi "beberapa" adalah kata. foo dan "foo" adalah kata.

  Namun, berhati-hatilah saat menggunakan tanda kutip tunggal atau ganda dalam nama target. Saat mengutip satu atau beberapa nama target, hanya gunakan satu jenis tanda kutip (baik semua tanda kutip tunggal maupun ganda).

  Berikut adalah contoh dari string kueri Java yang akan menjadi:

    'a"'a'         # WRONG: Error message: unclosed quotation.
    "a'"a"         # WRONG: Error message: unclosed quotation.
    '"a" + 'a''    # WRONG: Error message: unexpected token 'a' after query expression '"a" + '
    "'a' + "a""    # WRONG: Error message: unexpected token 'a' after query expression ''a' + '
    "a'a"          # OK.
    'a"a'          # OK.
    '"a" + "a"'    # OK
    "'a' + 'a'"    # OK
  

  Kami memilih {i>syntax<i} ini sehingga tanda kutip tidak diperlukan dalam kebanyakan kasus. Contoh ".*test rule" (yang tidak biasa) memerlukan tanda kutip: contoh ini diawali dengan titik dan berisi spasi. Mengutip "cc_library" tidak diperlukan, tetapi tidak berbahaya.

• Tanda baca, seperti tanda kurung (), titik ., dan koma ,. Kata 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 setara dengan, grafik (DAG) target. Ini adalah satu-satunya {i>datatype<i}.

Kumpulan dan grafik merujuk pada tipe data yang sama, tetapi menekankan aspek yang berbeda, misalnya:

• Tetapkan: Urutan sebagian target tidak menarik.
• Grafik: Urutan sebagian target bersifat signifikan.

Siklus dalam grafik dependensi

Grafik dependensi build harus asiklik.

Algoritma yang digunakan oleh bahasa kueri dimaksudkan untuk digunakan dalam grafik asiklik, tetapi tahan terhadap siklus. Detail tentang cara perlakuan siklus tidak ditentukan dan tidak boleh diandalkan.

Dependensi implisit

Selain dependensi build yang ditentukan secara eksplisit dalam file BUILD, Bazel juga menambahkan dependensi implisit tambahan ke aturan. Dependensi implisit dapat ditentukan 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.

Perlu diperhatikan bahwa, karena kueri tidak mempertimbangkan konfigurasi, implementasi toolchain potensial tidak dianggap sebagai dependensi, melainkan hanya jenis toolchain yang diperlukan. Lihat dokumentasi toolchain.

Tingkat kesehatan

Ekspresi bahasa kueri Bazel beroperasi pada grafik dependensi build, yang merupakan grafik yang ditentukan secara implisit oleh semua deklarasi aturan di semua file BUILD. Penting untuk dipahami bahwa grafik ini agak abstrak, dan bukan merupakan deskripsi lengkap tentang cara menjalankan semua langkah build. Agar dapat menjalankan build, konfigurasi juga diperlukan; lihat bagian konfigurasi dalam Panduan Pengguna untuk mengetahui detail selengkapnya.

Hasil evaluasi ekspresi dalam bahasa kueri Bazel adalah benar untuk semua konfigurasi, yang berarti ekspresi tersebut mungkin merupakan perkiraan berlebihan yang konservatif, dan tidak sepenuhnya akurat. Jika Anda menggunakan alat kueri untuk menghitung kumpulan semua file sumber yang diperlukan selama proses build, alat ini mungkin melaporkan lebih banyak data daripada yang sebenarnya diperlukan karena, misalnya, alat kueri akan menyertakan semua file yang diperlukan untuk mendukung penerjemahan pesan, meskipun Anda tidak bermaksud menggunakan fitur tersebut dalam build.

Tentang mempertahankan urutan grafik

Operasi mempertahankan setiap batasan pengurutan yang diwarisi dari subekspresinya. Anda bisa menganggap ini sebagai "hukum kekekalan urutan parsial". Pertimbangkan sebuah contoh: jika Anda mengeluarkan kueri untuk menentukan penutupan transitif dependensi target tertentu, kumpulan yang dihasilkan akan diurutkan sesuai dengan grafik dependensi. Jika Anda memfilter yang ditetapkan agar hanya menyertakan target dari jenis file, hubungan pengurutan parsial transitif yang sama akan berlaku di antara setiap pasangan target dalam subset yang dihasilkan, meskipun tidak ada pasangan ini yang benar-benar terhubung langsung dalam grafik asli. (Tidak ada tepi file-file dalam grafik dependensi build).

Namun, meskipun semua operator mempertahankan urutan, beberapa operasi, seperti operasi yang ditetapkan tidak memperkenalkan batasan pengurutannya sendiri. Pertimbangkan ekspresi ini:

deps(x) union y

Urutan kumpulan hasil akhir dijamin akan mempertahankan semua batasan pengurutan subekspresinya, yaitu, bahwa semua dependensi transitif x diurutkan dengan benar terkait satu sama lain. Namun, kueri tersebut tidak menjamin apa pun terkait urutan target di y, atau tentang pengurutan target di deps(x) yang terkait dengan yang ada di y (kecuali untuk target dalam y yang juga terjadi di deps(x)).

Operator yang menerapkan batasan pengurutan mencakup: 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 ini beroperasi di seluruh cakupan semesta (itulah mengapa fungsi ini tidak masuk akal untuk Kueri normal).

Menentukan cakupan semesta

Mode Sky Query diaktifkan dengan meneruskan dua flag berikut: (--universe_scope atau --infer_universe_scope) dan --order_output=no. --universe_scope=<target_pattern1>,...,<target_patternN> memberi tahu kueri untuk melakukan pramuat penutupan transitif pola target yang ditentukan oleh pola target, yang dapat berupa aditif dan subtraktif. Semua kueri kemudian dievaluasi dalam "cakupan" ini. Secara khusus, operator allrdeps dan rbuildfiles hanya menampilkan hasil dari cakupan ini. --infer_universe_scope memberi tahu Bazel untuk menyimpulkan nilai --universe_scope dari ekspresi kueri. Nilai yang disimpulkan ini adalah daftar pola target unik dalam ekspresi kueri, tetapi ini mungkin bukan yang Anda inginkan. Contoh:

bazel query --infer_universe_scope --order_output=no "allrdeps(//my:target)"

Daftar pola target unik dalam ekspresi kueri ini adalah ["//my:target"], sehingga Bazel memperlakukannya sama seperti panggilan:

bazel query --universe_scope=//my:target --order_output=no "allrdeps(//my:target)"

Namun, hasil kueri dengan --universe_scope tersebut hanyalah //my:target; tidak satu pun dari dependensi terbalik //my:target yang ada di alam semesta, berdasarkan konstruksi. Di sisi lain, pertimbangkan:

bazel query --infer_universe_scope --order_output=no "tests(//a/... + b/...) intersect allrdeps(siblings(rbuildfiles(my/starlark/file.bzl)))"

Ini adalah pemanggilan kueri penting yang mencoba menghitung target pengujian dalam perluasan tests target pada beberapa direktori yang bergantung secara transitif pada target yang definisinya menggunakan file .bzl tertentu. Di sini, --infer_universe_scope adalah kenyamanan, terutama jika pilihan --universe_scope mengharuskan Anda untuk mengurai ekspresi kueri sendiri.

Jadi, untuk ekspresi kueri yang menggunakan operator cakupan alam semesta seperti allrdeps dan rbuildfiles, pastikan Anda menggunakan --infer_universe_scope hanya jika perilakunya sesuai dengan yang Anda inginkan.

Sky Query memiliki beberapa kelebihan dan kekurangan dibandingkan dengan kueri default. Kekurangan utamanya adalah tidak dapat mengurutkan output-nya sesuai dengan urutan grafik, sehingga format output tertentu dilarang. Kelebihannya adalah menyediakan dua operator (allrdeps dan rbuildfiles) yang tidak tersedia di kueri default. Selain itu, Sky Query melakukan tugasnya dengan memasukkan grafik Skyframe, bukan membuat grafik baru, yang merupakan fungsi implementasi default. Dengan demikian, ada beberapa situasi saat proses ini lebih cepat dan menggunakan lebih sedikit memori.

Ekspresi: Sintaksis dan semantik tata bahasa

Ini adalah tata bahasa dari bahasa kueri Bazel, yang dinyatakan dalam notasi EBNF:

expr ::= word
       | let name = expr in expr
       | (expr)
       | expr intersect expr
       | expr ^ expr
       | expr union expr
       | expr + expr
       | expr except expr
       | expr - expr
       | set(word *)
       | word '(' int | word | expr ... ')'

Bagian berikut menjelaskan setiap produksi tata bahasa ini secara berurutan.

Pola target

expr ::= word

Secara sintaksis, pola target hanyalah sebuah kata. Ini ditafsirkan sebagai kumpulan target (tidak berurutan). Pola target yang paling sederhana adalah label, yang mengidentifikasi satu target (file atau aturan). Misalnya, pola target //foo:bar mengevaluasi ke set yang berisi satu elemen, yaitu target, aturan bar.

Pola target menggeneralisasi label untuk menyertakan karakter pengganti di atas paket dan target. Misalnya, foo/...:all (atau hanya foo/...) adalah pola target yang dievaluasi ke set yang berisi semua aturan di setiap paket secara rekursif di bawah direktori foo; bar/baz:all adalah pola target yang dievaluasi ke set yang berisi semua aturan dalam paket bar/baz, tetapi bukan sub-paketnya.

Demikian pula, foo/...:* adalah pola target yang dievaluasi ke set 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 dalam paket bar/baz, tetapi bukan sub-paketnya.

Karena karakter pengganti :* cocok dengan file serta aturan, karakter pengganti ini sering kali lebih berguna daripada :all untuk kueri. Sebaliknya, karakter pengganti :all (implisit dalam pola target seperti foo/...) biasanya lebih berguna untuk build.

Pola target bazel query berfungsi sama seperti target build bazel build. Untuk mengetahui detail selengkapnya, lihat Pola Target, atau ketik bazel help target-syntax.

Pola target dapat mengevaluasi ke kumpulan singleton (dalam kasus label), ke kumpulan yang berisi banyak elemen (seperti dalam kasus foo/..., yang memiliki ribuan elemen), atau ke kumpulan kosong, jika pola target tidak cocok dengan target apa pun.

Semua node dalam hasil ekspresi pola target diurutkan dengan benar relatif satu sama lain sesuai dengan hubungan dependensi. Jadi, hasil foo:* bukan hanya kumpulan target dalam paket foo, tetapi juga grafik pada target tersebut. (Tidak ada jaminan terkait pengurutan relatif node hasil terhadap node lain.) Untuk detail selengkapnya, lihat bagian urutan grafik.

Variabel

expr ::= let name = expr1 in expr2
       | $name

Bahasa kueri Bazel memungkinkan definisi dan referensi ke variabel. Hasil evaluasi ekspresi let sama dengan expr₂, dengan semua kemunculan bebas variabel name diganti dengan nilai expr₁.

Misalnya, let v = foo/... in allpaths($v, //common) intersect $v setara dengan allpaths(foo/...,//common) intersect foo/....

Kejadian referensi variabel name selain dalam ekspresi let name = ... yang mencakup adalah error. Dengan kata lain, ekspresi kueri tingkat atas tidak boleh memiliki variabel bebas.

Dalam produksi tata bahasa di atas, name mirip dengan kata, tetapi dengan batasan tambahan sebagai ID resmi dalam bahasa pemrograman C. Referensi ke variabel harus diawali dengan karakter "$".

Setiap ekspresi let hanya menentukan satu variabel, tetapi Anda dapat menyusunnya bertingkat.

pola target dan referensi variabel hanya terdiri dari satu token, sebuah kata, sehingga menciptakan ambiguitas sintaksis. Namun, tidak ada ambiguitas semantik karena subset kata yang merupakan nama variabel hukum terpisah dari subset kata yang merupakan pola target hukum.

Secara teknis, ekspresi let tidak meningkatkan ekspresi bahasa kueri: kueri apa pun yang dapat diekspresikan dalam bahasa juga dapat dinyatakan tanpa ekspresi tersebut. Namun, cara ini akan meningkatkan keringkasan banyak kueri, dan juga dapat menghasilkan evaluasi kueri yang lebih efisien.

Ekspresi dalam tanda kurung

expr ::= (expr)

Tanda kurung mengaitkan subekspresi untuk memaksa urutan evaluasi. Ekspresi dalam tanda kurung 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 bentuk ini setara; bentuk simbolis lebih cepat diketik. (Agar lebih jelas, bagian lain dari halaman ini menggunakan bentuk nominal.)

Misalnya,

foo/... except foo/bar/...

mengevaluasi ke kumpulan target yang cocok dengan foo/..., tetapi tidak cocok dengan foo/bar/....

Anda dapat menulis kueri yang sama 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, sehingga Anda perlu menggunakan tanda kurung. Misalnya, dua ekspresi pertama adalah setara, tetapi yang ketiga tidak:

x intersect y union z
(x intersect y) union z
x intersect (y union z)

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

Membaca target dari sumber eksternal: ditetapkan

expr ::= set(word *)

Operator set(a b c ...) menghitung gabungan kumpulan nol atau beberapa pola target, yang dipisahkan oleh spasi kosong (tanpa koma).

Bersama dengan fitur $(...) shell Bourne, set() menyediakan cara untuk menyimpan hasil satu kueri dalam file teks biasa, memanipulasi file teks tersebut menggunakan program lain (seperti alat shell UNIX standar), lalu memperkenalkan hasilnya kembali ke alat kueri sebagai nilai untuk pemrosesan lebih lanjut. Contoh:

bazel query deps(//my:target) --output=label | grep ... | sed ... | awk ... > foo
bazel query "kind(cc_binary, set($(<foo)))"

Pada contoh berikutnya,kind(cc_library, deps(//some_dir/foo:main, 5)) dihitung dengan memfilter nilai maxrank menggunakan program awk.

bazel query 'deps(//some_dir/foo:main)' --output maxrank | awk '($1 < 5) { print $2;} ' > foo
bazel query "kind(cc_library, set($(<foo)))"

Dalam contoh ini, $(<foo) adalah singkatan untuk $(cat foo), tetapi perintah shell selain cat dapat digunakan juga—seperti perintah awk sebelumnya.

Catatan: set() tidak memperkenalkan batasan pengurutan grafik, sehingga informasi jalur dapat 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 fungsi menentukan jumlah dan jenis argumen yang diperlukan. Fungsi berikut tersedia:

• allpaths
• attr
• buildfiles
• rbuildfiles
• deps
• filter
• kind
• labels
• loadfiles
• rdeps
• allrdeps
• same_pkg_direct_rdeps
• siblings
• some
• somepath
• tests
• visible

Penutupan transitif dependensi: dependensi

expr ::= deps(expr)
       | deps(expr, depth)

Operator deps(x) mengevaluasi ke grafik yang dibentuk oleh penutupan transitif dependensi kumpulan argumennya x. Misalnya, nilai deps(//foo) adalah grafik dependensi yang di-root pada foo node tunggal, termasuk semua dependensinya. Nilai deps(foo/...) adalah grafik dependensi yang root-nya adalah semua aturan di setiap paket di bawah direktori foo. Dalam konteks ini, 'dependensi' hanya berarti target aturan dan file, sehingga file BUILD dan Starlark yang diperlukan untuk membuat target tersebut tidak disertakan di sini. Untuk itu, Anda harus menggunakan operator buildfiles.

Grafik yang dihasilkan diurutkan sesuai dengan relasi ketergantungan. Untuk mengetahui detail selengkapnya, lihat bagian urutan grafik.

Operator deps menerima argumen kedua opsional, yang merupakan literal bilangan bulat yang menentukan batas atas pada kedalaman penelusuran. Jadi, deps(foo:*, 0) menampilkan semua target dalam paket foo, sedangkan deps(foo:*, 1) lebih lanjut menyertakan prasyarat langsung dari target apa pun dalam paket foo, dan deps(foo:*, 2) lebih lanjut menyertakan node yang dapat dijangkau langsung dari node di deps(foo:*, 1), dan seterusnya. (Angka ini sesuai dengan peringkat yang ditampilkan dalam format output minrank.) Jika parameter depth dihilangkan, penelusuran tidak dibatasi: penghitungan ini menghitung penutupan transitif refleksif untuk prasyarat.

Penutupan transitif dependensi terbalik: rdeps

expr ::= rdeps(expr, expr)
       | rdeps(expr, expr, depth)

Operator rdeps(u, x) mengevaluasi dependensi terbalik dari kumpulan argumen x dalam penutupan transitif kumpulan alam semesta u.

Grafik yang dihasilkan diurutkan sesuai dengan relasi ketergantungan. Lihat bagian urutan grafik untuk detail selengkapnya.

Operator rdeps menerima argumen ketiga opsional, yang merupakan literal bilangan bulat yang menentukan batas atas pada kedalaman penelusuran. Grafik yang dihasilkan hanya menyertakan node dalam jarak kedalaman yang ditentukan dari node mana pun dalam kumpulan argumen. Jadi, rdeps(//foo, //common, 1) mengevaluasi ke semua node dalam penutupan transitif //foo yang bergantung langsung pada //common. (Angka ini sesuai dengan peringkat yang ditampilkan dalam format output minrank.) Jika parameter depth dihilangkan, penelusuran tidak dibatasi.

Penutupan transitif semua dependensi terbalik: allrdeps

expr ::= allrdeps(expr)
       | allrdeps(expr, depth)

Catatan: Hanya tersedia dengan Sky Query

Operator allrdeps berperilaku seperti operator rdeps, kecuali bahwa "universe set" adalah apa pun yang dievaluasi oleh flag --universe_scope, bukan ditentukan secara terpisah. Jadi, jika --universe_scope=//foo/... diteruskan, allrdeps(//bar) setara dengan rdeps(//foo/..., //bar).

Dependensi balik langsung dalam paket yang sama: same_pkg_direct_rdeps

expr ::= same_pkg_direct_rdeps(expr)

Operator same_pkg_direct_rdeps(x) mengevaluasi ke kumpulan lengkap target yang ada dalam paket yang sama dengan target dalam kumpulan argumen, dan yang bergantung langsung padanya.

Menangani paket target: saudara

expr ::= siblings(expr)

Operator siblings(x) mengevaluasi ke kumpulan target lengkap yang ada dalam paket yang sama sebagai target dalam kumpulan argumen.

Pilihan arbitrer: beberapa

expr ::= some(expr)
       | some(expr, count )

Operator some(x, k) memilih maksimum k target secara arbitrer dari kumpulan argumen x, dan mengevaluasi ke set yang hanya berisi target tersebut. Parameter k bersifat opsional; jika tidak ada, hasilnya adalah kumpulan singleton yang hanya berisi satu target yang dipilih secara acak. Jika ukuran kumpulan argumen x lebih kecil dari k, seluruh kumpulan argumen x akan ditampilkan.

Misalnya, ekspresi some(//foo:main union //bar:baz) dievaluasi ke kumpulan singleton yang berisi //foo:main atau //bar:baz—meskipun belum ditentukan. Ekspresi some(//foo:main union //bar:baz, 2) atau some(//foo:main union //bar:baz, 3) menampilkan //foo:main dan //bar:baz.

Jika argumennya adalah singleton, some akan menghitung fungsi identitas: some(//foo:main) setara dengan //foo:main.

Error jika kumpulan argumen yang ditentukan kosong, seperti dalam ekspresi some(//foo:main intersect //bar:baz).

Operator jalur: somepath, allpaths

expr ::= somepath(expr, expr)
       | allpaths(expr, expr)

Operator somepath(S, E) dan allpaths(S, E) menghitung jalur di antara dua kumpulan target. Kedua kueri menerima dua argumen, satu S titik awal dan satu kumpulan E titik akhir. somepath menampilkan grafik node di beberapa jalur arbitrer dari target di S ke target di E; allpaths menampilkan grafik node di semua jalur dari semua target di 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)

Operator kind(pattern, input) menerapkan filter ke kumpulan target, dan menghapus target yang bukan jenis yang diharapkan. Parameter pattern menentukan jenis target yang akan dicocokkan.

Misalnya, jenis untuk empat target yang ditentukan oleh file BUILD (untuk paket p) yang ditampilkan di bawah diilustrasikan dalam tabel:

Kode	Target	Jenis
genrule( name = "a", srcs = ["a.in"], outs = ["a.out"], cmd = "...", )	//p:a	aturan genrule
	//p:a.in	file sumber
	//p:a.out	file yang dibuat
	//p:BUILD	file sumber

Dengan demikian, kind("cc_.* rule", foo/...) mengevaluasi ke kumpulan semua cc_library, cc_binary, dll., target aturan di bawah foo, dan kind("source file", deps(//foo)) bernilai 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)

Operator filter(pattern, input) menerapkan filter ke sekumpulan target dan menghapus target yang labelnya (dalam bentuk absolut) tidak cocok dengan pola. Operator ini melakukan evaluasi ke subset inputnya.

Argumen pertama, pattern adalah kata yang berisi ekspresi reguler di atas nama target. Ekspresi filter dievaluasi ke kumpulan yang berisi semua target x sehingga x adalah anggota dari kumpulan input dan label (dalam bentuk absolut, seperti //foo:bar) dari x berisi kecocokan (tanpa tautan) untuk ekspresi reguler pattern. Karena semua nama target diawali dengan //, nama ini dapat digunakan sebagai alternatif untuk anchor ekspresi reguler ^.

Operator ini sering memberikan alternatif yang jauh lebih cepat dan lebih tangguh untuk operator intersect. Misalnya, untuk melihat semua dependensi bar dari target //foo:foo, kita dapat mengevaluasi

deps(//foo) intersect //bar/...

Namun, pernyataan ini akan memerlukan penguraian semua file BUILD di hierarki bar, yang akan lambat dan rentan terhadap error dalam file BUILD yang tidak relevan. Alternatifnya adalah:

filter(//bar, deps(//foo))

yang terlebih dahulu menghitung kumpulan dependensi //foo, lalu hanya memfilter target yang cocok dengan pola yang diberikan—dengan kata lain, target dengan nama yang berisi //bar sebagai substring.

Penggunaan umum lainnya dari operator filter(pattern, expr) adalah memfilter file tertentu berdasarkan nama atau ekstensinya. Misalnya,

filter("\.cc$", deps(//foo))

akan memberikan daftar semua file .cc yang digunakan untuk membangun //foo.

Pemfilteran atribut aturan: attr

expr ::= attr(word, word, expr)

Operator attr(name, pattern, input) menerapkan filter ke sekumpulan target, dan menghapus target yang bukan aturan, target aturan yang tidak memiliki atribut yang ditetapkan name, atau target aturan yang nilai atributnya tidak cocok dengan ekspresi reguler pattern yang diberikan. Operator ini melakukan evaluasi ke subkumpulan inputnya.

Argumen pertama, name adalah nama atribut aturan yang harus dicocokkan dengan pola ekspresi reguler yang disediakan. Argumen kedua, pattern adalah ekspresi reguler di atas nilai atribut. Ekspresi attr dievaluasi ke kumpulan yang berisi semua target x sehingga x adalah anggota kumpulan input, merupakan aturan dengan atribut name yang ditentukan, dan nilai atribut berisi kecocokan (tanpa penempatan) untuk ekspresi reguler pattern. Jika name adalah atribut opsional dan aturan tidak menentukannya secara eksplisit, nilai atribut default akan digunakan untuk perbandingan. Misalnya,

attr(linkshared, 0, deps(//foo))

akan memilih semua dependensi //foo yang diizinkan untuk memiliki atribut linkshared (seperti, aturan cc_binary) dan menetapkannya secara eksplisit ke 0 atau tidak menetapkannya sama sekali, tetapi nilai defaultnya adalah 0 (misalnya untuk aturan cc_binary).

Atribut jenis daftar (seperti srcs, data, dll.) dikonversi menjadi string bentuk [value<sub>1</sub>, ..., value<sub>n</sub>], dimulai dengan tanda kurung [, diakhiri dengan tanda kurung ] dan menggunakan "," (koma, spasi) untuk membatasi beberapa nilai. Label dikonversi menjadi string dengan menggunakan bentuk absolut dari label. Misalnya, atribut deps=[":foo", "//otherpkg:bar", "wiz"] akan dikonversi menjadi string [//thispkg:foo, //otherpkg:bar, //thispkg:wiz]. Tanda kurung selalu ada, sehingga daftar kosong akan menggunakan nilai string [] untuk tujuan pencocokan. Misalnya,

attr("srcs", "\[\]", deps(//foo))

akan memilih semua aturan di antara dependensi //foo yang memiliki atribut srcs kosong, sedangkan

attr("data", ".{3,}", deps(//foo))

akan memilih semua aturan di antara dependensi //foo yang menentukan setidaknya satu nilai dalam atribut data (panjang setiap label minimal 3 karakter karena // dan :).

Untuk memilih semua aturan di antara dependensi //foo dengan value tertentu dalam atribut jenis daftar, gunakan

attr("tags", "[\[ ]value[,\]]", deps(//foo))

Ini berfungsi karena karakter sebelum value akan 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 sekumpulan target, dan menghapus target tanpa visibilitas yang diperlukan.

Argumen pertama, predicate, adalah kumpulan target yang harus terlihat oleh semua target dalam output. Ekspresi visible dievaluasi ke kumpulan yang berisi semua target x sehingga x adalah anggota dari input yang ditetapkan, dan untuk semua target y di predicate x dapat dilihat oleh y. Contoh:

visible(//foo, //bar:*)

akan memilih semua target dalam paket //bar yang dapat diandalkan oleh //foo tanpa melanggar batasan visibilitas.

Evaluasi atribut aturan label jenis: label

expr ::= labels(word, expr)

Operator labels(attr_name, inputs) menampilkan kumpulan target yang ditentukan dalam atribut attr_name dari jenis "label" atau "daftar label" dalam beberapa aturan di kumpulan inputs.

Misalnya, labels(srcs, //foo) menampilkan kumpulan target yang muncul dalam atribut srcs aturan //foo. Jika ada beberapa aturan dengan atribut srcs dalam kumpulan inputs, gabungan dari srcs-nya akan ditampilkan.

Meluaskan dan memfilter test_suites: pengujian

expr ::= tests(expr)

Operator tests(x) menampilkan kumpulan semua aturan pengujian dalam x kumpulan, yang memperluas aturan test_suite ke sekumpulan pengujian individual yang dirujuk, dan menerapkan pemfilteran menurut tag dan size.

Secara default, evaluasi kueri mengabaikan target non-pengujian di semua aturan test_suite. Error ini dapat diubah menjadi error dengan opsi --strict_test_suite.

Misalnya, kueri kind(test, foo:*) mencantumkan semua aturan *_test dan test_suite dalam paket foo. Semua hasil adalah anggota (berdasarkan definisi) dari paket foo. Sebaliknya, kueri tests(foo:*) akan menampilkan semua pengujian individual yang akan dijalankan oleh bazel test foo:*: ini dapat mencakup pengujian yang termasuk dalam paket lain, yang direferensikan secara langsung atau tidak langsung melalui aturan test_suite.

File definisi paket: buildfiles

expr ::= buildfiles(expr)

Operator buildfiles(x) menampilkan kumpulan file yang menentukan paket setiap target dalam kumpulan x; dengan kata lain, untuk setiap paket, file BUILD-nya, plus file .bzl apa pun yang direferensikan melalui load. Perhatikan bahwa tindakan ini juga akan menampilkan file BUILD dari paket yang berisi file load ini.

Operator ini biasanya digunakan saat menentukan file atau paket yang diperlukan untuk membuat target yang ditentukan, sering kali bersama dengan opsi --output package, di bawah). Misalnya,

bazel query 'buildfiles(deps(//foo))' --output package

menampilkan kumpulan semua paket yang menjadi dependensi //foo secara transitif.

Catatan: Upaya naif pada kueri di atas akan menghilangkan operator buildfiles dan hanya menggunakan deps, tetapi ini memberikan hasil yang salah: meskipun hasilnya berisi sebagian besar paket yang diperlukan, paket yang hanya berisi file yang memiliki load() akan hilang.

Peringatan: Bazel berpura-pura setiap file .bzl yang dihasilkan oleh buildfiles memiliki target yang sesuai (misalnya/target.2}, file {target.2}a/b.bzl//a:b.bzl Oleh karena itu, buildfiles tidak cocok dengan operator kueri lain dan hasilnya dapat menyesatkan saat 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 bergantung secara transitif pada fragmen jalur ini. Misalnya, jika //foo adalah sebuah paket, rbuildfiles(foo/BUILD) akan menampilkan target //foo:BUILD. Jika file foo/BUILD memiliki load('//bar:file.bzl'... di dalamnya, rbuildfiles(bar/file.bzl) akan menampilkan target //foo:BUILD, serta target untuk file BUILD lainnya yang memuat //bar:file.bzl

Cakupan operator rbuildfiles adalah alam semesta yang ditentukan oleh flag --universe_scope. File yang tidak berkaitan langsung dengan file BUILD dan file .bzl tidak akan memengaruhi hasil. Misalnya, file sumber (seperti foo.cc) diabaikan, meskipun file tersebut disebutkan secara eksplisit dalam file BUILD. Namun, Symlink dipatuhi sehingga jika foo/BUILD adalah symlink ke bar/BUILD, rbuildfiles(bar/BUILD) akan menyertakan //foo:BUILD dalam hasilnya.

Operator rbuildfiles secara moral hampir merupakan kebalikan dari operator buildfiles. Namun, inversi moral ini bertahan lebih kuat dalam satu arah: output rbuildfiles sama seperti input buildfiles; yang pertama hanya akan berisi target file BUILD dalam paket, dan yang kedua dapat berisi target tersebut. Di arah lain, korespondensi akan lebih lemah. Output operator buildfiles adalah target yang sesuai dengan semua paket dan .File bzl yang dibutuhkan oleh input tertentu. Namun, input operator rbuildfiles bukanlah target tersebut, melainkan fragmen jalur yang sesuai dengan target tersebut.

File definisi paket: loadfile

expr ::= loadfiles(expr)

Operator loadfiles(x) menampilkan kumpulan file Starlark yang diperlukan untuk memuat paket setiap target dalam kumpulan x. Dengan kata lain, untuk setiap paket, sistem akan menampilkan 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 hal ini belum tentu terjadi. Oleh karena itu, loadfiles tidak dapat ditulis dengan baik dengan operator kueri lain dan hasilnya dapat menyesatkan saat diformat dengan cara yang terstruktur, seperti --output=xml.

Format output

bazel query membuat grafik. Anda menentukan konten, format, dan pengurutan yang digunakan bazel query menyajikan grafik ini melalui opsi command line --output.

Saat dijalankan dengan Sky Query, hanya format output yang kompatibel dengan output yang tidak berurutan yang diizinkan. Secara khusus, format output graph, minrank, dan maxrank dilarang.

Beberapa format output menerima opsi tambahan. Nama setiap opsi output diawali dengan format output yang berlaku, sehingga --graph:factored hanya berlaku jika --output=graph sedang digunakan; dan tidak berpengaruh jika format output selain graph digunakan. Demikian pula, --xml:line_numbers hanya berlaku jika --output=xml sedang digunakan.

Pada urutan hasil

Meskipun ekspresi kueri selalu mengikuti "hukum kekekalan urutan grafik", presentasi hasilnya dapat dilakukan dengan cara yang berurutan atau tidak berurutan. Hal ini tidak memengaruhi target dalam kumpulan hasil atau cara kueri dihitung. Hal ini hanya memengaruhi cara hasil dicetak ke stdout. Selain itu, node yang setara dalam urutan dependensi mungkin atau mungkin tidak diurutkan menurut abjad. Flag --order_output dapat digunakan untuk mengontrol perilaku ini. (Flag --[no]order_results memiliki subset fungsi flag --order_output dan tidak digunakan lagi.)

Nilai default flag ini adalah auto, yang mencetak hasil dalam urutan leksikografis. Namun, jika somepath(a,b) digunakan, hasilnya akan dicetak dalam urutan deps.

Jika tanda ini adalah no dan --output adalah salah satu dari build, label, label_kind, location, package, proto, atau xml, output akan dicetak dalam urutan arbitrer. Umumnya, ini adalah opsi tercepat. Namun, hal ini tidak didukung jika --output adalah salah satu dari graph, minrank, atau maxrank: dengan format ini, Bazel selalu mencetak hasil yang diurutkan berdasarkan urutan atau peringkat dependensi.

Jika flag ini adalah deps, Bazel akan mencetak hasil dalam urutan topologis—yaitu, dependensi terlebih dahulu dan dependensi setelahnya. Namun, node yang tidak diurutkan menurut urutan dependensi (karena tidak ada jalur dari salah satu ke node lainnya) dapat dicetak dalam urutan apa pun.

Jika flag ini adalah full, Bazel akan mencetak node dengan urutan (total) yang sepenuhnya deterministik. Pertama, semua node diurutkan menurut abjad. Kemudian, setiap node dalam daftar akan digunakan sebagai awal penelusuran depth-first pasca-urutan dengan tepi keluar ke node yang tidak dikunjungi dalam urutan abjad dari node pengganti. Terakhir, node dicetak dalam urutan berbalik dari urutan kunjungannya.

Mencetak node dalam urutan ini mungkin lebih lambat, sehingga hanya boleh digunakan jika determinisme penting.

Cetak bentuk sumber target seperti yang akan terlihat di BUILD

--output build

Dengan opsi ini, representasi setiap target seolah-olah ditulis dengan tangan dalam bahasa BUILD. Semua variabel dan panggilan fungsi (seperti glob, makro) diperluas, yang berguna untuk melihat efek makro Starlark. Selain itu, setiap aturan efektif melaporkan nilai generator_name dan/atau generator_function, sehingga memberikan nama makro yang dievaluasi untuk menghasilkan aturan yang efektif.

Meskipun output menggunakan sintaksis yang sama dengan file BUILD, tidak ada jaminan untuk menghasilkan file BUILD yang valid.

Cetak label setiap target

--output label

Dengan opsi ini, kumpulan nama (atau label) setiap target dalam grafik yang dihasilkan akan dicetak, satu label per baris, dalam urutan topologis (kecuali jika --noorder_results ditentukan, lihat catatan tentang urutan hasil). (Pengurutan topologi adalah urutan node grafik muncul lebih awal dari semua penerusnya.) Tentu saja ada banyak kemungkinan pengurutan topologi grafik (postorder terbalik hanyalah satu); urutan mana yang dipilih tidak ditentukan.

Saat mencetak output kueri somepath, urutan pencetakan node adalah urutan jalur.

Peringatan: dalam beberapa kasus sudut, mungkin ada dua target berbeda dengan label yang sama; misalnya, aturan sh_binary dan file srcs tunggal (implisit)-nya dapat disebut foo.sh. Jika hasil kueri berisi kedua target ini, output (dalam format label) akan tampak berisi duplikat. Saat menggunakan format label_kind (lihat di bawah), perbedaannya menjadi jelas: kedua target memiliki nama yang sama, tetapi satu target memiliki jenis sh_binary rule dan jenis lainnya source file.

Cetak label dan jenis setiap target

--output label_kind

Seperti label, format output ini mencetak label setiap target dalam grafik yang dihasilkan, dalam urutan topologis, tetapi juga mendahului label dengan jenis target.

Target cetak dalam format buffering protokol

--output proto

Mencetak output kueri sebagai buffering protokol QueryResult.

Cetak target dalam format buffering protokol yang dibatasi-panjang

--output streamed_proto

Mencetak stream yang dibatasi panjang dari buffer protokol Target. Hal ini berguna untuk (i) mengatasi batasan ukuran buffering protokol jika ada terlalu banyak target untuk dimuat dalam satu QueryResult atau (ii) untuk memulai pemrosesan saat Bazel masih dalam proses output.

Cetak target dalam format proto teks

--output textproto

Serupa dengan --output proto, mencetak buffering protokol QueryResult tetapi dalam format teks.

Cetak target dalam format ndjson

--output streamed_jsonproto

Serupa dengan --output streamed_proto, mencetak aliran data buffering protokol Target tetapi dalam format ndjson.

Cetak label setiap target dalam urutan peringkat

--output minrank --output maxrank

Seperti label, format output minrank dan maxrank mencetak label setiap target dalam grafik yang dihasilkan, tetapi bukannya muncul dalam urutan topologi, format output tersebut muncul dalam urutan peringkat, didahului oleh nomor peringkatnya. Nilai ini tidak terpengaruh oleh flag --[no]order_results pengurutan hasil (lihat catatan tentang urutan hasil).

Ada dua varian format ini: minrank mengurutkan setiap node berdasarkan panjang jalur terpendek dari node root ke node root. Node "root" (yang tidak memiliki tepi masuk) berasal dari peringkat 0, penggantinya berperingkat 1, dst. (Seperti biasa, node mengarah dari target ke prasyaratnya: target yang menjadi dependensinya.)

maxrank mengurutkan setiap node berdasarkan panjang jalur terpanjang dari node root ke node tersebut. Sekali lagi, "root" memiliki peringkat 0, semua node lainnya memiliki peringkat yang satu lebih besar dari peringkat maksimum semua pendahulunya.

Semua node dalam siklus dianggap memiliki peringkat yang sama. (Sebagian besar grafik bersifat asiklik, tetapi siklus memang terjadi hanya karena file BUILD berisi siklus yang salah.)

Format output ini berguna untuk mengetahui seberapa dalam grafik. Jika digunakan untuk hasil kueri deps(x), rdeps(x), atau allpaths, maka nomor peringkat sama dengan panjang jalur terpendek (dengan minrank) atau terpanjang (dengan maxrank) dari x ke node pada peringkat tersebut. maxrank dapat digunakan untuk menentukan urutan langkah build terpanjang yang diperlukan untuk mem-build target.

Catatan: Output yang diberi peringkat dari kueri somepath pada dasarnya tidak bermakna karena somepath tidak menjamin untuk menampilkan jalur terpendek atau terpanjang, dan mungkin menyertakan tepi "transitif" dari satu node jalur ke node jalur lainnya yang bukan tepi langsung dalam grafik asli.

Misalnya, grafik di sebelah kiri menghasilkan output di sebelah kanan jika --output minrank dan --output maxrank ditentukan.

minrank 0 //c:c 1 //b:b 1 //a:a 2 //b:b.cc 2 //a:a.cc

maxrank 0 //c:c 1 //b:b 2 //a:a 2 //b:b.cc 3 //a:a.cc

Cetak lokasi setiap target

--output location

Seperti label_kind, opsi ini mencetak, untuk setiap target dalam hasil, jenis dan label target, tetapi diawali oleh string yang menjelaskan lokasi target tersebut, sebagai nama file dan nomor baris. Formatnya menyerupai output grep. Dengan demikian, alat yang dapat mengurai yang terakhir ini (seperti Emacs atau vi) juga dapat menggunakan output kueri untuk menelusuri serangkaian kecocokan, yang memungkinkan alat kueri Bazel digunakan sebagai "grep for BUILD" yang berbasis grafik dependensi.

Informasi lokasi bervariasi menurut jenis target (lihat operator jenis). Untuk aturan, lokasi deklarasi aturan dalam file BUILD akan dicetak. Untuk file sumber, lokasi baris 1 file aktual akan dicetak. Untuk file yang dihasilkan, lokasi aturan yang menghasilkan file tersebut akan dicetak. (Alat kueri tidak memiliki informasi yang memadai untuk menemukan lokasi sebenarnya dari file yang dihasilkan, dan dalam kasus apa pun, mungkin tidak ada jika build belum dijalankan.)

Mencetak kumpulan paket

--output package

Opsi ini mencetak nama semua paket yang memiliki beberapa target dalam kumpulan hasil. Nama dicetak dalam urutan leksikografis; duplikat akan dikecualikan. Secara formal, ini adalah proyeksi dari kumpulan label (paket, target) ke paket.

Paket dalam repositori eksternal diformat sebagai @repo//foo/bar, sedangkan paket di repositori utama diformat sebagai foo/bar.

Bersama dengan kueri deps(...), opsi output ini dapat digunakan untuk menemukan kumpulan paket yang harus diperiksa untuk membangun kumpulan target tertentu.

Menampilkan grafik hasil

--output graph

Opsi ini menyebabkan hasil kueri dicetak sebagai grafik terarah dalam format AT&T GraphViz yang populer. Biasanya, hasilnya disimpan ke file, seperti .png atau .svg. (Jika program dot tidak diinstal di workstation, Anda dapat menginstalnya menggunakan perintah sudo apt-get install graphviz.) Lihat contoh bagian di bawah untuk contoh panggilan.

Format output ini sangat berguna untuk kueri allpaths, deps, atau rdeps, yang hasilnya menyertakan set jalur yang tidak dapat divisualisasikan dengan mudah saat dirender dalam bentuk linear, seperti dengan --output label.

Secara default, grafik dirender dalam bentuk yang difaktorkan. Artinya, node yang setara secara topologis digabungkan menjadi satu node dengan beberapa label. Hal ini akan membuat grafik lebih ringkas dan mudah dibaca karena grafik hasil standar berisi pola yang sangat berulang. Misalnya, aturan java_library mungkin bergantung pada ratusan file sumber Java yang semuanya dihasilkan oleh genrule yang sama; dalam grafik terfaktorkan, semua file ini direpresentasikan oleh satu node. Perilaku ini dapat dinonaktifkan dengan opsi --nograph:factored.

--graph:node_limit n

Opsi ini menentukan panjang maksimum string label untuk node grafik dalam output. Label yang lebih panjang akan dipotong; -1 menonaktifkan pemotongan. Karena bentuk faktor yang biasanya digunakan untuk mencetak, label node mungkin sangat panjang. GraphViz tidak dapat menangani label yang melebihi 1.024 karakter, yang merupakan nilai default dari opsi ini. Opsi ini tidak akan berpengaruh kecuali jika --output=graph 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 oleh alat lain (seperti grep). Opsi ini tidak akan berpengaruh kecuali jika --output=graph digunakan.

XML

--output xml

Opsi ini menyebabkan target yang dihasilkan dicetak dalam bentuk XML. Outputnya dimulai dengan header XML seperti ini

  <?xml version="1.0" encoding="UTF-8"?>
  <query version="2">

lalu dilanjutkan dengan elemen XML untuk setiap target dalam grafik hasil, dalam urutan topologis (kecuali jika hasil yang tidak berurutan diminta), lalu diakhiri dengan

</query>

Entri sederhana dimunculkan untuk target jenis file:

  <source-file name='//foo:foo_main.cc' .../>
  <generated-file name='//foo:libfoo.so' .../>

Namun, untuk aturan, XML bersifat terstruktur dan berisi definisi semua atribut aturan, termasuk atribut yang nilainya tidak secara eksplisit ditentukan dalam file BUILD aturan.

Selain itu, hasilnya menyertakan elemen rule-input dan rule-output sehingga topologi grafik dependensi dapat direkonstruksi tanpa harus mengetahui bahwa, misalnya, elemen atribut srcs merupakan dependensi maju (prasyarat) dan konten atribut outs adalah dependensi mundur (konsumen).

Elemen rule-input untuk dependensi implisit disembunyikan jika --noimplicit_deps ditentukan.

  <rule class='cc_binary rule' name='//foo:foo' ...>
    <list name='srcs'>
      <label value='//foo:foo_main.cc'/>
      <label value='//foo:bar.cc'/>
      ...
    </list>
    <list name='deps'>
      <label value='//common:common'/>
      <label value='//collections:collections'/>
      ...
    </list>
    <list name='data'>
      ...
    </list>
    <int name='linkstatic' value='0'/>
    <int name='linkshared' value='0'/>
    <list name='licenses'/>
    <list name='distribs'>
      <distribution value="INTERNAL" />
    </list>
    <rule-input name="//common:common" />
    <rule-input name="//collections:collections" />
    <rule-input name="//foo:foo_main.cc" />
    <rule-input name="//foo:bar.cc" />
    ...
  </rule>

Setiap elemen XML untuk target berisi atribut name, yang nilainya adalah label target, dan atribut location, yang nilainya adalah lokasi target seperti yang dicetak oleh --output location.

--[no]xml:line_numbers

Secara default, lokasi yang ditampilkan dalam output XML berisi nomor baris. Jika --noxml:line_numbers ditentukan, nomor baris tidak akan dicetak.

--[no]xml:default_values

Secara default, output XML tidak menyertakan atribut aturan yang nilainya adalah nilai default untuk jenis atribut tersebut (misalnya, jika tidak ditentukan dalam file BUILD, atau nilai default diberikan secara eksplisit). Opsi ini menyebabkan nilai atribut tersebut disertakan dalam output XML.

Ekspresi reguler

Ekspresi reguler dalam bahasa kueri menggunakan library ekspresi reguler Java, sehingga Anda dapat menggunakan sintaksis lengkap untuk java.util.regex.Pattern.

Membuat kueri dengan repositori eksternal

Jika build bergantung pada aturan dari repositori eksternal, hasil kueri akan menyertakan dependensi ini. Misalnya, jika //foo:bar bergantung pada @other-repo//baz:lib, maka bazel query 'deps(//foo:bar)' akan mencantumkan @other-repo//baz:lib sebagai dependensi.