Referensi Kueri Bazel

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

Untuk kasus penggunaan praktis, lihat Cara Menggunakan 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 Configured Target Graph pasca-analisis dan mengekspos informasi tentang Tindakan, Artefak, dan hubungannya. aquery berguna saat Anda tertarik dengan properti Tindakan/Artefak yang dihasilkan dari Configured Target Graph. Misalnya, perintah sebenarnya yang dijalankan dan input, output, serta mnemoniknya.

Untuk mengetahui detail selengkapnya, lihat referensi aquery.

Kueri yang dapat dikonfigurasi

Kueri Bazel tradisional berjalan pada grafik target fase pasca-pemuatan dan oleh karena itu tidak memiliki konsep konfigurasi dan konsep terkaitnya. Khususnya, tidak dapat menyelesaikan pernyataan pemilihan dengan benar dan malah menampilkan semua kemungkinan penyelesaian 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 cquery.

Contoh

Bagaimana cara orang menggunakan bazel query? Berikut contoh umumnya:

Mengapa pohon //foo bergantung pada //bar/baz? Menampilkan jalur:

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

Library C++ apa saja yang bergantung pada semua pengujian foo yang tidak bergantung pada target foo_bin?

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

Token: Sintaksis leksikal

Ekspresi dalam bahasa kueri terdiri dari token berikut:

• Kata kunci, seperti let. Kata kunci adalah kata-kata yang dicadangkan dalam bahasa, dan masing-masing kata dijelaskan di bawah. Kumpulan lengkap kata kuncinya adalah:

  • except

  • in

  • intersect

  • let

  • set

  • union

• Kata, seperti "foo/..." atau ".*test rule" atau "//bar/baz:all". Jika urutan karakter "dikutip" (dimulai dan diakhiri dengan tanda kutip tunggal ' atau dimulai dan diakhiri dengan tanda kutip ganda "), itu adalah kata. Jika urutan karakter tidak diapit tanda petik, urutan tersebut mungkin masih diuraikan sebagai kata. Kata yang tidak diapit tanda petik adalah urutan karakter yang diambil 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, tilde, kurung siku kiri, kurung siku kanan). Namun, kata yang tidak diapit tanda petik tidak boleh diawali dengan tanda hubung - atau tanda bintang * meskipun nama target relatif dapat diawali dengan karakter tersebut. Sebagai aturan khusus yang dimaksudkan untuk menyederhanakan penanganan label yang merujuk ke repositori eksternal, kata yang tidak diapit tanda petik yang diawali dengan @@ dapat berisi karakter +.

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

  Pemberian tanda petik diperlukan saat menulis skrip yang membuat ekspresi kueri Bazel dari nilai yang diberikan pengguna.

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

  Perhatikan bahwa kutipan ini merupakan tambahan dari kutipan apa pun yang mungkin diperlukan oleh shell Anda, seperti:

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

  Kata kunci dan operator, jika diberi tanda kutip, 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, gunakan hanya satu jenis tanda kutip (semua tanda kutip tunggal atau semua tanda kutip ganda).

  Berikut adalah contoh string kueri Java:

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

  Kami memilih sintaksis ini agar tanda petik tidak diperlukan dalam sebagian besar kasus. Contoh ".*test rule" (tidak biasa) memerlukan tanda petik: dimulai dengan titik dan berisi spasi. Mengutip "cc_library" tidak diperlukan, tetapi tidak berbahaya.

• Tanda baca, seperti tanda kurung (), titik ., dan koma ,. Kata yang berisi tanda baca (selain pengecualian yang tercantum di atas) harus diapit tanda petik.

Karakter spasi kosong di luar kata yang dikutip akan diabaikan.

Konsep bahasa kueri Bazel

Bahasa kueri Bazel adalah bahasa ekspresi. Setiap ekspresi dievaluasi ke kumpulan target yang diurutkan sebagian, atau secara setara, grafik (DAG) target. Ini adalah satu-satunya jenis data.

Set dan grafik merujuk pada jenis data yang sama, tetapi menekankan aspek yang berbeda, misalnya:

• Setel: Urutan parsial target tidak menarik.
• Grafik: Urutan parsial target signifikan.

Siklus dalam grafik dependensi

Grafik dependensi build harus asiklik.

Algoritma yang digunakan oleh bahasa kueri ditujukan untuk digunakan dalam grafik asiklik, tetapi kuat terhadap siklus. Detail cara siklus ditangani 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 ditentukan oleh:

• Atribut pribadi
• Persyaratan toolchain

Secara default, bazel query memperhitungkan dependensi implisit saat menghitung hasil kueri. Perilaku ini dapat diubah dengan opsi --[no]implicit_deps.

Perhatikan bahwa, karena kueri tidak mempertimbangkan konfigurasi, potensi implementasi toolchain tidak dianggap sebagai dependensi, hanya jenis toolchain yang diperlukan. Lihat dokumentasi toolchain.

Kualitas

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

Hasil evaluasi ekspresi dalam bahasa kueri Bazel bernilai benar untuk semua konfigurasi, yang berarti bahwa hasil tersebut mungkin merupakan perkiraan berlebih yang konservatif, dan tidak sepenuhnya akurat. Jika Anda menggunakan alat kueri untuk menghitung kumpulan semua file sumber yang diperlukan selama build, alat tersebut dapat melaporkan lebih banyak file daripada yang sebenarnya diperlukan karena, misalnya, alat kueri akan menyertakan semua file yang diperlukan untuk mendukung terjemahan pesan, meskipun Anda tidak berniat menggunakan fitur tersebut dalam build Anda.

Tentang mempertahankan urutan grafik

Operasi mempertahankan batasan pengurutan yang diwarisi dari subekspresinya. Anda dapat menganggapnya 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 dependensi. Jika Anda memfilter set tersebut untuk menyertakan hanya target jenis file, relasi pengurutan parsial transitif yang sama berlaku di antara setiap pasangan target dalam subset yang dihasilkan - meskipun tidak ada pasangan ini yang sebenarnya terhubung langsung dalam grafik asli. (Tidak ada tepi file-file dalam grafik dependensi build).

Namun, meskipun semua operator mempertahankan urutan, beberapa operasi, seperti operasi set tidak memperkenalkan batasan pengurutan apa pun. Pertimbangkan ekspresi ini:

deps(x) union y

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

Operator yang memperkenalkan batasan pengurutan meliputi: allpaths, deps, rdeps, somepath, dan karakter pengganti pola target package:*, dir/..., dll.

Kueri langit

Sky Query adalah mode kueri yang beroperasi dalam cakupan semesta tertentu.

Fungsi khusus yang hanya tersedia di SkyQuery

Mode Sky Query memiliki fungsi kueri tambahan allrdeps dan rbuildfiles. Fungsi ini beroperasi di seluruh cakupan semesta (itulah sebabnya fungsi ini tidak masuk akal untuk Kueri normal).

Menentukan cakupan semesta

Mode Sky Query diaktifkan dengan meneruskan dua tanda berikut: (--universe_scope atau --infer_universe_scope) dan --order_output=no. --universe_scope=<target_pattern1>,...,<target_patternN> memberi tahu kueri untuk memuat terlebih dahulu penutupan transitif pola target yang ditentukan oleh pola target, yang dapat bersifat aditif dan subtraktif. Semua kueri kemudian dievaluasi dalam "cakupan" ini. Khususnya, 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 mungkin bukan itu 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 memperlakukan ini sama dengan pemanggilan:

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

Namun, hasil kueri tersebut dengan --universe_scope hanya //my:target; tidak ada dependensi terbalik //my:target di semesta, berdasarkan konstruksi. Di sisi lain, pertimbangkan:

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

Ini adalah pemanggilan kueri yang bermakna yang mencoba menghitung target pengujian dalam perluasan tests target di beberapa direktori yang bergantung secara transitif pada target yang definisinya menggunakan file .bzl tertentu. Di sini, --infer_universe_scope adalah kemudahan, terutama dalam kasus saat pilihan --universe_scope akan mengharuskan Anda mengurai ekspresi kueri sendiri.

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

Kueri Sky memiliki beberapa kelebihan dan kekurangan dibandingkan dengan kueri default. Kekurangan utamanya adalah tidak dapat mengurutkan outputnya sesuai dengan urutan grafik, sehingga format output tertentu tidak diizinkan. Keuntungannya adalah menyediakan dua operator (allrdeps dan rbuildfiles) yang tidak tersedia dalam kueri default. Selain itu, Sky Query melakukan pekerjaannya dengan mengamati grafik Skyframe, bukan membuat grafik baru, seperti yang dilakukan implementasi default. Oleh karena itu, ada beberapa situasi saat hal ini lebih cepat dan menggunakan lebih sedikit memori.

Ekspresi: Sintaksis dan semantik tata bahasa

Berikut adalah tata bahasa 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. Ditafsirkan sebagai set target (tidak berurutan). Pola target paling sederhana adalah label, yang mengidentifikasi satu target (file atau aturan). Misalnya, pola target //foo:bar dievaluasi ke set yang berisi satu elemen, target, aturan bar.

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

Demikian pula, foo/...:* adalah pola target yang dievaluasi ke set yang berisi semua target (file aturan dan) di setiap paket secara rekursif di bawah direktori foo; bar/baz:* dievaluasi ke set yang berisi semua target dalam paket bar/baz, tetapi bukan subpaketnya.

Karena karakter pengganti :* mencocokkan file dan aturan, karakter 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 dievaluasi ke set singleton (dalam kasus label), ke set yang berisi banyak elemen (seperti dalam kasus foo/..., yang memiliki ribuan elemen) atau ke set kosong, jika pola target tidak cocok dengan target.

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

Variabel

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

Bahasa kueri Bazel memungkinkan definisi dan referensi ke variabel. Hasil evaluasi ekspresi let sama dengan hasil evaluasi 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/....

Kemunculan referensi variabel name selain dalam ekspresi let name = ... yang melampirkan adalah kesalahan. Dengan kata lain, ekspresi kueri tingkat teratas tidak boleh memiliki variabel bebas.

Dalam produksi tata bahasa di atas, name seperti word, tetapi dengan batasan tambahan bahwa itu harus berupa ID yang valid dalam bahasa pemrograman C. Referensi ke variabel harus diawali dengan karakter "$".

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

Pola target dan referensi variabel hanya terdiri dari satu token, sebuah kata, sehingga menimbulkan ambiguitas sintaksis. Namun, tidak ada ambiguitas semantik, karena subset kata yang merupakan nama variabel yang valid tidak terkait dengan subset kata yang merupakan pola target yang valid.

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

Ekspresi dalam tanda kurung

expr ::= (expr)

Tanda kurung mengaitkan subekspresi untuk memaksa urutan evaluasi. Ekspresi dalam tanda kurung dievaluasi menjadi nilai argumennya.

Operasi himpunan aljabar: irisan, gabungan, selisih himpunan

expr ::= expr intersect expr
       | expr ^ expr
       | expr union expr
       | expr + expr
       | expr except expr
       | expr - expr

Ketiga operator ini menghitung operasi set biasa atas argumennya. Setiap operator memiliki dua bentuk, bentuk nominal, seperti intersect, dan bentuk simbolis, seperti ^. Kedua bentuk tersebut setara; bentuk simbolik lebih cepat diketik. (Agar lebih jelas, bagian lain di halaman ini menggunakan bentuk nominal.)

Misalnya,

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

dievaluasi ke set target yang cocok dengan foo/..., tetapi tidak cocok dengan foo/bar/....

Anda dapat menulis kueri yang sama sebagai:

foo/... - foo/bar/...

Operasi intersect (^) dan union (+) bersifat komutatif (simetris); except (-) bersifat asimetris. Parser memperlakukan ketiga operator sebagai asosiatif kiri dan memiliki prioritas yang sama, jadi Anda mungkin memerlukan tanda kurung. Misalnya, dua ekspresi pertama ini setara, tetapi yang ketiga tidak:

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

Membaca target dari sumber eksternal: set

expr ::= set(word *)

Operator set(a b c ...) menghitung gabungan dari sekumpulan nol atau lebih pola target, yang dipisahkan dengan spasi (tanpa koma).

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

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

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

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

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

Fungsi

expr ::= word '(' int | word | expr ... ')'

Bahasa kueri menentukan beberapa fungsi. Nama fungsi menentukan jumlah dan jenis argumen yang diperlukan. Fungsi berikut tersedia:

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

Penutupan transitif dependensi: deps

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

Operator deps(x) mengevaluasi grafik yang dibentuk oleh penutupan transitif dependensi set argumennya x. Misalnya, nilai deps(//foo) adalah grafik dependensi yang berakar pada satu node foo, 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 ini tidak disertakan di sini. Untuk itu, Anda harus menggunakan operator buildfiles.

Grafik yang dihasilkan diurutkan sesuai dengan hubungan dependensi. Untuk detail selengkapnya, lihat bagian tentang urutan grafik.

Operator deps menerima argumen kedua opsional, yang merupakan literal bilangan bulat yang menentukan batas atas kedalaman penelusuran. Jadi, deps(foo:*, 0) menampilkan semua target dalam paket foo, sementara 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-angka ini sesuai dengan peringkat yang ditampilkan dalam format output minrank.) Jika parameter depth tidak disertakan, penelusuran tidak dibatasi: penelusuran akan menghitung penutupan transitif refleksif prasyarat.

Penutupan transitif dependensi terbalik: rdeps

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

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

Grafik yang dihasilkan diurutkan sesuai dengan hubungan dependensi. Lihat bagian tentang urutan grafik untuk mengetahui 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 set argumen. Jadi, rdeps(//foo, //common, 1) dievaluasi ke semua node dalam penutupan transitif //foo yang secara langsung bergantung pada //common. (Angka-angka ini sesuai dengan peringkat yang ditampilkan dalam format output minrank.) Jika parameter depth tidak ada, penelusuran tidak dibatasi.

Penutupan transitif semua dependensi terbalik: allrdeps

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

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

Dependensi terbalik langsung dalam paket yang sama: same_pkg_direct_rdeps

expr ::= same_pkg_direct_rdeps(expr)

Operator same_pkg_direct_rdeps(x) dievaluasi ke set lengkap target yang berada dalam paket yang sama dengan target dalam set argumen, dan yang bergantung langsung padanya.

Menangani paket target: saudara kandung

expr ::= siblings(expr)

Operator siblings(x) dievaluasi ke set lengkap target yang ada dalam paket yang sama dengan target dalam set argumen.

Pilihan arbitrer: beberapa

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

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

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

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

Error akan terjadi 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)

Operator somepath(S, E) dan allpaths(S, E) menghitung jalur antara dua set target. Kedua kueri menerima dua argumen, yaitu set S titik awal dan set 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 target mana pun di S ke target mana pun di E.

Grafik yang dihasilkan diurutkan sesuai dengan hubungan dependensi. Lihat bagian tentang urutan grafik untuk mengetahui detail selengkapnya.

Pemfilteran jenis target: jenis

expr ::= kind(word, expr)

Operator kind(pattern, input) menerapkan filter ke sekumpulan target, dan membuang target yang bukan dari 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:

        genrule(
            name = "a",
            srcs = ["a.in"],
            outs = ["a.out"],
            cmd = "...",
        )
      

Dengan demikian, kind("cc_.* rule", foo/...) dievaluasi ke set semua target aturan cc_library, cc_binary, dll., di bawah foo, dan kind("source file", deps(//foo)) dievaluasi ke set semua file sumber dalam penutupan transitif dependensi target //foo.

Kutipan argumen pattern sering kali diperlukan karena tanpa kutipan, banyak ekspresi reguler, seperti source file dan .*_test, tidak dianggap sebagai kata oleh parser.

Saat mencocokkan package group, target yang diakhiri dengan :all mungkin tidak menghasilkan hasil apa pun. Gunakan :all-targets sebagai gantinya.

Pemfilteran nama target: filter

expr ::= filter(word, expr)

Operator filter(pattern, input) menerapkan filter ke sekumpulan target, dan membuang target yang labelnya (dalam bentuk absolut) tidak cocok dengan pola; operator ini mengevaluasi ke subset inputnya.

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

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

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

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

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

yang pertama-tama akan menghitung set dependensi //foo dan kemudian hanya akan memfilter target yang cocok dengan pola yang diberikan—dengan kata lain, target dengan nama yang berisi //bar sebagai substring.

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

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

akan memberikan daftar semua file .cc yang digunakan untuk mem-build //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 name yang ditentukan atau target aturan yang nilai atributnya tidak cocok dengan ekspresi reguler pattern yang diberikan; operator ini dievaluasi ke subset inputnya.

Argumen pertama, name, adalah nama atribut aturan yang harus dicocokkan dengan pola ekspresi reguler yang diberikan. Argumen kedua, pattern adalah ekspresi reguler atas nilai atribut. Ekspresi attr dievaluasi ke set yang berisi semua target x sehingga x adalah anggota set input, adalah aturan dengan atribut name yang ditentukan, dan nilai atribut berisi kecocokan (tanpa jangkar) 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 telah ditetapkan secara eksplisit ke 0 atau tidak ditetapkan sama sekali, tetapi nilai defaultnya adalah 0 (seperti untuk aturan cc_binary).

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

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

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

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

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

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

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

Hal 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 membuang target tanpa visibilitas yang diperlukan.

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

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

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

Evaluasi atribut aturan jenis label: label

expr ::= labels(word, expr)

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

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

Perluas dan filter test_suites: tests

expr ::= tests(expr)

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

Secara default, evaluasi kueri mengabaikan semua target non-pengujian dalam semua aturan test_suite. 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 (menurut definisi) adalah anggota paket foo. Sebaliknya, kueri tests(foo:*) akan menampilkan semua pengujian individual yang akan dieksekusi oleh bazel test foo:*: ini dapat mencakup pengujian milik paket lain, yang dirujuk secara langsung atau tidak langsung melalui aturan test_suite.

File definisi paket: buildfiles

expr ::= buildfiles(expr)

Operator buildfiles(x) menampilkan kumpulan file yang menentukan paket setiap target dalam kumpulan x; dengan kata lain, untuk setiap paket, file BUILD-nya, ditambah file .bzl yang direferensikannya melalui load. Perhatikan bahwa hal ini juga menampilkan file BUILD dari paket yang berisi file load tersebut.

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

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

menampilkan set semua paket yang secara transitif bergantung pada //foo.

File definisi paket: rbuildfiles

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

Operator rbuildfiles mengambil daftar fragmen jalur yang dipisahkan koma dan menampilkan kumpulan file BUILD yang bergantung secara transitif pada fragmen jalur ini. Misalnya, jika //foo adalah 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 lain yang memuat //bar:file.bzl

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

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

File definisi paket: loadfiles

expr ::= loadfiles(expr)

Operator loadfiles(x) menampilkan kumpulan file Starlark yang diperlukan untuk memuat paket setiap target dalam set x. Dengan kata lain, untuk setiap paket, fungsi ini akan menampilkan file .bzl yang dirujuk dari file BUILD-nya.

Format keluaran

bazel query membuat grafik. Anda menentukan konten, format, dan pengurutan yang digunakan bazel query untuk menyajikan grafik ini dengan 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 saat --output=graph digunakan; opsi ini tidak berpengaruh jika format output selain graph digunakan. Demikian pula, --xml:line_numbers hanya berlaku saat --output=xml sedang digunakan.

Tentang pengurutan hasil

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

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

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

Jika tanda ini deps, Bazel akan mencetak hasil dalam beberapa urutan topologi—yaitu, dependen terlebih dahulu dan dependensi setelahnya. Namun, node yang tidak diurutkan berdasarkan urutan dependensi (karena tidak ada jalur dari satu ke yang lain) dapat dicetak dalam urutan apa pun.

Jika tanda ini adalah full, Bazel akan mencetak node dalam urutan yang sepenuhnya deterministik (total). Pertama, semua node diurutkan menurut abjad. Kemudian, setiap node dalam daftar digunakan sebagai awal penelusuran depth-first pasca-urutan yang melintasi tepi keluar ke node yang belum dikunjungi dalam urutan alfabetis node penerus. Terakhir, node dicetak dalam urutan terbalik saat dikunjungi.

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

Mencetak formulir sumber target sebagaimana akan muncul di BUILD

--output build

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

Meskipun output menggunakan sintaksis yang sama dengan file BUILD, output tidak dijamin menghasilkan file BUILD yang valid.

Mencetak label setiap target

--output label

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

Saat mencetak output kueri somepath, urutan node yang dicetak adalah urutan jalur.

Peringatan: dalam beberapa kasus ekstrem, mungkin ada dua target berbeda dengan label yang sama; misalnya, aturan sh_binary dan file srcs (implisit) tunggalnya mungkin sama-sama 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 yang satu memiliki jenis sh_binary rule dan yang lainnya memiliki jenis source file.

Mencetak label dan jenis setiap target

--output label_kind

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

Target cetak dalam format buffer protokol

--output proto

Mencetak output kueri sebagai QueryResult penyangga protokol.

Mencetak target dalam format protocol buffer yang dibatasi panjangnya

--output streamed_proto

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

Target cetak dalam format proto teks

--output textproto

Mirip dengan --output proto, mencetak QueryResult buffer protokol, tetapi dalam format teks.

Mencetak target dalam format ndjson

--output streamed_jsonproto

Mirip dengan --output streamed_proto, menampilkan aliran buffer protokol Target, tetapi dalam format ndjson.

Mencetak label setiap target, dalam urutan peringkat

--output minrank --output maxrank

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

Ada dua varian format ini: minrank memberi peringkat setiap node berdasarkan panjang jalur terpendek dari node root ke node tersebut. Node "root" (yang tidak memiliki tepi masuk) memiliki peringkat 0, penerusnya memiliki peringkat 1, dan seterusnya. (Seperti biasa, tepi mengarah dari target ke prasyaratnya: target yang bergantung padanya.)

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

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

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

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

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

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

Mencetak lokasi setiap target

--output location

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

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

Mencetak kumpulan paket

--output package

Opsi ini mencetak nama semua paket yang beberapa target dalam set hasilnya termasuk di dalamnya. Nama dicetak dalam urutan leksikografis; duplikat tidak disertakan. Secara formal, ini adalah proyeksi dari set label (paket, target) ke paket.

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

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

Menampilkan grafik hasil

--output graph

Opsi ini menyebabkan hasil kueri dicetak sebagai grafik berarah 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 bagian contoh di bawah untuk contoh pemanggilan.

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

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

--graph:node_limit n

Opsi ini menentukan panjang maksimum string label untuk node grafik dalam output. Label yang lebih panjang akan dipotong; -1 menonaktifkan pemotongan. Karena bentuk terfaktor yang biasanya digunakan untuk mencetak grafik, label node mungkin sangat panjang. GraphViz tidak dapat menangani label yang melebihi 1.024 karakter, yang merupakan nilai default opsi ini. Opsi ini tidak akan berpengaruh kecuali jika --output=graph sedang digunakan.

--[no]graph:factored

Secara default, grafik ditampilkan dalam bentuk faktor, seperti yang dijelaskan di atas. Jika --nograph:factored ditentukan, grafik akan dicetak tanpa faktor. Hal ini membuat visualisasi menggunakan GraphViz tidak praktis, tetapi format yang lebih sederhana dapat mempermudah pemrosesan oleh alat lain (seperti grep). Opsi ini tidak berpengaruh kecuali jika --output=graph sedang digunakan.

XML

--output xml

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

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

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

</query>

Entri sederhana dikeluarkan untuk target jenis file:

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

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

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

Elemen rule-input untuk dependensi implisit akan dihilangkan 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 regex 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.