Referensi Kueri Bazel

Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.
Laporkan masalah Lihat sumber

Halaman ini adalah panduan referensi untuk Bazel Query Language yang digunakan saat Anda menggunakan bazel query untuk menganalisis dependensi build. Bagian ini juga menjelaskan format output yang didukung oleh bazel query.

Untuk kasus penggunaan praktis, lihat Petunjuk Kueri Bazel.

Referensi kueri tambahan

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

Kueri grafik tindakan

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

Untuk 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, kode ini tidak me-resolve pernyataan tertentu dengan benar, tetapi menampilkan semua kemungkinan resolusi pilihan. Namun, lingkungan kueri yang dapat dikonfigurasi, cquery, menangani konfigurasi dengan benar, tetapi tidak menyediakan semua fungsi kueri asli ini.

Untuk 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 yang tidak digunakan oleh 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 yang sudah dicadangkan untuk bahasa bahasa, dan masing-masingnya dijelaskan di bawah. Kumpulan kata kunci lengkap adalah:

  • Kata, seperti "foo/..." atau ".*test rule" atau "//bar/baz:all". Jika urutan karakter "dikutip" (diawali dan diakhiri dengan tanda kutip tunggal ' atau diawali dan diakhiri dengan tanda kutip ganda "), maka merupakan kata. Jika tidak diurutkan, urutan karakter mungkin masih diuraikan sebagai kata. 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, pada, titik, tanda hubung, garis bawah, titik dua, tanda dolar, tanda gelombang, kurung kurawal kiri, kurung siku kanan). Namun, kata-kata yang tidak diberi tanda kutip tidak boleh diawali dengan tanda hubung - atau tanda bintang * meskipun [nama target] relatif ((/konsep/label#target-nama) dapat dimulai dengan karakter tersebut.

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

    Mengutip diperlukan saat menulis skrip yang membuat ekspresi kueri Bazel dari nilai yang diberikan pengguna.

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

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

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

    Kata kunci, jika dikutip, dianggap sebagai kata-kata biasa. Misalnya, some adalah kata kunci, tetapi "beberapa" adalah sebuah kata. foo dan "foo" adalah kata.

    Namun, berhati-hatilah saat menggunakan tanda kutip tunggal atau ganda dalam nama target. Saat mengutip satu atau beberapa nama target, gunakan hanya satu jenis tanda kutip (semua tanda kutip tunggal atau 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 sehingga tanda kutip tidak diperlukan dalam kebanyakan kasus. Contoh (tidak biasa) ".*test rule" memerlukan tanda kutip: dimulai dengan titik dan berisi spasi. Mengutip "cc_library" tidak diperlukan tetapi tidak berbahaya.

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

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 jenis data.

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

  • Set: Urutan sebagian target tidak menarik.
  • Grafik: Urutan target sebagian besar signifikan.

Siklus dalam grafik dependensi

Grafik dependensi build harus bersifat asiklik.

Algoritme yang digunakan oleh bahasa kueri ditujukan untuk digunakan dalam grafik asiklik, tetapi bersifat andal 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. Misalnya, setiap aturan Java secara implisit bergantung pada JavaBuilder. Dependensi implisit dibuat menggunakan atribut yang dimulai dengan $ dan tidak dapat diganti dalam file BUILD.

Per default, bazel query memperhitungkan dependensi implisit saat menghitung hasil kueri. Perilaku ini dapat diubah dengan opsi --[no]implicit_deps. Perhatikan bahwa, karena kueri tidak mempertimbangkan konfigurasi, potensi toolchain tidak akan pernah dipertimbangkan.

Kesehatan

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

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

Tentang pemeliharaan urutan grafik

Operasi mempertahankan batasan pengurutan yang diwarisi dari subekspresinya. Anda dapat menganggapnya sebagai "hukum konservasi pesanan parsial". Pertimbangkan contoh: jika Anda mengeluarkan kueri untuk menentukan penutupan transitifitas dependensi target tertentu, kumpulan yang dihasilkan akan diurutkan sesuai dengan grafik dependensi. Jika Anda memfilter yang ditetapkan untuk hanya menyertakan target jenis file, hubungan pengurutan parsial transitif yang sama akan terjadi di antara setiap pasangan target dalam subset yang dihasilkan, meskipun tidak satu pun dari pasangan tersebut yang benar-benar terhubung langsung dalam grafik asli. (Tidak ada tepi file dalam grafik dependensi build).

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

deps(x) union y

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

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

Kueri Sky

Sky Query adalah mode kueri yang beroperasi pada cakupan universal yang ditentukan.

Fungsi khusus hanya tersedia di SkyQuery

Mode Kueri Sky memiliki fungsi kueri tambahan allrdeps dan rbuildfiles. Fungsi ini beroperasi di seluruh cakupan dunia (itulah sebabnya fungsi tersebut tidak cocok untuk Kueri normal).

Menentukan cakupan dunia

Mode Sky Query diaktifkan dengan meneruskan dua flag berikut: (--universe_scope atau --infer_universe_scope) dan --order_output=no. --universe_scope=<target_pattern1>,...,<target_patternN> memberi tahu kueri untuk melakukan pramuat penutupan transitif pola target yang ditentukan oleh pola target, yang dapat bersifat tambahan dan pengurangan. 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 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 yang ada di dunia, melalui konstruksi. Di sisi lain, pertimbangkan:

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

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

Jadi, untuk ekspresi kueri yang menggunakan operator dengan cakupan universal, seperti allrdeps dan rbuildfiles, pastikan untuk menggunakan --infer_universe_scope hanya jika perilakunya adalah 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. Keuntungannya adalah alat ini menyediakan dua operator (allrdeps dan rbuildfiles) yang tidak tersedia di kueri default. Selain itu, Sky Query melakukan pekerjaannya dengan memperkenalkan grafik Skyframe, daripada membuat grafik baru, yang dilakukan oleh penerapan default. Oleh karena itu, ada beberapa situasi yang mempercepat dan menggunakan lebih sedikit memori.

Ekspresi: Sintaksis dan semantik tata bahasa

Ini 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. Ini ditafsirkan sebagai kumpulan target (yang tidak berurutan). Pola target yang paling sederhana adalah label, yang mengidentifikasi satu target (file atau aturan). Misalnya, pola target //foo:bar bernilai kumpulan yang berisi satu elemen, 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 mengevaluasi ke kumpulan yang berisi semua aturan di setiap paket secara rekursif di bawah direktori foo; bar/baz:all adalah pola target yang mengevaluasi ke kumpulan yang berisi semua aturan dalam paket bar/baz, tetapi bukan sub-paketnya.

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

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

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

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

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

Variabel

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

Bahasa kueri Bazel memungkinkan definisi dan referensi ke variabel. Hasil evaluasi ekspresi let sama dengan hasil expr2, dengan semua kemunculan bebas variabel name diganti dengan nilai expr1.

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

Kemunculan referensi variabel name selain dalam ekspresi let name = ... yang menyertainya merupakan error. Dengan kata lain, ekspresi kueri level teratas tidak boleh memiliki variabel bebas.

Dalam produksi tata bahasa di atas, name mirip dengan kata, tetapi dengan batasan tambahan berupa ID hukum 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, yang menciptakan ambiguitas sintaksis. Namun, tidak ada ambiguitas semantik, karena subkumpulan kata yang merupakan nama variabel legal akan terpisah dari subkumpulan kata yang merupakan pola target hukum.

Secara teknis, ekspresi let tidak meningkatkan ekspresif bahasa kueri: setiap kueri yang dapat diekspresikan dalam bahasa juga dapat dinyatakan tanpanya. Namun, kueri ini akan meningkatkan kualitas ringkas berbagai kueri, dan juga dapat menghasilkan evaluasi kueri yang lebih efisien.

Ekspresi yang diberi tanda kurung

expr ::= (expr)

Tanda kurung mengaitkan subekspresi untuk memaksa urutan evaluasi. Ekspresi yang diberi tanda kurung mengevaluasi nilai argumennya.

Operasi himpunan aljabar: persimpangan, gabungan, perbedaan yang ditetapkan

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

Ketiga operator ini menghitung operasi set yang biasa pada argumen mereka. Setiap operator memiliki dua bentuk, yaitu bentuk nominal, seperti intersect, dan bentuk simbolis, seperti ^. Kedua formulir tersebut setara; bentuk simbolis lebih cepat diketik. (Agar lebih jelas, bagian lain dari halaman ini menggunakan bentuk nominal.)

Misalnya,

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

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

Anda bisa menulis kueri yang sama seperti:

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

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

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

Membaca target dari sumber eksternal: ditetapkan

expr ::= set(word *)

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

Bersama dengan fitur $(...) shell Bourne, set() menyediakan cara untuk menyimpan hasil dari satu kueri dalam file teks biasa, memanipulasi file teks tersebut menggunakan program lain (seperti alat shell UNIX standar), kemudian 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 nama pendek untuk $(cat foo), tetapi perintah shell selain cat juga dapat digunakan, seperti perintah awk sebelumnya.

Functions

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

Bahasa kueri menentukan beberapa fungsi. Nama fungsi menentukan jumlah dan jenis argumen yang diperlukan. Berikut adalah fungsi yang tersedia:

Penutupan transitif dependensi: dependensi

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

Operator deps(x) mengevaluasi ke grafik yang dibentuk oleh penutupan transitif dependensi dependensi yang disetel x. Misalnya, nilai deps(//foo) adalah grafik dependensi yang di-root pada foo tunggal, termasuk semua dependensinya. Nilai deps(foo/...) adalah grafik dependensi yang root-nya adalah semua aturan dalam setiap paket di bawah direktori foo. Dalam konteks ini, 'dependensi' hanya berarti 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 integer yang menentukan batas atas pada kedalaman penelusuran. Jadi, deps(foo:*, 0) akan menampilkan semua target dalam paket foo, sementara deps(foo:*, 1) lebih lanjut menyertakan prasyarat langsung dari setiap target dalam paket foo, dan deps(foo:*, 0) selanjutnya menyertakan node yang langsung dapat dijangkau dari node di deps(foo:*, 1), dan seterusnya. (Angka ini sesuai dengan peringkat yang ditampilkan dalam format output minrank.) Jika parameter depth dihilangkan, penelusuran tidak akan terikat: parameter ini akan menghitung penutupan transitif refleksif prasyarat.

Penutupan transitif dependensi terbalik: rdeps

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

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

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

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

Penutupan transitif dari semua dependensi terbalik: allrdeps

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

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

Dependensi terbalik langsung dalam paket yang sama: same_pkg_direct_rdeps

expr ::= same_pkg_direct_rdeps(expr)

Operator same_pkg_direct_rdeps(x) bernilai kumpulan target penuh yang berada dalam paket yang sama dengan target dalam kumpulan argumen, dan yang secara langsung bergantung padanya.

Berinteraksi dengan paket target: sibling

expr ::= siblings(expr)

Operator siblings(x) bernilai kumpulan lengkap target yang ada dalam paket yang sama dengan target dalam kumpulan argumen.

Pilihan arbitrer: beberapa

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

Operator some(x, k) memilih maksimal k target dari sembarang argumen argumennya x, dan akan mengevaluasi ke kumpulan yang hanya berisi target tersebut. Parameter k bersifat opsional; jika tidak ada, hasilnya akan berupa 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) bernilai satu singleton yang berisi //foo:main atau //bar:baz—meskipun mana yang tidak ditentukan. Ekspresi some(//foo:main union //bar:baz, 2) atau some(//foo:main union //bar:baz, 3) menampilkan //foo:main dan //bar:baz.

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

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

Operator jalur: somepath, allpath

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

Operator somepath(S, E) dan allpaths(S, E) menghitung jalur antara dua kumpulan target. Kedua kueri menerima dua argumen, yaitu kumpulan S titik awal dan kumpulan E titik akhir. somepath menampilkan grafik node pada beberapa jalur arbitrer dari target dalam S ke target di E; allpaths menampilkan grafik node pada semua jalur dari setiap target di S ke target mana pun di E.

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

Jalur tertentu
somepath(S1 + S2, E), satu kemungkinan hasil.
Jalur tertentu
somepath(S1 + S2, E), kemungkinan hasil lainnya.
Semua jalur
allpaths(S1 + S2, E)

Pemfilteran jenis target: jenis

expr ::= kind(word, expr)

Operator kind(pattern, input) menerapkan filter ke sekumpulan target, dan menghapus target tersebut 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 ini diilustrasikan dalam tabel:

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

Dengan demikian, kind("cc_.* rule", foo/...) mengevaluasi kumpulan semua aturan cc_library, cc_binary, dll., yang berada di bawah foo, dan kind("cc_.* rule", foo/...) mengevaluasi sebagai kumpulan semua file sumber dalam penutupan transitif dependensi target //foo.

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

Jika cocok dengan 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 akan dievaluasi ke subset inputnya.

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

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

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

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

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

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

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

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

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

Pemfilteran atribut aturan: atribut

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

Operator attr(name, pattern, input) menerapkan filter ke sekumpulan target, dan menghapus target yang bukan aturan, target aturan yang tidak memiliki atribut name yang ditentukan atau target aturan dengan nilai atribut yang tidak cocok dengan ekspresi reguler pattern yang diberikan; layanan akan mengevaluasi 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 dari nilai atribut. Ekspresi attr mengevaluasi kumpulan yang berisi semua target x sehingga x adalah anggota kumpulan input, adalah aturan dengan atribut yang ditentukan name dan nilai atribut berisi pencocokan (tanpa anchor) 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 menyetelnya secara eksplisit ke 0 atau tidak menetapkannya sama sekali, tetapi nilai defaultnya adalah 0 (seperti untuk aturan cc_binary).

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

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

akan memilih semua aturan di antara dependensi //foo yang memiliki 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 (setiap label sedikitnya memiliki panjang 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 menjadi 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 serangkaian target yang harus terlihat oleh semua target di output. Ekspresi visible bernilai kumpulan yang berisi semua target x sehingga x adalah anggota dari kumpulan input, dan untuk semua target, y dalam predicate x dapat dilihat oleh y. Contoh:

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

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

Evaluasi atribut aturan label jenis: label

expr ::= labels(word, expr)

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

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

Perluas dan filter test_suite: pengujian

expr ::= tests(expr)

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

Secara default, evaluasi kueri mengabaikan target non-pengujian di 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) anggota paket foo. Sebaliknya, kueri tests(foo:*) akan menampilkan semua pengujian individual yang akan dijalankan oleh bazel test foo:*: kueri ini mungkin mencakup pengujian yang disertakan 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, serta file .bzl yang direferensikannya melalui load. Perhatikan bahwa tindakan ini juga menampilkan file BUILD dari paket yang berisi file load ini.

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

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

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

File definisi paket: rbuildfiles

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

Operator rbuildfiles mengambil daftar fragmen jalur yang dipisahkan koma dan menampilkan kumpulan file BUILD yang secara transitif bergantung 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, maka rbuildfiles(bar/file.bzl) akan menampilkan target //foo:BUILD, serta target untuk file BUILD lainnya yang memuat //bar:file.bzl

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

Operator rbuildfiles hampir secara moral merupakan kebalikan dari operator buildfiles. Namun, inversi moral ini berpegang lebih kuat pada satu arah: output rbuildfiles sama seperti input buildfiles; yang pertama hanya akan berisi target file BUILD dalam paket, dan yang terakhir mungkin berisi target tersebut. Di sisi lain, korespondensi akan lebih lemah. Output operator buildfiles adalah target yang sesuai dengan semua paket dan .File bzl yang diperlukan oleh input tertentu. Namun, input dari operator rbuildfiles bukan 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 kumpulan x. Dengan kata lain, untuk setiap paket, kolom ini menampilkan file .bzl yang direferensikan dari file BUILD-nya.

Format output

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

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

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

Tentang urutan hasil

Meskipun ekspresi kueri selalu mengikuti "hukum pengurutan urutan grafik", untuk menyajikan hasil dapat dilakukan dengan cara yang bergantung pada urutan atau tidak berurutan. Hal ini tidak memengaruhi target dalam kumpulan hasil atau cara kueri dihitung. Ini hanya memengaruhi cara hasil dicetak ke stdout. Selain itu, node yang setara dalam urutan dependensi mungkin 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, saat 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. Hal ini umumnya merupakan opsi tercepat. Meskipun tidak didukung jika --output adalah salah satu dari graph, minrank, atau maxrank: dengan format ini, Bazel selalu mencetak hasil yang diurutkan berdasarkan urutan dependensi atau peringkat.

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

Jika tanda ini adalah full, Bazel mencetak node dalam urutan yang sepenuhnya deterministik (total). Pertama, semua node diurutkan menurut abjad. Kemudian, setiap node dalam daftar digunakan sebagai awal penelusuran kedalaman kedalaman setelah pesanan, yang mana tepi keluar ke node yang tidak dikunjungi diteruskan dalam urutan abjad dari node pengganti. Terakhir, node dicetak dalam urutan terbalik saat dikunjungi.

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

Cetak bentuk sumber target seperti yang akan muncul di BUILD

--output build

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

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

--output label

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

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

Peringatan: dalam beberapa kasus sudut, mungkin ada dua target berbeda dengan label yang sama; misalnya, aturan sh_binary dan file srcs tunggal (implisitnya) dapat disebut foo.sh. Jika hasil kueri berisi kedua target ini, outputnya (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 memiliki jenis sh_binary rule dan jenis lainnya source file.

--output label_kind

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

--output minrank --output maxrank

Seperti label, format output minrank dan maxrank mencetak label setiap target dalam grafik yang dihasilkan, tetapi tidak muncul dalam urutan topologi, tetapi muncul dalam urutan peringkat, yang didahului oleh nomor peringkatnya. Ini tidak terpengaruh oleh flag hasil pengurutan --[no]order_results (lihat catatan tentang urutan 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) berada di peringkat 0, penerusnya adalah peringkat 1, dll. (Seperti biasa, tepi mengarah dari target ke prasyaratnya: target yang menjadi targetnya.)

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

Semua node dalam satu siklus dianggap memiliki peringkat yang sama. (Sebagian besar grafik bersifat asiklik, tetapi siklus 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, angka peringkatnya sama dengan panjang jalur terpendek (dengan minrank) atau terpanjang (dengan maxrank) dari x ke node di peringkat tersebut. maxrank dapat digunakan untuk menentukan urutan terpanjang dari langkah build yang diperlukan untuk membuat target.

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

Di luar peringkat
      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
      
--output location

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

Informasi lokasi bervariasi menurut jenis target (lihat operator jenis). Untuk aturan, lokasi deklarasi aturan dalam file BUILD dicetak. Untuk file sumber, lokasi baris 1 file yang sebenarnya akan dicetak. Untuk file yang dihasilkan, lokasi aturan yang membuatnya akan dicetak. (Alat kueri tidak memiliki informasi yang memadai untuk menemukan lokasi sebenarnya file yang dihasilkan, dan bagaimanapun juga, alat ini mungkin tidak ada jika build belum dilakukan.)

--output package

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

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

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

Menampilkan grafik hasil

--output graph

Opsi ini menyebabkan hasil kueri dicetak sebagai grafik terarah dalam format AT&T GraphViz yang populer. Biasanya, hasilnya disimpan ke file, seperti .png atau .svg. (Jika program dot tidak diinstal di workstation Anda, 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 kumpulan jalur yang tidak dapat dengan mudah divisualisasikan saat dirender dalam bentuk linear, seperti dengan --output label.

Secara default, grafik dirender dalam bentuk yang difaktorkan. 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 mungkin bergantung pada ratusan file sumber Java yang semuanya dihasilkan oleh genrule yang sama; dalam grafik yang difaktorkan, semua file ini diwakili oleh satu node. Perilaku ini dapat dinonaktifkan dengan opsi --nograph:factored.

--graph:node_limit n

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

--[no]graph:factored

Secara default, grafik ditampilkan dalam bentuk faktor, seperti yang dijelaskan di atas. 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">

lalu melanjutkan dengan elemen XML untuk setiap target dalam grafik hasil, dalam urutan topologi (kecuali jika hasil yang tidak diurutkan diminta), lalu diakhiri dengan penghentian

</query>

Entri sederhana dikeluarkan untuk target jenis file:

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

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

Selain itu, hasilnya mencakup elemen rule-input dan rule-output sehingga topologi grafik dependensi dapat direkonstruksi tanpa harus mengetahui bahwa, misalnya, elemen atribut srcs adalah dependensi 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 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 (ditentukan dalam file WORKSPACE), hasil kueri akan menyertakan dependensi ini. Misalnya, jika //foo:bar bergantung pada //external:some-lib dan //external:some-lib terikat ke @other-repo//baz:lib, maka bazel query 'deps(//foo:bar)' akan mencantumkan @other-repo//baz:lib dan //external:some-lib sebagai dependensi.

Repositori eksternal itu sendiri bukanlah dependensi build. Artinya, dalam contoh di atas, //external:other-repo bukan dependensi. Namun, dapat dikueri sebagai anggota paket //external, misalnya:

  # Querying over all members of //external returns the repository.
  bazel query 'kind(http_archive, //external:*)'
  //external:other-repo

  # ...but the repository is not a dependency.
  bazel query 'kind(http_archive, deps(//foo:bar))'
  INFO: Empty results