เปิดให้ลงทะเบียนและส่งเนื้อหาสำหรับ CFP ของ BazelCon 2025 แล้ว

หน้านี้ได้รับการแปลโดย Cloud Translation API

ข้อมูลอ้างอิงข้อความค้นหา Bazel

รายงานปัญหา ดูแหล่งที่มา Nightly · 8.3 · 8.2 · 8.1 · 8.0 · 7.6

หน้านี้เป็นคู่มืออ้างอิงสำหรับภาษาการค้นหาของ Bazel ที่ใช้ เมื่อใช้ bazel query เพื่อวิเคราะห์การขึ้นต่อกันของการสร้าง นอกจากนี้ ยังอธิบายรูปแบบเอาต์พุตที่ bazel query รองรับด้วย

ดูกรณีการใช้งานจริงได้ที่วิธีการใช้ Bazel Query

ข้อมูลอ้างอิงการค้นหาเพิ่มเติม

นอกจาก query ซึ่งทํางานในกราฟเป้าหมายระยะหลังการโหลดแล้ว<0x0ABazel ยังมีการค้นหากราฟการกระทําและการค้นหาที่กําหนดค่าได้

การค้นหากราฟการดำเนินการ

การค้นหากราฟการดำเนินการ (aquery) จะทำงานในกราฟเป้าหมายที่กำหนดค่าไว้หลังการวิเคราะห์ และแสดงข้อมูลเกี่ยวกับการดำเนินการ อาร์ติแฟกต์ และความสัมพันธ์ของอาร์ติแฟกต์เหล่านั้น aquery มีประโยชน์เมื่อคุณสนใจคุณสมบัติของ การดำเนินการ/อาร์ติแฟกต์ที่สร้างจากกราฟเป้าหมายที่กำหนดค่า เช่น คำสั่งจริงที่เรียกใช้ รวมถึงอินพุต เอาต์พุต และมνηนิค

ดูรายละเอียดเพิ่มเติมได้ที่ข้อมูลอ้างอิง aquery

การค้นหาที่กำหนดค่าได้

การค้นหา Bazel แบบเดิมจะทำงานในกราฟเป้าหมายของเฟสหลังการโหลด และ จึงไม่มีแนวคิดของการกำหนดค่าและแนวคิดที่เกี่ยวข้อง โปรดทราบว่า ฟีเจอร์นี้ไม่สามารถแก้ปัญหาคำสั่ง SELECT ได้อย่างถูกต้อง แต่จะแสดงผลลัพธ์ที่เป็นไปได้ทั้งหมดของ SELECT แทน อย่างไรก็ตาม สภาพแวดล้อมการค้นหาที่กำหนดค่าได้ cquery จะจัดการการกำหนดค่าอย่างถูกต้อง แต่ ไม่ได้ให้ฟังก์ชันการทำงานทั้งหมดของการค้นหาเดิมนี้

ดูรายละเอียดเพิ่มเติมได้ที่ข้อมูลอ้างอิง cquery

ตัวอย่าง

ผู้คนใช้ bazel query อย่างไร ตัวอย่างทั่วไปมีดังนี้

ทำไม//fooจึงต้องใช้//bar/baz แสดงเส้นทาง

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

ไลบรารี C++ ใดที่fooการทดสอบทั้งหมดต้องใช้ แต่foo_binเป้าหมายไม่ต้องใช้

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

โทเค็น: ไวยากรณ์ระดับคำ

นิพจน์ในภาษาการค้นหาประกอบด้วยโทเค็นต่อไปนี้

คีย์เวิร์ด เช่น let คีย์เวิร์ดคือคำที่สงวนไว้ของ ภาษา และแต่ละคำจะอธิบายไว้ด้านล่าง ชุดคีย์เวิร์ดทั้งหมด มีดังนี้
- except
- in
- intersect
- let
- set
- union
คำ เช่น "foo/..." หรือ ".*test rule" หรือ "//bar/baz:all" หากลำดับอักขระ "อยู่ในเครื่องหมายคำพูด" (ขึ้นต้นและลงท้ายด้วยเครื่องหมายคำพูดเดี่ยว ' หรือขึ้นต้นและลงท้ายด้วยเครื่องหมายคำพูดคู่ ") จะถือเป็นคำ หากไม่ได้ใส่เครื่องหมายคำพูดในลำดับอักขระ ระบบอาจยังคงแยกวิเคราะห์เป็นคำได้ คำที่ไม่ได้อยู่ในเครื่องหมายคำพูดคือลำดับ ของอักขระที่ดึงมาจากอักขระตัวอักษร A-Za-z, ตัวเลข 0-9 และอักขระพิเศษ */@.-_:$~[] (ดอกจัน, ทับ, @, จุด, ขีดกลาง, ขีดล่าง, โคลอน, เครื่องหมายดอลลาร์, ตัวหนอน, วงเล็บเหลี่ยมซ้าย, วงเล็บเหลี่ยมขวา) อย่างไรก็ตาม คำที่ไม่มีเครื่องหมายคำพูดต้องไม่ขึ้นต้นด้วยขีดกลาง - หรือดอกจัน * แม้ว่า [ชื่อเป้าหมาย][(/concepts/labels#target-names) ที่เกี่ยวข้องอาจขึ้นต้น ด้วยอักขระเหล่านั้นก็ตาม

นอกจากนี้ คำที่ไม่มีเครื่องหมายคำพูดต้องไม่มีเครื่องหมายบวก + หรือเครื่องหมายเท่ากับ = แม้ว่าระบบจะอนุญาตให้ใช้อักขระเหล่านั้นในชื่อเป้าหมายก็ตาม เมื่อเขียนโค้ดที่สร้างนิพจน์การค้นหา คุณควรใส่เครื่องหมายคำพูดรอบชื่อเป้าหมาย

การใส่เครื่องหมายคำพูดเป็นสิ่งจำเป็นเมื่อเขียนสคริปต์ที่สร้างนิพจน์การค้นหา Bazel จากค่าที่ผู้ใช้ระบุ
```
 //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.
```
โปรดทราบว่าการใส่เครื่องหมายคำพูดนี้เป็นส่วนเพิ่มเติมจากการใส่เครื่องหมายคำพูดที่อาจจำเป็นต้องใช้ในเชลล์ เช่น
```
bazel query ' "//foo:bar=wiz" '   # single-quotes for shell, double-quotes for Bazel.
```
เมื่อใส่เครื่องหมายคำพูด คีย์เวิร์ดจะถือเป็นคำธรรมดา เช่น some เป็นคีย์เวิร์ด แต่ "บาง" เป็นคำ ทั้ง foo และ "foo" เป็นคำ

อย่างไรก็ตาม โปรดระมัดระวังเมื่อใช้เครื่องหมายคำพูดเดี่ยวหรือคู่ในชื่อเป้าหมาย เมื่ออ้างอิงชื่อเป้าหมายอย่างน้อย 1 ชื่อ ให้ใช้เครื่องหมายคำพูดประเภทเดียวเท่านั้น (ไม่ว่าจะเป็นเครื่องหมายคำพูดเดี่ยวทั้งหมดหรือเครื่องหมายคำพูดคู่ทั้งหมด)

ตัวอย่างของสตริงการค้นหา 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
```
เราเลือกไวยากรณ์นี้เพื่อให้ไม่ต้องใช้เครื่องหมายคำพูดในกรณีส่วนใหญ่ ตัวอย่าง (ที่ผิดปกติ) ".*test rule" ต้องมีเครื่องหมายคำพูด เนื่องจากขึ้นต้นด้วยจุดและ มีช่องว่าง การใส่เครื่องหมายคำพูด "cc_library" ไม่จำเป็นแต่ก็ไม่เป็นอันตราย
เครื่องหมายวรรคตอน เช่น วงเล็บ () จุด . และคอมมา , คำที่มีเครื่องหมายวรรคตอน (นอกเหนือจากข้อยกเว้นที่ระบุไว้ข้างต้น) ต้องอยู่ในเครื่องหมายคำพูด

ระบบจะไม่สนใจอักขระช่องว่างที่อยู่นอกคำที่อยู่ในเครื่องหมายคำพูด

แนวคิดของภาษาการค้นหา Bazel

ภาษาการค้นหาของ Bazel เป็นภาษาของนิพจน์ ทุก นิพจน์จะประเมินเป็นชุดเป้าหมายที่เรียงลำดับบางส่วน หรือเทียบเท่ากับกราฟ (DAG) ของเป้าหมาย นี่เป็น ประเภทข้อมูลเดียว

ชุดและกราฟอ้างอิงถึงประเภทข้อมูลเดียวกัน แต่เน้นแง่มุมที่แตกต่างกัน เช่น

ชุด: ลำดับบางส่วนของเป้าหมายไม่น่าสนใจ
กราฟ: ลำดับบางส่วนของเป้าหมายมีความสำคัญ

รอบในกราฟทรัพยากร Dependency

กราฟทรัพยากร Dependency ของบิลด์ควรเป็นแบบไม่มีวงจร

อัลกอริทึมที่ใช้โดยภาษาการค้นหามีไว้สําหรับใช้ใน กราฟแบบไม่มีวงจร แต่มีความทนทานต่อวงจร รายละเอียดเกี่ยวกับวิธีจัดการกับ รอบการเรียกเก็บเงินไม่ได้ระบุไว้และไม่ควรนำมาใช้

ทรัพยากร Dependency โดยนัย

นอกจากการพึ่งพาบิลด์ที่กำหนดไว้อย่างชัดเจนในไฟล์ BUILD แล้ว Bazel ยังเพิ่มการพึ่งพาโดยนัยเพิ่มเติมลงในกฎด้วย เช่น กฎ Java ทุกข้อขึ้นอยู่กับ JavaBuilder โดยนัย การกำหนดการขึ้นต่อกันโดยนัย จะทำโดยใช้แอตทริบิวต์ที่ขึ้นต้นด้วย $ และจะ ลบล้างในไฟล์ BUILD ไม่ได้

โดยค่าเริ่มต้น bazel query จะพิจารณาการอ้างอิงโดยนัย เมื่อคำนวณผลการค้นหา คุณเปลี่ยนลักษณะการทำงานนี้ได้ด้วยตัวเลือก --[no]implicit_deps โปรดทราบว่าเนื่องจากคำค้นหาไม่ได้พิจารณาการกำหนดค่า จึงไม่มีการพิจารณา Toolchain ที่อาจเกิดขึ้น

ความสมบูรณ์

นิพจน์ภาษาการค้นหาของ Bazel ทำงานบนกราฟการขึ้นต่อกันของการสร้าง ซึ่งเป็นกราฟที่กำหนดโดยปริยายจากการประกาศกฎทั้งหมดในไฟล์ BUILD ทั้งหมด โปรดทราบว่า กราฟนี้เป็นนามธรรมและไม่ได้อธิบาย วิธีดำเนินการทุกขั้นตอนของการสร้างอย่างครบถ้วน นอกจากนี้ คุณต้องมีการกำหนดค่าด้วยจึงจะสร้างได้ ดูรายละเอียดเพิ่มเติมได้ที่ส่วนการกำหนดค่า ในคู่มือผู้ใช้

ผลลัพธ์ของการประเมินนิพจน์ในภาษาการค้นหาของ Bazel เป็นจริงสําหรับการกําหนดค่าทั้งหมด ซึ่งหมายความว่าอาจเป็น การประมาณค่าที่สูงเกินจริงแบบอนุรักษ์นิยม และไม่แม่นยำอย่างแน่นอน หากคุณใช้เครื่องมือค้นหาเพื่อคำนวณชุดไฟล์ต้นฉบับทั้งหมดที่จำเป็นในระหว่างการสร้าง เครื่องมืออาจรายงานไฟล์มากกว่าที่จำเป็นจริง ตัวอย่างเช่น เครื่องมือค้นหาจะรวมไฟล์ทั้งหมดที่จำเป็นต่อการรองรับการแปลข้อความ แม้ว่าคุณจะไม่ได้ตั้งใจใช้ฟีเจอร์นั้นในการสร้างก็ตาม

เกี่ยวกับการรักษาลำดับกราฟ

การดำเนินการจะรักษาข้อจำกัดในการจัดเรียง ที่รับช่วงมาจากนิพจน์ย่อย คุณอาจคิดว่า นี่คือ "กฎการอนุรักษ์ลำดับบางส่วน" พิจารณา ตัวอย่าง: หากคุณส่งคำค้นหาเพื่อกำหนดการปิดทรานซิทีฟของ การขึ้นต่อกันของเป้าหมายหนึ่งๆ ชุดผลลัพธ์จะเรียงลำดับ ตามกราฟการขึ้นต่อกัน หากคุณกรองชุดดังกล่าวให้รวมเฉพาะเป้าหมายประเภท file ความสัมพันธ์การเรียงลำดับบางส่วนแบบทรานซิทีฟเดียวกันจะยังคงอยู่ระหว่างเป้าหมายแต่ละคู่ในชุดย่อยที่เป็นผลลัพธ์ แม้ว่าคู่เหล่านี้จะไม่ได้เชื่อมต่อกันโดยตรงในกราฟเดิมก็ตาม (ไม่มีขอบไฟล์ต่อไฟล์ในกราฟการขึ้นต่อกันของการสร้าง)

อย่างไรก็ตาม แม้ว่าโอเปอเรเตอร์ทั้งหมดจะรักษาลำดับไว้ แต่การดำเนินการบางอย่าง เช่น การดำเนินการกับชุดข้อมูล ไม่ได้กำหนดข้อจำกัดในการจัดลำดับของตัวเอง ลองพิจารณานิพจน์นี้

deps(x) union y

ระบบรับประกันว่าลำดับของชุดผลลัพธ์สุดท้ายจะรักษาข้อจำกัดในการจัดลำดับทั้งหมดของนิพจน์ย่อย ซึ่งหมายความว่าการอ้างอิงแบบทรานซิทีฟทั้งหมดของ x จะได้รับการจัดลำดับอย่างถูกต้องเมื่อเทียบกัน อย่างไรก็ตาม การค้นหาไม่ได้รับประกันสิ่งใดเกี่ยวกับการจัดลำดับเป้าหมายใน y หรือเกี่ยวกับการจัดลำดับเป้าหมายใน deps(x) เมื่อเทียบกับเป้าหมายใน y (ยกเว้นเป้าหมายใน y ที่อยู่ใน deps(x) ด้วย)

โอเปอเรเตอร์ที่กำหนดข้อจำกัดในการจัดลำดับ ได้แก่ allpaths, deps, rdeps, somepath และไวลด์การ์ดรูปแบบเป้าหมาย package:*, dir/... ฯลฯ

คำค้นหาเกี่ยวกับท้องฟ้า

Sky Query เป็นโหมดการค้นหาที่ทำงานในขอบเขตของจักรวาลที่ระบุ

ฟังก์ชันพิเศษที่ใช้ได้ใน SkyQuery เท่านั้น

โหมดการค้นหาท้องฟ้ามีฟังก์ชันการค้นหาเพิ่มเติม allrdeps และ rbuildfiles ฟังก์ชันเหล่านี้ทํางานในขอบเขตของทั้ง จักรวาล (ซึ่งเป็นเหตุผลที่ฟังก์ชันเหล่านี้ไม่เหมาะสําหรับการค้นหาปกติ)

การระบุขอบเขตของจักรวาล

ระบบจะเปิดใช้งานโหมด Sky Query โดยการส่ง 2 แฟล็กต่อไปนี้ (--universe_scope หรือ --infer_universe_scope) และ --order_output=no --universe_scope=<target_pattern1>,...,<target_patternN> บอกให้คำค้นหา โหลดล่วงหน้าการปิดทรานซิทีฟของรูปแบบเป้าหมายที่ระบุโดยรูปแบบเป้าหมาย ซึ่งอาจ เป็นการเพิ่มและลบ จากนั้นระบบจะประเมินการค้นหาทั้งหมดใน "ขอบเขต" นี้ โดยเฉพาะโอเปอเรเตอร์ allrdeps และ rbuildfiles จะแสดงผลลัพธ์จากขอบเขตนี้เท่านั้น --infer_universe_scope บอกให้ Bazel อนุมานค่าสำหรับ --universe_scope จากนิพจน์การค้นหา ค่าที่อนุมานนี้คือรายการรูปแบบเป้าหมายที่ไม่ซ้ำกันใน นิพจน์การค้นหา แต่อาจไม่ใช่สิ่งที่คุณต้องการ เช่น

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

รายการรูปแบบเป้าหมายที่ไม่ซ้ำกันในนิพจน์การค้นหานี้คือ ["//my:target"] ดังนั้น Bazel จะถือว่ารายการนี้เหมือนกับการเรียกใช้ต่อไปนี้

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

แต่ผลลัพธ์ของคำค้นหานั้นที่มี --universe_scope คือ //my:target เท่านั้น เนื่องจากไม่มีการขึ้นต่อกันแบบย้อนกลับของ //my:target ในจักรวาล ตามโครงสร้าง ในทางกลับกัน ลองพิจารณาสิ่งต่อไปนี้

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

นี่คือการเรียกใช้คำค้นหาที่มีความหมายซึ่งพยายามคำนวณเป้าหมายการทดสอบใน tests การขยายเป้าหมายภายใต้ไดเรกทอรีบางรายการที่ ขึ้นอยู่กับเป้าหมายแบบทรานซิทีฟซึ่งคำจำกัดความใช้ไฟล์ .bzl บางไฟล์ ในกรณีนี้ --infer_universe_scope จะช่วยอำนวยความสะดวก โดยเฉพาะในกรณีที่การเลือก --universe_scope จะทำให้คุณต้องแยกวิเคราะห์นิพจน์การค้นหาด้วยตนเอง

ดังนั้น สำหรับนิพจน์การค้นหาที่ใช้ตัวดำเนินการที่มีขอบเขตระดับ Universe เช่น allrdeps และ rbuildfiles โปรดใช้ --infer_universe_scope เฉพาะในกรณีที่ลักษณะการทำงานเป็นสิ่งที่คุณต้องการ

Sky Query มีข้อดีและข้อเสียบางอย่างเมื่อเทียบกับคำค้นหาเริ่มต้น ข้อเสียหลักคือไม่สามารถจัดเรียงเอาต์พุตตามลำดับกราฟได้ จึงห้ามใช้รูปแบบเอาต์พุตบางอย่าง ข้อดีของฟีเจอร์นี้คือมีโอเปอเรเตอร์ 2 ตัว (allrdeps และ rbuildfiles) ที่ไม่มีในคำค้นหาเริ่มต้น นอกจากนี้ Sky Query ยังทำงานโดยการตรวจสอบกราฟ Skyframe แทนที่จะสร้างกราฟใหม่ ซึ่งเป็นสิ่งที่การติดตั้งใช้งานเริ่มต้นทำ ดังนั้น ในบางกรณี การใช้ฟีเจอร์นี้จะเร็วกว่าและใช้หน่วยความจำน้อยกว่า

นิพจน์: ไวยากรณ์และความหมายของไวยากรณ์

นี่คือไวยากรณ์ของภาษาที่ใช้ค้นหาของ Bazel ซึ่งแสดงในสัญกรณ์ 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 ... ')'

ส่วนต่อไปนี้จะอธิบายการสร้างไวยากรณ์นี้แต่ละรายการตามลำดับ

รูปแบบเป้าหมาย

expr ::= word

ในทางไวยากรณ์ รูปแบบเป้าหมายเป็นเพียงคำเดียว โดยจะตีความเป็นชุดเป้าหมาย (ที่ไม่มีลำดับ) รูปแบบเป้าหมายที่ง่ายที่สุดคือป้ายกำกับ ซึ่ง ระบุเป้าหมายเดียว (ไฟล์หรือกฎ) เช่น รูปแบบเป้าหมาย //foo:bar จะประเมินเป็นชุดที่มีองค์ประกอบ 1 รายการ ซึ่งก็คือเป้าหมาย กฎ bar

รูปแบบเป้าหมายจะสรุปป้ายกำกับให้รวมไวลด์การ์ดไว้ในแพ็กเกจและ เป้าหมาย เช่น foo/...:all (หรือ foo/...) คือรูปแบบเป้าหมาย ที่ประเมินค่าเป็นชุดที่มีกฎทั้งหมดในทุกแพ็กเกจแบบเรียกซ้ำ ภายใต้ไดเรกทอรี foo ส่วน bar/baz:all คือรูปแบบเป้าหมายที่ประเมินค่า เป็นชุดที่มีกฎทั้งหมดในแพ็กเกจ bar/baz แต่ไม่ใช่ แพ็กเกจย่อย

ในทำนองเดียวกัน foo/...:* คือรูปแบบเป้าหมายที่ประเมินค่าเป็นชุดที่มี เป้าหมาย (กฎและไฟล์) ทั้งหมดในทุกแพ็กเกจแบบเรียกซ้ำภายใต้ ไดเรกทอรี foo ส่วน bar/baz:* จะประเมินค่าเป็นชุดที่มีเป้าหมายทั้งหมดใน แพ็กเกจ bar/baz แต่ไม่ใช่แพ็กเกจย่อย

เนื่องจากไวลด์การ์ด :* จะจับคู่ทั้งไฟล์และกฎ จึงมักมีประโยชน์มากกว่า :all สำหรับการค้นหา ในทางกลับกัน ไวล์ดการ์ด :all (ซึ่งอยู่ในรูปแบบเป้าหมาย เช่น foo/...) มักจะมีประโยชน์มากกว่าสำหรับการสร้าง

bazel queryรูปแบบเป้าหมายทํางานเหมือนกับbazel buildเป้าหมายการสร้าง ดูรายละเอียดเพิ่มเติมได้ที่รูปแบบเป้าหมาย หรือ พิมพ์ bazel help target-syntax

รูปแบบเป้าหมายอาจประเมินเป็นชุดแบบเอกพจน์ (ในกรณีของป้ายกำกับ) เป็นชุดที่มีองค์ประกอบจำนวนมาก (เช่น ในกรณีของ foo/... ซึ่งมีองค์ประกอบหลายพันรายการ) หรือเป็นชุดว่าง หากรูปแบบเป้าหมายไม่ตรงกับเป้าหมายใดเลย

โหนดทั้งหมดในผลลัพธ์ของนิพจน์รูปแบบเป้าหมายจะได้รับการจัดเรียงอย่างถูกต้อง โดยสัมพันธ์กันตามความสัมพันธ์ของการอ้างอิง ดังนั้น ผลลัพธ์ของ foo:* ไม่ใช่แค่ชุดเป้าหมายในแพ็กเกจ foo แต่ยังเป็นกราฟของเป้าหมายเหล่านั้นด้วย (ไม่มีการรับประกันเกี่ยวกับการจัดลำดับที่สัมพันธ์กัน ของโหนดผลลัพธ์กับโหนดอื่นๆ) ดูรายละเอียดเพิ่มเติมได้ที่ส่วนลำดับกราฟ

ตัวแปร

expr ::= let name = expr₁ in expr₂
       | $name

ภาษาการค้นหาของ Bazel อนุญาตให้กำหนดและอ้างอิง ตัวแปร ผลลัพธ์ของการประเมินนิพจน์ let จะเหมือนกับ expr₂ โดยจะแทนที่ตัวแปร name ที่เกิดขึ้นทั้งหมด ด้วยค่าของ expr₁

เช่น let v = foo/... in allpaths($v, //common) intersect $v มีค่าเท่ากับ allpaths(foo/...,//common) intersect foo/...

การอ้างอิงตัวแปร name ที่ไม่ได้อยู่ในนิพจน์ let name = ... ที่ครอบคลุมถือเป็นข้อผิดพลาด กล่าวคือ นิพจน์การค้นหาระดับบนสุดต้องไม่มีตัวแปรอิสระ

ในการสร้างไวยากรณ์ข้างต้น name จะเหมือนกับ word แต่มีข้อจำกัดเพิ่มเติมคือต้องเป็นตัวระบุที่ถูกต้องตามกฎหมายในภาษาโปรแกรม C การอ้างอิงตัวแปรต้องขึ้นต้นด้วยอักขระ "$"

let แต่ละนิพจน์จะกำหนดตัวแปรเพียงตัวเดียว แต่คุณสามารถซ้อนนิพจน์ได้

ทั้งรูปแบบเป้าหมายและการอ้างอิงตัวแปรประกอบด้วย โทเค็นเดียว ซึ่งเป็นคำหนึ่งคำ ทำให้เกิดความกำกวมทางไวยากรณ์ อย่างไรก็ตาม จะไม่มีความคลุมเครือทางความหมายเนื่องจากเซตย่อยของคำที่เป็นชื่อตัวแปรที่ถูกต้องตามกฎหมาย จะแยกออกจากเซตย่อยของคำที่เป็นรูปแบบเป้าหมายที่ถูกต้องตามกฎหมาย

ในทางเทคนิคแล้ว let นิพจน์ไม่ได้เพิ่ม ความสามารถในการแสดงออกของภาษาการค้นหา การค้นหาใดๆ ที่แสดงออกใน ภาษาดังกล่าวสามารถแสดงออกได้โดยไม่ต้องใช้นิพจน์ อย่างไรก็ตาม การใช้ตัวย่อจะช่วยให้คำค้นหาหลายคำกระชับขึ้น และอาจช่วยให้การประเมินคำค้นหามีประสิทธิภาพมากขึ้นด้วย

นิพจน์ในวงเล็บ

expr ::= (expr)

วงเล็บจะเชื่อมโยงนิพจน์ย่อยเพื่อบังคับลำดับการประเมิน นิพจน์ในวงเล็บจะประเมินค่าเป็นค่าของอาร์กิวเมนต์

การดำเนินการกับเซตพีชคณิต: อินเตอร์เซกชัน ยูเนียน ผลต่างของเซต

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

ตัวดำเนินการทั้ง 3 นี้จะคำนวณการดำเนินการชุดข้อมูลตามปกติกับอาร์กิวเมนต์ โอเปอเรเตอร์แต่ละตัวมี 2 รูปแบบ ได้แก่ รูปแบบตามชื่อ เช่น intersect และรูปแบบสัญลักษณ์ เช่น ^ ทั้ง 2 รูปแบบมีความหมายเหมือนกัน แต่รูปแบบสัญลักษณ์จะ พิมพ์ได้เร็วกว่า (เพื่อความชัดเจน ส่วนที่เหลือของหน้านี้จะใช้รูปแบบนาม)

ตัวอย่างเช่น

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

ประเมินเป็นชุดเป้าหมายที่ตรงกับ foo/... แต่ไม่ตรงกับ foo/bar/...

คุณเขียนคำค้นหาเดียวกันได้ดังนี้

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

การดำเนินการ intersect (^) และ union (+) เป็นการดำเนินการสลับที่ (สมมาตร) except (-) เป็นการดำเนินการแบบอสมมาตร ตัวแยกวิเคราะห์จะถือว่าโอเปอเรเตอร์ทั้ง 3 ตัวเป็น การเชื่อมโยงจากซ้ายและมีลำดับความสำคัญเท่ากัน ดังนั้นคุณอาจต้องใช้เครื่องหมายวงเล็บ ตัวอย่างเช่น สองนิพจน์แรกมีความหมายเหมือนกัน แต่ตัวที่สามไม่เหมือน

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

อ่านเป้าหมายจากแหล่งที่มาภายนอก: ตั้งค่า

expr ::= set(word *)

ตัวดำเนินการ set(a b c ...) จะคำนวณการรวมชุดของรูปแบบเป้าหมายตั้งแต่ 0 รายการขึ้นไป โดยคั่นด้วยช่องว่าง (ไม่มีคอมมา)

เมื่อใช้ร่วมกับฟีเจอร์ $(...) ของ Bourne Shell set() จะเป็นวิธีบันทึกผลลัพธ์ของการค้นหาหนึ่งๆ ในไฟล์ข้อความปกติ จัดการไฟล์ข้อความนั้นโดยใช้โปรแกรมอื่นๆ (เช่น เครื่องมือ Shell มาตรฐานของ UNIX) แล้วนำผลลัพธ์กลับไปใส่ในเครื่องมือค้นหาเป็นค่าสำหรับการประมวลผลเพิ่มเติม เช่น

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

ในตัวอย่างถัดไปkind(cc_library, deps(//some_dir/foo:main, 5)) จะ คำนวณโดยการกรองค่า maxrank โดยใช้โปรแกรม awk

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

ในตัวอย่างเหล่านี้ $(<foo) เป็นรูปแบบย่อของ $(cat foo) แต่คุณอาจใช้คำสั่ง Shell อื่นๆ นอกเหนือจาก cat ได้เช่นกัน เช่น คำสั่ง awk ก่อนหน้า

ฟังก์ชัน

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

ภาษาการค้นหาจะกำหนดฟังก์ชันหลายอย่าง ชื่อของฟังก์ชัน จะกำหนดจำนวนและประเภทของอาร์กิวเมนต์ที่ต้องใช้ ฟังก์ชันต่อไปนี้พร้อมใช้งาน

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

การปิดการเปลี่ยนผ่านของทรัพยากร Dependency: deps

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

ตัวดำเนินการ deps(x) จะประเมินค่าเป็นกราฟที่สร้างขึ้น โดยการปิดทรานซิทีฟของชุดอาร์กิวเมนต์ x เช่น ค่าของ deps(//foo) คือ กราฟการอ้างอิงที่เริ่มต้นที่โหนดเดียว foo รวมถึงการอ้างอิงทั้งหมด ค่าของ deps(foo/...) คือกราฟการขึ้นต่อกันที่มีรูทเป็นกฎทั้งหมดในทุกแพ็กเกจที่อยู่ใต้ไดเรกทอรี foo ในบริบทนี้ "การอ้างอิง" หมายถึงเป้าหมายกฎและไฟล์เท่านั้น ดังนั้นไฟล์ BUILD และ Starlark ที่จำเป็นในการสร้างเป้าหมายเหล่านี้จึงไม่ได้รวมไว้ที่นี่ ในกรณีนี้ คุณควรใช้โอเปอเรเตอร์ buildfiles

กราฟที่ได้จะจัดเรียงตามความสัมพันธ์ของทรัพยากร Dependency ดูรายละเอียดเพิ่มเติมได้ที่ส่วนลำดับกราฟ

ตัวดำเนินการ deps รับอาร์กิวเมนต์ที่ 2 ที่ไม่บังคับ ซึ่งเป็นจำนวนเต็ม ตามตัวอักษรที่ระบุขอบเขตบนของความลึกของการค้นหา ดังนั้น deps(foo:*, 0) จะแสดงเป้าหมายทั้งหมดในแพ็กเกจ foo ขณะที่ deps(foo:*, 1) จะรวมข้อกำหนดเบื้องต้นโดยตรงของเป้าหมายใดก็ตามในแพ็กเกจ foo และ deps(foo:*, 2) จะรวมโหนดที่เข้าถึงได้โดยตรงจากโหนดใน deps(foo:*, 1) และอื่นๆ (ตัวเลขเหล่านี้ สอดคล้องกับอันดับที่แสดงในรูปแบบเอาต์พุต minrank) หากละเว้นพารามิเตอร์ depth การค้นหาจะ ไม่จำกัด: โดยจะคำนวณการปิดการเปลี่ยนผ่านแบบรีเฟล็กซีฟของข้อกำหนดเบื้องต้น

การปิดทรานซิทีฟของการขึ้นต่อกันแบบย้อนกลับ: rdeps

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

ตัวดำเนินการ rdeps(u, x) จะประเมินการขึ้นต่อกันแบบย้อนกลับของชุดอาร์กิวเมนต์ x ภายในทรานซิทีฟโคลเชอร์ของชุดจักรวาล u

โอเปอเรเตอร์ rdeps รับอาร์กิวเมนต์ที่ 3 ที่ไม่บังคับ ซึ่งเป็นจำนวนเต็ม ตามตัวอักษรที่ระบุขอบเขตบนของความลึกของการค้นหา กราฟที่ได้จะมีเฉพาะโหนดที่อยู่ภายในระยะทางของความลึกที่ระบุจากโหนดใดๆ ในชุดอาร์กิวเมนต์ ดังนั้น rdeps(//foo, //common, 1) จะประเมินเป็นโหนดทั้งหมด ใน Closure แบบทรานซิทีฟของ //foo ที่ขึ้นอยู่กับ //common โดยตรง (ตัวเลขเหล่านี้ ตรงกับอันดับที่แสดงในรูปแบบเอาต์พุต minrank ) หากละเว้นพารามิเตอร์ depth การค้นหาจะไม่มีขอบเขต

การปิดทรานซิทีฟของทรัพยากร Dependency แบบย้อนกลับทั้งหมด: allrdeps

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

โอเปอเรเตอร์ allrdeps ทำงานเหมือนกับโอเปอเรเตอร์ rdeps ทุกประการ ยกเว้นว่า "ชุดจักรวาล" คือค่าที่ได้จากการประเมินแฟล็ก --universe_scope แทนที่จะระบุแยกกัน ดังนั้น หากส่ง --universe_scope=//foo/... แล้ว allrdeps(//bar) จะ เทียบเท่ากับ rdeps(//foo/..., //bar)

การอ้างอิงย้อนกลับโดยตรงในแพ็กเกจเดียวกัน: same_pkg_direct_rdeps

expr ::= same_pkg_direct_rdeps(expr)

โอเปอเรเตอร์ same_pkg_direct_rdeps(x) จะประเมินเป้าหมายทั้งหมด ที่อยู่ในแพ็กเกจเดียวกันกับเป้าหมายในชุดอาร์กิวเมนต์ และขึ้นอยู่กับเป้าหมายนั้นโดยตรง

การจัดการแพ็กเกจของเป้าหมาย: พี่น้อง

expr ::= siblings(expr)

โอเปอเรเตอร์ siblings(x) จะประเมินเป็นชุดเป้าหมายทั้งหมดที่อยู่ใน แพ็กเกจเดียวกันกับเป้าหมายในชุดอาร์กิวเมนต์

การเลือกโดยพลการ: บางส่วน

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

โอเปอเรเตอร์ some(x, k) เลือกเป้าหมายอย่างน้อย k รายการจากชุดอาร์กิวเมนต์ x และประเมินเป็นชุดที่มีเฉพาะเป้าหมายเหล่านั้น พารามิเตอร์ k เป็นพารามิเตอร์ที่ไม่บังคับ หากไม่มี ผลลัพธ์จะเป็นชุดแบบเดี่ยวที่มีเป้าหมายเพียงรายการเดียว ซึ่งเลือกโดยพลการ หากขนาดของชุดอาร์กิวเมนต์ x มีขนาดเล็กกว่า k ระบบจะแสดงผลชุดอาร์กิวเมนต์ทั้งหมด x

เช่น นิพจน์ some(//foo:main union //bar:baz) จะประเมินเป็นชุดค่าเดียวที่มี //foo:main หรือ //bar:baz แม้ว่าจะไม่ได้กำหนดว่าจะเป็นค่าใดก็ตาม นิพจน์ some(//foo:main union //bar:baz, 2) หรือ some(//foo:main union //bar:baz, 3) จะแสดงผลทั้ง //foo:main และ //bar:baz

หากอาร์กิวเมนต์เป็นค่าเดียว some จะคำนวณฟังก์ชันเอกลักษณ์: some(//foo:main) จะ เทียบเท่ากับ //foo:main

หากชุดอาร์กิวเมนต์ที่ระบุว่างเปล่า จะถือว่าเป็นข้อผิดพลาด เช่น ใน นิพจน์ some(//foo:main intersect //bar:baz)

ตัวดำเนินการเส้นทาง: somepath, allpaths

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

โอเปอเรเตอร์ somepath(S, E) และ allpaths(S, E) จะคำนวณเส้นทางระหว่างเป้าหมาย 2 ชุด ทั้ง 2 คำค้นหารับอาร์กิวเมนต์ 2 รายการ ได้แก่ ชุดSจุดเริ่มต้นและชุดEจุดสิ้นสุด somepath จะแสดงกราฟของโหนดในเส้นทางที่กำหนดบางเส้นทางจากเป้าหมายใน S ไปยังเป้าหมายใน E allpaths จะแสดงกราฟของโหนดในทุกเส้นทางจากเป้าหมายใดก็ตามใน S ไปยังเป้าหมายใดก็ตามใน E

การกรองประเภทเป้าหมาย: ประเภท

expr ::= kind(word, expr)

kind(pattern, input) โอเปอเรเตอร์จะใช้ตัวกรองกับชุดเป้าหมาย และทิ้งเป้าหมายเหล่านั้น ที่ไม่ได้เป็นประเภทที่คาดไว้ pattern พารามิเตอร์ระบุประเภทเป้าหมายที่จะจับคู่

ตัวอย่างเช่น ตารางด้านล่างแสดงประเภทของเป้าหมายทั้ง 4 รายการที่กำหนดโดยไฟล์ BUILD (สำหรับแพ็กเกจ p)

รหัส	เป้าหมาย	ชนิด
genrule( name = "a", srcs = ["a.in"], outs = ["a.out"], cmd = "...", )	`//p:a`	กฎ genrule
	`//p:a.in`	ไฟล์ต้นฉบับ
	`//p:a.out`	ไฟล์ที่สร้างขึ้น
	`//p:BUILD`	ไฟล์ต้นฉบับ

ดังนั้น kind("cc_.* rule", foo/...) จะประเมินเป็นชุด ของเป้าหมายกฎทั้งหมด cc_library, cc_binary ฯลฯ ภายใต้ foo และ kind("source file", deps(//foo)) จะประเมินเป็นชุดของไฟล์ต้นฉบับทั้งหมดในการปิดการเปลี่ยนผ่าน ของการอ้างอิงของเป้าหมาย //foo

มักต้องมีการอ้างอิงอาร์กิวเมนต์ pattern เนื่องจากหากไม่มีอาร์กิวเมนต์นี้ ตัวแยกวิเคราะห์จะไม่ถือว่านิพจน์ทั่วไปหลายรายการ เช่น source file และ .*_test เป็นคำ

เมื่อจับคู่สำหรับ package group เป้าหมายที่ลงท้ายด้วย :all อาจไม่แสดงผลลัพธ์ใดๆ โปรดใช้ :all-targets แทน

การกรองชื่อเป้าหมาย: กรอง

expr ::= filter(word, expr)

โอเปอเรเตอร์ filter(pattern, input) จะใช้ตัวกรองกับชุดเป้าหมาย และทิ้งเป้าหมายที่มี ป้ายกำกับ (ในรูปแบบสัมบูรณ์) ไม่ตรงกับรูปแบบ โดยจะ ประเมินเป็นชุดย่อยของอินพุต

อาร์กิวเมนต์แรก pattern คือคำที่มีนิพจน์ทั่วไปเกี่ยวกับชื่อเป้าหมาย filter นิพจน์ จะประเมินเป็นชุดที่มีเป้าหมายทั้งหมด x โดยที่ x เป็นสมาชิกของชุด input และ ป้ายกำกับ (ในรูปแบบสัมบูรณ์ เช่น //foo:bar) ของ x มีการจับคู่ (แบบไม่มีการยึด) สำหรับนิพจน์ทั่วไป pattern เนื่องจากชื่อเป้าหมายทั้งหมดเริ่มต้นด้วย // จึงอาจใช้เป็นทางเลือกแทน จุดยึดนิพจน์ทั่วไป ^

โดยโอเปอเรเตอร์นี้มักจะเป็นทางเลือกที่รวดเร็วและมีประสิทธิภาพมากกว่าโอเปอเรเตอร์ intersect เช่น หากต้องการดูการขึ้นต่อกันทั้งหมดของเป้าหมาย //foo:foo คุณสามารถประเมินbar

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

อย่างไรก็ตาม คำสั่งนี้จะต้องแยกวิเคราะห์ไฟล์ BUILD ทั้งหมดในโครงสร้าง bar ซึ่งจะช้าและมีแนวโน้มที่จะเกิดข้อผิดพลาดในไฟล์ BUILD ที่ไม่เกี่ยวข้อง หรือคุณอาจทำดังนี้

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

ซึ่งจะคำนวณชุด//fooการอ้างอิงก่อน จากนั้นจะกรองเฉพาะเป้าหมายที่ตรงกับรูปแบบที่ระบุ กล่าวคือ เป้าหมายที่มีชื่อซึ่งมี //bar เป็นสตริงย่อย

การใช้ตัวดำเนินการ filter(pattern, expr) อีกอย่างที่พบบ่อยคือการกรองไฟล์ที่เฉพาะเจาะจงตามชื่อหรือส่วนขยาย ตัวอย่างเช่น

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

จะแสดงรายการ.ccไฟล์ทั้งหมดที่ใช้สร้าง //foo

การกรองแอตทริบิวต์ของกฎ: attr

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

attr(name, pattern, input) ตัวดำเนินการจะใช้ตัวกรองกับชุดเป้าหมาย และทิ้งเป้าหมายที่ไม่ใช่ กฎ เป้าหมายกฎที่ไม่ได้กำหนดแอตทริบิวต์ name หรือเป้าหมายกฎที่ค่าแอตทริบิวต์ไม่ตรงกับนิพจน์ทั่วไปที่ระบุ pattern โดยจะประเมิน เป็นชุดย่อยของอินพุต

อาร์กิวเมนต์แรก name คือชื่อของแอตทริบิวต์กฎ ที่ควรจับคู่กับรูปแบบนิพจน์ทั่วไปที่ระบุ อาร์กิวเมนต์ที่ 2 pattern คือนิพจน์ทั่วไปสำหรับค่าแอตทริบิวต์ attr นิพจน์จะประเมินเป็นชุดที่มีเป้าหมายทั้งหมด x โดยที่ x เป็น สมาชิกของชุด input เป็นกฎที่มีแอตทริบิวต์ที่กำหนด name และค่าแอตทริบิวต์มีการจับคู่ (ไม่มีการยึด) สำหรับนิพจน์ทั่วไป pattern หาก name เป็นแอตทริบิวต์ที่ไม่บังคับและกฎไม่ได้ระบุอย่างชัดเจน ระบบจะใช้ค่าแอตทริบิวต์เริ่มต้นสำหรับการเปรียบเทียบ ตัวอย่างเช่น

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

จะเลือกการขึ้นต่อกันของ //foo ทั้งหมดที่ได้รับอนุญาตให้มีแอตทริบิวต์ linkshared (เช่น กฎ cc_binary) และตั้งค่าเป็น 0 อย่างชัดเจน หรือไม่ตั้งค่าเลย แต่ค่าเริ่มต้นคือ 0 (เช่น สำหรับกฎ cc_binary)

แอตทริบิวต์ประเภทรายการ (เช่น srcs, data ฯลฯ) จะ แปลงเป็นสตริงในรูปแบบ [value<sub>1</sub>, ..., value<sub>n</sub>] โดย ขึ้นต้นด้วยวงเล็บ [ ลงท้ายด้วยวงเล็บ ] และใช้ "," (คอมมา ตามด้วยช่องว่าง) เพื่อคั่นค่าหลายค่า ระบบจะแปลงป้ายกำกับเป็นสตริงโดยใช้รูปแบบสัมบูรณ์ของ ป้ายกำกับ เช่น ระบบจะแปลงแอตทริบิวต์ deps=[":foo", "//otherpkg:bar", "wiz"] เป็นสตริง [//thispkg:foo, //otherpkg:bar, //thispkg:wiz] วงเล็บจะปรากฏอยู่เสมอ ดังนั้นรายการที่ว่างเปล่าจะใช้ค่าสตริง [] เพื่อวัตถุประสงค์ในการจับคู่ ตัวอย่างเช่น

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

จะเลือกกฎทั้งหมดใน//fooทรัพยากร Dependency ที่มีแอตทริบิวต์srcsว่าง ในขณะที่

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

จะเลือกกฎทั้งหมดในกลุ่มการขึ้นต่อกันของ //foo ที่ระบุค่าอย่างน้อย 1 ค่าในแอตทริบิวต์ data (ป้ายกำกับทุกรายการมีความยาวอย่างน้อย 3 อักขระเนื่องจาก // และ :)

หากต้องการเลือกกฎทั้งหมดใน//fooการอ้างอิงที่มีvalueเฉพาะในแอตทริบิวต์ประเภทรายการ ให้ใช้

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

วิธีนี้ใช้ได้เนื่องจากอักขระก่อน value จะเป็น [ หรือช่องว่าง และอักขระหลัง value จะเป็นคอมมาหรือ ]

การกรองระดับการเข้าถึงของกฎ: visible

expr ::= visible(expr, expr)

โอเปอเรเตอร์ visible(predicate, input) ใช้ตัวกรองกับชุดเป้าหมาย และทิ้งเป้าหมายที่ไม่มี ระดับการมองเห็นที่จำเป็น

อาร์กิวเมนต์แรก predicate คือชุดเป้าหมายที่เป้าหมายทั้งหมด ในเอาต์พุตต้องมองเห็นได้ visibleนิพจน์ จะประเมินเป็นชุดที่มีเป้าหมายทั้งหมด x โดยที่ x เป็นสมาชิกของชุด input และเป้าหมายทั้งหมด y ใน predicate x จะมองเห็น y เช่น

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

จะเลือกเป้าหมายทั้งหมดในแพ็กเกจ //bar ที่ //foo สามารถขึ้นอยู่กับได้โดยไม่ละเมิดข้อจำกัดด้านการมองเห็น

การประเมินแอตทริบิวต์กฎของป้ายกำกับประเภท: ป้ายกำกับ

expr ::= labels(word, expr)

ตัวดำเนินการ labels(attr_name, inputs) จะแสดงผลชุดเป้าหมายที่ระบุใน แอตทริบิวต์ attr_name ของประเภท "ป้ายกำกับ" หรือ "รายการป้ายกำกับ" ใน กฎบางอย่างในชุด inputs

เช่น labels(srcs, //foo) จะแสดงชุดเป้าหมายที่ปรากฏในแอตทริบิวต์ srcs ของกฎ //foo หากมีกฎหลายข้อที่มีแอตทริบิวต์ srcs ในชุด inputs ระบบจะแสดงผลรวมของ srcs

ขยายและกรอง test_suites: tests

expr ::= tests(expr)

ตัวดำเนินการ tests(x) จะแสดงชุดกฎการทดสอบทั้งหมดในชุด x โดยขยายกฎ test_suite ใดๆ ให้เป็นชุดการทดสอบแต่ละรายการที่กฎอ้างอิงถึง และใช้การกรองตาม tag และ size

โดยค่าเริ่มต้น การประเมินคำค้นหา จะละเว้นเป้าหมายที่ไม่ใช่การทดสอบในtest_suiteกฎทั้งหมด คุณเปลี่ยนเป็นข้อผิดพลาดได้โดยใช้ตัวเลือก --strict_test_suite

เช่น การค้นหา kind(test, foo:*) จะแสดงกฎ *_test และ test_suite ทั้งหมด ในแพ็กเกจ foo ผลลัพธ์ทั้งหมดเป็นสมาชิกของfooแพ็กเกจ (ตามคำจำกัดความ) ในทางตรงกันข้าม คำค้นหา tests(foo:*) จะแสดงการทดสอบแต่ละรายการทั้งหมดที่ bazel test foo:* จะดำเนินการ ซึ่งอาจรวมถึงการทดสอบที่เป็นของแพ็กเกจอื่นๆ ที่อ้างอิงโดยตรงหรือโดยอ้อม ผ่านกฎ test_suite

ไฟล์คำจำกัดความของแพ็กเกจ: buildfiles

expr ::= buildfiles(expr)

ตัวดำเนินการ buildfiles(x) จะแสดงชุด ของไฟล์ที่กำหนดแพ็กเกจของแต่ละเป้าหมายใน ชุด x กล่าวคือ สำหรับแต่ละแพ็กเกจ จะมีไฟล์ BUILD รวมถึงไฟล์ .bzl ที่อ้างอิงผ่าน load โปรดทราบว่าการดำเนินการนี้จะแสดงผลBUILDของแพ็กเกจที่มีไฟล์ที่loadแล้วเหล่านี้ด้วย

โดยปกติแล้วจะใช้ตัวดำเนินการนี้เมื่อพิจารณาว่าต้องใช้ไฟล์หรือแพ็กเกจใดในการสร้างเป้าหมายที่ระบุ ซึ่งมักใช้ร่วมกับตัวเลือก --output package (ด้านล่าง) ตัวอย่างเช่น

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

จะแสดงชุดแพ็กเกจทั้งหมดที่ //foo ขึ้นอยู่กับแบบทรานซิทีฟ

ไฟล์คำจำกัดความของแพ็กเกจ: rbuildfiles

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

ตัวดำเนินการ rbuildfiles จะรับรายการส่วนเส้นทางที่คั่นด้วยคอมมาและแสดงชุดไฟล์ BUILD ที่ขึ้นอยู่กับส่วนเส้นทางเหล่านี้โดยอ้อม เช่น หาก //foo เป็นแพ็กเกจ rbuildfiles(foo/BUILD) จะแสดงผลเป้าหมาย //foo:BUILD หากfoo/BUILDมี load('//bar:file.bzl'... rbuildfiles(bar/file.bzl) จะ แสดงเป้าหมาย //foo:BUILD รวมถึงเป้าหมายสำหรับไฟล์ BUILD อื่นๆ ที่โหลด //bar:file.bzl

ขอบเขตของโอเปอเรเตอร์ rbuildfiles คือจักรวาลที่ระบุโดยแฟล็ก --universe_scope ไฟล์ที่ไม่สอดคล้องกับไฟล์ BUILD และไฟล์ .bzl โดยตรงจะไม่ส่งผลต่อผลลัพธ์ เช่น ระบบจะไม่สนใจไฟล์ต้นฉบับ (เช่น foo.cc) แม้ว่าจะมีการระบุไว้อย่างชัดเจนในไฟล์ BUILD อย่างไรก็ตาม ระบบจะพิจารณา Symlink เพื่อให้ หาก foo/BUILD เป็น Symlink ไปยัง bar/BUILD rbuildfiles(bar/BUILD) จะรวม //foo:BUILD ไว้ในผลลัพธ์

โอเปอเรเตอร์ rbuildfiles แทบจะเป็นค่าผกผันของโอเปอเรเตอร์ buildfiles อย่างไรก็ตาม การกลับด้านทางศีลธรรมนี้ มีผลในทิศทางเดียวอย่างชัดเจน นั่นคือ เอาต์พุตของ rbuildfiles จะเหมือนกับ อินพุตของ buildfiles โดยเอาต์พุตของ rbuildfiles จะมีเฉพาะเป้าหมายไฟล์ BUILD ในแพ็กเกจ และอินพุตของ buildfiles อาจมีเป้าหมายดังกล่าว ในทางกลับกัน ความสอดคล้องจะอ่อนลง เอาต์พุตของตัวดำเนินการ buildfiles คือเป้าหมายที่สอดคล้องกับแพ็กเกจทั้งหมดและbzl ไฟล์ที่ต้องใช้สำหรับอินพุตที่ระบุ อย่างไรก็ตาม อินพุตของโอเปอเรเตอร์ rbuildfiles ไม่ใช่เป้าหมายเหล่านั้น แต่เป็นส่วนของเส้นทางที่สอดคล้องกับเป้าหมายเหล่านั้น

ไฟล์คำจำกัดความของแพ็กเกจ: loadfiles

expr ::= loadfiles(expr)

ตัวดำเนินการ loadfiles(x) จะแสดงผลชุดไฟล์ Starlark ที่จำเป็นในการโหลดแพ็กเกจของแต่ละเป้าหมายในชุด x กล่าวคือ สำหรับแต่ละแพ็กเกจ ระบบจะแสดงไฟล์ .bzl ที่อ้างอิงจากไฟล์ BUILD

รูปแบบเอาต์พุต

bazel query จะสร้างกราฟ คุณระบุเนื้อหา รูปแบบ และลำดับที่ bazel query นำเสนอกราฟนี้ โดยใช้ตัวเลือกบรรทัดคำสั่ง --output

เมื่อเรียกใช้ด้วย Sky Query จะอนุญาตเฉพาะรูปแบบเอาต์พุตที่เข้ากันได้กับ เอาต์พุตที่ไม่มีการจัดเรียง โดยเฉพาะอย่างยิ่ง ไม่อนุญาตให้ใช้รูปแบบเอาต์พุต graph, minrank และ maxrank

รูปแบบเอาต์พุตบางรูปแบบยอมรับตัวเลือกเพิ่มเติม ชื่อของ แต่ละตัวเลือกเอาต์พุตจะมีคำนำหน้าเป็นรูปแบบเอาต์พุตที่ตัวเลือกนั้น ใช้ ดังนั้น --graph:factored จะใช้ได้เฉพาะ เมื่อใช้ --output=graph เท่านั้น และจะไม่มีผลหากใช้ รูปแบบเอาต์พุตอื่นที่ไม่ใช่ graph ในทำนองเดียวกัน --xml:line_numbers จะมีผลเมื่อใช้ --output=xml เท่านั้น

เกี่ยวกับการจัดลำดับผลการค้นหา

แม้ว่านิพจน์การค้นหาจะปฏิบัติตาม "กฎ การคงลำดับกราฟ" เสมอ แต่การนำเสนอผลลัพธ์อาจทำได้ ในลักษณะที่เรียงตามการขึ้นต่อกันหรือไม่เรียงก็ได้ ซึ่งไม่มี ผลต่อเป้าหมายในชุดผลลัพธ์หรือวิธีคำนวณการค้นหา แต่จะส่งผลต่อวิธีพิมพ์ผลลัพธ์ไปยัง stdout เท่านั้น นอกจากนี้ โหนดที่มีลำดับการขึ้นต่อกันเหมือนกันอาจเรียงตามตัวอักษรหรือไม่ก็ได้ คุณใช้แฟล็ก --order_output เพื่อควบคุมลักษณะการทำงานนี้ได้ (ธง --[no]order_results มีฟังก์ชันการทำงานบางส่วน ของธง --order_output และเลิกใช้งานแล้ว)

ค่าเริ่มต้นของแฟล็กนี้คือ auto ซึ่งจะพิมพ์ผลลัพธ์ตามลำดับพจนานุกรม อย่างไรก็ตาม เมื่อใช้ somepath(a,b) ระบบจะพิมพ์ผลลัพธ์ตามลำดับ deps แทน

เมื่อตั้งค่าสถานะนี้เป็น no และ --output เป็นค่าใดค่าหนึ่งใน build, label, label_kind, location, package, proto หรือ xml ระบบจะพิมพ์เอาต์พุตตามลำดับที่กำหนดเอง โดยทั่วไปแล้วตัวเลือกนี้เป็นตัวเลือกที่เร็วที่สุด แต่จะไม่รองรับเมื่อ --output เป็นหนึ่งใน graph, minrank หรือ maxrank: ในรูปแบบเหล่านี้ Bazel จะพิมพ์ผลลัพธ์ที่ เรียงตามลำดับการอ้างอิงหรืออันดับเสมอ

เมื่อตั้งค่าสถานะนี้เป็น deps Bazel จะพิมพ์ผลลัพธ์ตามลำดับโทโพโลยีบางอย่าง นั่นคือ การอ้างอิงก่อน อย่างไรก็ตาม โหนดที่ไม่ได้เรียงตามลำดับการขึ้นต่อกัน (เนื่องจากไม่มีเส้นทางจากโหนดหนึ่งไปยังอีกโหนดหนึ่ง) อาจพิมพ์ในลำดับใดก็ได้

เมื่อตั้งค่าสถานะนี้เป็น full Bazel จะพิมพ์โหนดตามลำดับที่กำหนดได้อย่างสมบูรณ์ (ทั้งหมด) ก่อนอื่น ระบบจะจัดเรียงโหนดทั้งหมดตามลำดับตัวอักษร จากนั้น ระบบจะใช้แต่ละโหนดในรายการเป็นจุดเริ่มต้นของ การค้นหาแบบเจาะลึกตามลำดับหลังในกรณีที่ขอบขาออกไปยังโหนดที่ยังไม่ได้เข้าชมจะได้รับการสำรวจตาม ลำดับตัวอักษรของโหนดสืบทอด สุดท้าย ระบบจะพิมพ์โหนดในลำดับย้อนกลับของลำดับ ที่เข้าชม

การพิมพ์โหนดตามลำดับนี้อาจช้ากว่า ดังนั้นจึงควรใช้เฉพาะเมื่อมีความสำคัญ เท่านั้น

พิมพ์รูปแบบแหล่งที่มาของเป้าหมายตามที่ปรากฏใน BUILD

--output build

ตัวเลือกนี้จะทำให้การแสดงแต่ละเป้าหมายเป็นเหมือนการ เขียนด้วยมือในภาษา BUILD ขยายตัวแปรและการเรียกฟังก์ชันทั้งหมด (เช่น glob, มาโคร) ซึ่งมีประโยชน์ในการดูผลลัพธ์ ของมาโคร Starlark นอกจากนี้ กฎที่มีผลแต่ละข้อจะรายงานค่า generator_name และ/หรือ generator_function โดยระบุชื่อของมาโครที่ได้รับการประเมินเพื่อสร้างกฎที่มีผล

แม้ว่าเอาต์พุตจะใช้ไวยากรณ์เดียวกันกับไฟล์ BUILD แต่ก็ไม่รับประกันว่าจะสร้างไฟล์ BUILD ที่ถูกต้อง

พิมพ์ป้ายกำกับของแต่ละเป้าหมาย

--output label

ตัวเลือกนี้จะพิมพ์ชุดชื่อ (หรือป้ายกำกับ) ของแต่ละเป้าหมาย ในกราฟผลลัพธ์ โดยมีป้ายกำกับ 1 รายการต่อบรรทัดใน ลำดับโทโพโลยี (เว้นแต่จะระบุ --noorder_results ดูหมายเหตุเกี่ยวกับการจัดลำดับผลลัพธ์) (การเรียงลำดับโทโพโลยีคือการเรียงลำดับที่โหนดกราฟ ปรากฏก่อนโหนดทั้งหมดที่ต่อจากโหนดนั้น) แน่นอนว่ากราฟมีลำดับโทโพโลยีที่เป็นไปได้หลายแบบ (การเรียงลำดับหลังการเยี่ยมชมแบบย้อนกลับเป็นเพียงแบบเดียว) และไม่ได้ระบุว่าระบบจะเลือกแบบใด

เมื่อพิมพ์เอาต์พุตของsomepathการค้นหา ลำดับ ที่พิมพ์โหนดคือลำดับของเส้นทาง

ข้อควรระวัง: ในบางกรณีอาจมีเป้าหมายที่แตกต่างกัน 2 รายการที่มีป้ายกำกับเดียวกัน เช่น sh_binaryกฎและsrcsไฟล์เดียว (โดยนัย) อาจมีชื่อว่า foo.sh หากผลลัพธ์ของการค้นหามีทั้ง 2 เป้าหมายนี้ เอาต์พุต (ในรูปแบบ label) จะปรากฏขึ้น เพื่อระบุว่ามีรายการที่ซ้ำกัน เมื่อใช้รูปแบบ label_kind (ดู ด้านล่าง) ความแตกต่างจะชัดเจนขึ้น โดยเป้าหมายทั้ง 2 รายการมีชื่อเดียวกัน แต่รายการหนึ่งมีประเภท sh_binary rule และอีกรายการมีประเภท source file

พิมพ์ป้ายกำกับและประเภทของเป้าหมายแต่ละรายการ

--output label_kind

เช่นเดียวกับ label รูปแบบเอาต์พุตนี้จะพิมพ์ป้ายกำกับของ แต่ละเป้าหมายในกราฟผลลัพธ์ตามลำดับโทโพโลยี แต่จะ นำหน้าป้ายกำกับด้วยประเภทของเป้าหมาย

พิมพ์ป้ายกำกับของแต่ละเป้าหมายตามลำดับการจัดอันดับ

--output minrank --output maxrank

เช่นเดียวกับ label รูปแบบเอาต์พุต minrank และ maxrank จะพิมพ์ป้ายกำกับของแต่ละเป้าหมาย ในกราฟผลลัพธ์ แต่แทนที่จะปรากฏตาม ลำดับโทโพโลยี ป้ายกำกับจะปรากฏตามลำดับการจัดอันดับ โดยมี หมายเลขการจัดอันดับนำหน้า โดยการจัดลำดับผลการค้นหาจะไม่ส่งผลต่อรายการเหล่านี้ --[no]order_results (ดูหมายเหตุเกี่ยวกับ การจัดลำดับผลการค้นหา)

รูปแบบนี้มี 2 รูปแบบ ได้แก่ minrank จัดอันดับ แต่ละโหนดตามความยาวของเส้นทางที่สั้นที่สุดจากโหนดรูทไปยังโหนดนั้น โหนด "รูท" (โหนดที่ไม่มีขอบขาเข้า) มีอันดับ 0 โหนดที่สืบทอดมีอันดับ 1 ฯลฯ (เช่นเคย ขอบจะชี้จาก เป้าหมายไปยังข้อกำหนดเบื้องต้น ซึ่งก็คือเป้าหมายที่ขึ้นอยู่กับ)

maxrank จัดอันดับแต่ละโหนดตามความยาวของเส้นทางที่ยาวที่สุด จากโหนดรูทไปยังโหนดนั้น อีกครั้งที่ "รูท" มีอันดับ 0 ส่วนโหนดอื่นๆ ทั้งหมด จะมีอันดับที่มากกว่าอันดับสูงสุดของ โหนดก่อนหน้าทั้งหมดอยู่ 1

โดยถือว่าโหนดทั้งหมดในวงจรมีอันดับเท่ากัน (กราฟส่วนใหญ่เป็นแบบ ไม่มีวงจร แต่ก็มีวงจรเกิดขึ้น เนื่องจากไฟล์ BUILD มีวงจรที่ผิดพลาด)

รูปแบบเอาต์พุตเหล่านี้มีประโยชน์ในการค้นหาว่ากราฟมีความลึกเพียงใด หากใช้กับผลลัพธ์ของคำค้นหา deps(x), rdeps(x) หรือ allpaths หมายเลขอันดับจะเท่ากับ ความยาวของเส้นทางที่สั้นที่สุด (มี minrank) หรือยาวที่สุด (มี maxrank) จาก x ไปยังโหนดใน อันดับนั้น maxrank สามารถใช้เพื่อกำหนดลำดับขั้นตอนการสร้างที่ยาวที่สุดที่จำเป็นในการสร้างเป้าหมายได้

เช่น กราฟทางด้านซ้ายจะให้เอาต์พุตทางด้านขวา เมื่อระบุ --output minrank และ --output maxrank ตามลำดับ

      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

เช่น label_kind ตัวเลือกนี้จะพิมพ์ประเภทและป้ายกำกับของเป้าหมายแต่ละรายการในผลลัพธ์ แต่จะนำหน้าด้วยสตริงที่อธิบายตำแหน่งของเป้าหมายนั้นเป็นชื่อไฟล์และหมายเลขบรรทัด รูปแบบจะคล้ายกับเอาต์พุตของ grep ดังนั้น เครื่องมือที่แยกวิเคราะห์ข้อมูลหลังได้ (เช่น Emacs หรือ vi) ก็ใช้เอาต์พุตการค้นหาเพื่อดูชุดการจับคู่ ได้เช่นกัน ทำให้ใช้เครื่องมือค้นหา Bazel เป็น "grep สำหรับไฟล์ BUILD" ที่รับรู้กราฟการอ้างอิงได้

ข้อมูลสถานที่ตั้งจะแตกต่างกันไปตามประเภทเป้าหมาย (ดูตัวดำเนินการ kind) สำหรับกฎ ระบบจะพิมพ์ตำแหน่งของการประกาศกฎภายในไฟล์ BUILD สำหรับไฟล์ต้นฉบับ ระบบจะพิมพ์ตำแหน่งของบรรทัดที่ 1 ของไฟล์จริง สำหรับไฟล์ที่สร้างขึ้น ระบบจะพิมพ์ตำแหน่งของกฎที่ สร้างไฟล์นั้น (เครื่องมือค้นหามีข้อมูลไม่เพียงพอ ที่จะค้นหาตำแหน่งจริงของไฟล์ที่สร้างขึ้น และ ในกรณีใดก็ตาม ไฟล์อาจไม่มีอยู่หากยังไม่ได้ทำการบิลด์)

พิมพ์ชุดแพ็กเกจ

--output package

ตัวเลือกนี้จะพิมพ์ชื่อของแพ็กเกจทั้งหมดที่ เป้าหมายบางอย่างในชุดผลลัพธ์เป็นของ ระบบจะพิมพ์ชื่อตาม ลำดับพจนานุกรม โดยจะไม่รวมชื่อที่ซ้ำกัน ในทางเทคนิคแล้ว นี่คือการฉายภาพจากชุดป้ายกำกับ (แพ็กเกจ เป้าหมาย) ไปยังแพ็กเกจ

แพ็กเกจในที่เก็บข้อมูลภายนอกจะจัดรูปแบบเป็น @repo//foo/bar ส่วนแพ็กเกจในที่เก็บข้อมูลหลักจะจัดรูปแบบเป็น foo/bar

เมื่อใช้ร่วมกับdeps(...) query ตัวเลือกเอาต์พุตนี้ จะใช้เพื่อค้นหาชุดแพ็กเกจที่ต้องตรวจสอบ เพื่อสร้างชุดเป้าหมายที่กำหนดได้

แสดงกราฟของผลลัพธ์

--output graph

ตัวเลือกนี้จะทำให้ระบบพิมพ์ผลการค้นหาเป็นกราฟแบบมีทิศทางในรูปแบบ GraphViz ของ AT&T ที่ได้รับความนิยม โดยปกติแล้ว ระบบจะบันทึกผลลัพธ์ลงในไฟล์ เช่น .png หรือ .svg (หากไม่ได้ติดตั้งโปรแกรม dot ในเวิร์กสเตชัน คุณสามารถติดตั้งได้โดยใช้คำสั่ง sudo apt-get install graphviz) ดูการเรียกใช้ตัวอย่างได้ที่ส่วนตัวอย่างด้านล่าง

รูปแบบเอาต์พุตนี้มีประโยชน์อย่างยิ่งสำหรับคำค้นหา allpaths, deps หรือ rdeps ซึ่งผลลัพธ์ จะมีชุดเส้นทางที่แสดงภาพได้ยากเมื่อ แสดงผลในรูปแบบเชิงเส้น เช่น ด้วย --output label

โดยค่าเริ่มต้น กราฟจะแสดงในรูปแบบแยกตัวประกอบ กล่าวคือ ระบบจะผสานโหนดที่เทียบเท่ากันในเชิงโทโพโลยีเข้าด้วยกันเป็นโหนดเดียวที่มีป้ายกำกับหลายรายการ ซึ่งจะทำให้กราฟกะทัดรัด และอ่านง่ายขึ้น เนื่องจากกราฟผลลัพธ์ทั่วไปมีรูปแบบที่ ซ้ำกันสูง เช่น java_libraryกฎ อาจขึ้นอยู่กับไฟล์ต้นฉบับ Java หลายร้อยไฟล์ที่สร้างโดยgenruleเดียวกัน ในกราฟที่แยกตัวประกอบ ไฟล์ทั้งหมดนี้ จะแสดงด้วยโหนดเดียว คุณอาจปิดใช้ลักษณะการทำงานนี้ได้ ด้วยตัวเลือก --nograph:factored

`--graph:node_limit n`

ตัวเลือกนี้ระบุความยาวสูงสุดของสตริงป้ายกำกับสำหรับโหนดกราฟในเอาต์พุต ระบบจะตัดป้ายกำกับที่ยาวเกินไปออก แต่หากระบุ -1 จะเป็นการปิดใช้การตัด ป้ายกำกับโหนดอาจยาวมากเนื่องจากรูปแบบที่แยกตัวประกอบซึ่งมักใช้พิมพ์กราฟ GraphViz ไม่สามารถ จัดการป้ายกำกับที่ยาวเกิน 1, 024 อักขระ ซึ่งเป็นค่าเริ่มต้น ของตัวเลือกนี้ ตัวเลือกนี้จะไม่มีผล เว้นแต่จะใช้ --output=graph

`--[no]graph:factored`

โดยค่าเริ่มต้น กราฟจะแสดงในรูปแบบที่แยกตัวประกอบแล้ว ดังที่อธิบายไว้ด้านบน เมื่อระบุ --nograph:factored ระบบจะพิมพ์กราฟโดยไม่พิจารณาปัจจัย ซึ่งทำให้การแสดงภาพโดยใช้ GraphViz ไม่สามารถใช้งานได้จริง แต่รูปแบบที่ง่ายกว่าอาจช่วยให้เครื่องมืออื่นๆ (เช่น grep) ประมวลผลได้ง่ายขึ้น ตัวเลือกนี้จะไม่มีผล เว้นแต่จะใช้ --output=graph

XML

--output xml

ตัวเลือกนี้จะทำให้มีการพิมพ์เป้าหมายที่ได้ในรูปแบบ XML เอาต์พุตจะเริ่มต้นด้วยส่วนหัว XML เช่น

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

จากนั้นจะตามด้วยองค์ประกอบ XML สำหรับแต่ละเป้าหมาย ในกราฟผลลัพธ์ตามลำดับโทโพโลยี (เว้นแต่จะมีการขอผลลัพธ์ที่ไม่มีการจัดลำดับ) และปิดท้ายด้วย

</query>

ระบบจะปล่อยรายการแบบง่ายสำหรับเป้าหมายประเภท file ดังนี้

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

แต่สำหรับกฎ XML จะมีโครงสร้างและมีคำจำกัดความของแอตทริบิวต์ทั้งหมดของกฎ รวมถึงแอตทริบิวต์ที่ไม่ได้ระบุค่าอย่างชัดเจนในไฟล์ BUILD ของกฎ

นอกจากนี้ ผลลัพธ์ยังมีองค์ประกอบ rule-input และ rule-output เพื่อให้สามารถสร้างโทโพโลยีของ กราฟการขึ้นต่อกันใหม่ได้โดยไม่ต้องทราบว่า เช่น องค์ประกอบของแอตทริบิวต์ srcs คือการขึ้นต่อกันแบบส่งต่อ (ข้อกำหนดเบื้องต้น) และเนื้อหาของแอตทริบิวต์ outs คือการขึ้นต่อกันแบบย้อนกลับ (ผู้บริโภค)

ระบบจะระงับองค์ประกอบ rule-input สำหรับ การอ้างอิงโดยนัย หากมีการระบุ --noimplicit_deps

  <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>

องค์ประกอบ XML ทุกรายการสำหรับเป้าหมายจะมีแอตทริบิวต์ name ซึ่งมีค่าเป็นป้ายกำกับของเป้าหมาย และแอตทริบิวต์ location ซึ่งมีค่าเป็นตำแหน่งของเป้าหมายตามที่พิมพ์โดย --output location

`--[no]xml:line_numbers`

โดยค่าเริ่มต้น สถานที่ตั้งที่แสดงในเอาต์พุต XML จะมีหมายเลขบรรทัด เมื่อระบุ --noxml:line_numbers ระบบจะไม่พิมพ์หมายเลขบรรทัด

`--[no]xml:default_values`

โดยค่าเริ่มต้น เอาต์พุต XML จะไม่รวมแอตทริบิวต์กฎที่มีค่า เป็นค่าเริ่มต้นสำหรับแอตทริบิวต์ประเภทนั้น (เช่น หากไม่ได้ระบุในไฟล์ BUILD หรือมีการระบุค่าเริ่มต้นอย่างชัดเจน) ตัวเลือกนี้จะทำให้ค่าแอตทริบิวต์ดังกล่าวรวมอยู่ในเอาต์พุต XML

นิพจน์ทั่วไป

นิพจน์ทั่วไปในภาษาการค้นหาใช้ไลบรารีนิพจน์ทั่วไปของ Java คุณจึงใช้ไวยากรณ์แบบเต็มสำหรับ java.util.regex.Pattern ได้

การค้นหาด้วยที่เก็บภายนอก

หากบิลด์ขึ้นอยู่กับกฎจากที่เก็บภายนอก (กำหนดไว้ในไฟล์ WORKSPACE) ผลการค้นหาจะรวมการอ้างอิงเหล่านี้ ตัวอย่างเช่น หาก //foo:bar ขึ้นอยู่กับ //external:some-lib และ //external:some-lib เชื่อมโยงกับ @other-repo//baz:lib bazel query 'deps(//foo:bar)' จะแสดงทั้ง @other-repo//baz:lib และ //external:some-lib เป็นการขึ้นต่อกัน

ที่เก็บภายนอกเองไม่ใช่ทรัพยากร Dependency ของบิลด์ กล่าวคือ ในตัวอย่างด้านบน //external:other-repo ไม่ใช่การอ้างอิง แต่คุณสามารถค้นหาได้ในฐานะสมาชิกของแพ็กเกจ //external เช่น

  # 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