การลงทะเบียน BazelCon 2024 เปิดให้ลงทะเบียนแล้วในตอนนี้

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

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

รายงานปัญหา ดูแหล่งที่มา ตอนกลางคืน · 7.4 ที่ใช้เวลาเพียง 2 นาที 7.3 · 7.2 · 7.1 · 7.0 · 6.5

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

สำหรับกรณีการใช้งานที่นำไปปฏิบัติได้จริง โปรดดูวิธีการเกี่ยวกับการค้นหาด้วย Bazel

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

นอกเหนือจาก query ซึ่งทำงานบนกราฟเป้าหมายหลังการโหลดแล้ว Bazel ประกอบด้วยคำค้นหาในรูปแบบกราฟการดำเนินการและคำค้นหาที่กำหนดค่าได้

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

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

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

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

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

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

ตัวอย่าง

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

Why does the //foo tree depend on //bar/baz? แสดงเส้นทาง

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

การทดสอบ foo ทั้งหมดใช้ไลบรารี C++ ใดที่เป้าหมาย 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 และอักขระพิเศษ */@.-_:$~[] (ดอกจัน, เครื่องหมายทับ, ที่, จุด ขีดกลางสั้น, ขีดล่าง, ทวิภาค, สัญลักษณ์ดอลลาร์, ทิลเดอ, วงเล็บเหลี่ยมเปิด, สี่เหลี่ยมจัตุรัสด้านขวา วงเล็บปีกกา) แต่คำที่ไม่ได้ยกมาต้องไม่ขึ้นต้นด้วยขีดกลาง - หรือเครื่องหมายดอกจัน * แม้ว่าชื่อเป้าหมายที่เกี่ยวข้องอาจขึ้นต้นด้วย กับตัวละครเหล่านั้น

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

ต้องมีการอ้างอิงเป็นเมื่อเขียนสคริปต์ที่สร้างการค้นหาของ 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 โดยนัย

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

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

ความถูกต้อง

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

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

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

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

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

deps(x) union y

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

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

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

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

ฟังก์ชันพิเศษมีอยู่ใน SkyQuery เท่านั้น

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

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

โหมดการค้นหาท้องฟ้าจะเปิดใช้งานโดยการส่ง Flag 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 กำหนดให้คุณต้องแยกวิเคราะห์นิพจน์การค้นหาด้วยตัวเอง

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

Sky Query มีข้อดีและข้อเสียบางอย่างเมื่อเทียบกับ 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₂ โดยที่ค่าของ expr₁ จะแทนที่ตัวแปร name ทั้งหมดที่ปรากฏขึ้น

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

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

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

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

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

ในทางเทคนิคแล้ว นิพจน์ 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 รายการเป็นโอเปอเรเตอร์แบบแอตทริบิวต์แบบซ้ายและมีลําดับความสําคัญเท่ากัน คุณจึงอาจต้องใช้วงเล็บ ตัวอย่างเช่น นิพจน์ 2 รายการแรกมีความหมายเท่ากัน แต่นิพจน์ที่ 3 ไม่ได้หมายความว่า

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

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

expr ::= set(word *)

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

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

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

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

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

ปิดเชิงการเปลี่ยนรูปแบบของ Dependency แบบย้อนกลับ: rdeps

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

การดำเนินการ rdeps(u, x) จะประเมินเป็นความสัมพันธ์แบบย้อนกลับของชุดอาร์กิวเมนต์ xภายในการปิดเชิงการเปลี่ยนรูปแบบของชุดจักรวาล u

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

โอเปอเรเตอร์ rdeps ยอมรับอาร์กิวเมนต์ที่ 3 ซึ่งเป็นตัวเลือก ซึ่งเป็นเลขฐานสิบล้วนที่ระบุขีดจำกัดบนของระดับการค้นหา ผลลัพธ์ที่ได้ กราฟจะมีเฉพาะโหนดที่อยู่ในระยะของความลึกที่ระบุจากจุด โหนดในชุดอาร์กิวเมนต์ ดังนั้น rdeps(//foo, //common, 1) จะประเมินโหนดทั้งหมด ในการปิดแบบทางอ้อมของ //foo ที่ขึ้นอยู่กับ //common โดยตรง ( ตัวเลขที่สอดคล้องกับอันดับที่แสดงในเอาต์พุต minrank format.) หากเว้นพารามิเตอร์ 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) รายการ เส้นทางระหว่างเป้าหมายสองชุด ทั้งสองข้อความค้นหายอมรับสองข้อความ อาร์กิวเมนต์ ชุด S ของจุดเริ่มต้นและชุด E ของจุดสิ้นสุด somepath จะแสดงกราฟของโหนดในเส้นทางบางส่วนที่กำหนดเองจากเป้าหมายใน S ไปยังเป้าหมายใน E ส่วน allpaths จะแสดงกราฟของโหนดในเส้นทางทั้งหมดจากเป้าหมายใดก็ได้ใน S ไปยังเป้าหมายใดก็ได้ใน E

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

ซอมพาธ — `somepath(S1 + S2, E)` ผลลัพธ์ที่เป็นไปได้ 1 รายการ

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

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)) จะประเมินเป็นชุดของไฟล์ต้นฉบับทั้งหมดใน Closure แบบโอนย้ายได้ของ Dependency ของเป้าหมาย //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 เช่น หากต้องการดูทั้งหมด ทรัพยากร Dependency bar ของเป้าหมาย //foo:foo มี 1 รายการ ประเมินผล

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

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

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

ซึ่งจะคํานวณชุดของ//foo Dependency ก่อน แล้วกรองเฉพาะเป้าหมายที่ตรงกับรูปแบบที่ระบุ กล่าวคือ เป้าหมายที่มีชื่อที่มี //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))

จะเลือกทรัพยากร Dependency ทั้งหมด //foo รายการที่ได้รับอนุญาตให้มี เชื่อมโยงแอตทริบิวต์ที่แชร์ (เช่น กฎ 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))

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

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

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

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

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

ซึ่งทำได้เนื่องจากอักขระที่อยู่ก่อน value จะเป็น [ หรือการเว้นวรรคและ อักขระที่อยู่หลัง value จะเป็นเครื่องหมายจุลภาคหรือ ]

การกรองระดับการเข้าถึงกฎ: มองเห็นได้

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 ข้อ

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

expr ::= buildfiles(expr)

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

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

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

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

คำเตือน: Bazel จะถือว่าไฟล์ .bzl แต่ละไฟล์ที่สร้างขึ้นโดย buildfiles มีเป้าหมายที่เกี่ยวข้อง (เช่น ไฟล์ a/b.bzl => เป้าหมาย //a:b.bzl) แต่ก็ไม่ได้เป็นเช่นนั้นเสมอไป ดังนั้น buildfiles เขียนได้ไม่ดีนักกับโอเปอเรเตอร์การค้นหาอื่นๆ และผลลัพธ์อาจปรากฏขึ้น ทำให้เข้าใจผิดเมื่อมีการจัดรูปแบบอย่างมีโครงสร้าง เช่น [--output=xml](#output-xml)

ไฟล์การกำหนดแพ็กเกจ: 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 ก็ตาม อย่างไรก็ตาม ระบบจะพิจารณาซิมลิงก์ด้วย ดังนั้นหาก foo/BUILD เป็นซิมลิงก์ไปยัง bar/BUILD rbuildfiles(bar/BUILD) จะรวม //foo:BUILD ไว้ในผลการค้นหา

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

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

expr ::= loadfiles(expr)

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

คำเตือน: Bazel จะถือว่าไฟล์ .bzl แต่ละไฟล์มีเป้าหมายที่เกี่ยวข้อง (เช่น ไฟล์ a/b.bzl => เป้าหมาย //a:b.bzl) แต่ก็ไม่ได้เป็นเช่นนั้นเสมอไป ดังนั้น loadfiles จึงสามารถเขียนข้อความได้ไม่ดีนักกับคำค้นหาอื่น โอเปอเรเตอร์และผลลัพธ์อาจทำให้เกิดความเข้าใจผิดได้เมื่อจัดรูปแบบในลักษณะที่มีโครงสร้าง เช่น [--output=xml](#output-xml)

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

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

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

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

เกี่ยวกับลำดับของผลลัพธ์

แม้ว่านิพจน์ข้อความค้นหาจะเป็นไปตาม "กฎของ การสงวนลำดับกราฟ" การนำเสนอผลลัพธ์ที่เป็นไปได้ ในลักษณะที่มีการจัดลำดับการขึ้นต่อกันหรือไม่เรียงลำดับ การดำเนินการนี้ไม่ มีผลต่อเป้าหมายในชุดผลลัพธ์หรือวิธีการคำนวณข้อความค้นหา แต่จะส่งผลต่อวิธีพิมพ์ผลลัพธ์ไปยัง stdout เท่านั้น นอกจากนี้ โหนดที่เทียบเท่ากันในลําดับความขึ้นต่อกันอาจเรียงตามลําดับตัวอักษรหรือไม่ก็ได้ คุณใช้ Flag --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 จะพิมพ์ผลลัพธ์เสมอ เรียงลำดับตามอันดับหรืออันดับทรัพยากร Dependency

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

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

โหนดการพิมพ์ในลำดับนี้อาจทำงานได้ช้าลง ดังนั้นจึงควรใช้เมื่อการกำหนดเงื่อนไขคือเท่านั้น เป็นอย่างมาก

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

--output build

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

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

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

--output label

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

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

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

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

--output label_kind

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

พิมพ์เป้าหมายในรูปแบบโปรโตคอลบัฟเฟอร์

--output proto

พิมพ์ผลลัพธ์การค้นหาเป็น QueryResult บัฟเฟอร์โปรโตคอล

เป้าหมายที่พิมพ์ในรูปแบบบัฟเฟอร์โปรโตคอลที่คั่นด้วยความยาว

--output streamed_proto

พิมพ์สตรีมบัฟเฟอร์โปรโตคอล Target แบบแบ่งความยาว ซึ่งมีประโยชน์ในการ(1) หลีกเลี่ยงข้อจำกัดด้านขนาดของบัฟเฟอร์โปรโตคอลเมื่อมีเป้าหมายมากเกินไปที่จะใส่ในQueryResult รายการเดียว หรือ(2) เพื่อเริ่มการประมวลผลขณะที่ Bazel ยังคงแสดงผลอยู่

เป้าหมายที่พิมพ์ในรูปแบบข้อความ Proto

--output textproto

คล้ายกับ --output proto แต่จะพิมพ์บัฟเฟอร์โปรโตคอล QueryResult ในรูปแบบข้อความ

เป้าหมายที่พิมพ์ในรูปแบบ ndjson

--output streamed_jsonproto

คล้ายกับ --output streamed_proto แต่จะพิมพ์สตรีมบัฟเฟอร์โปรโตคอล Target ในรูปแบบ ndjson

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

--output minrank --output maxrank

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

รูปแบบนี้มี 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(...) เพื่อค้นหาชุดแพ็กเกจที่ต้องทำเครื่องหมายได้ เพื่อสร้างชุดเป้าหมายหนึ่งๆ

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

--output graph

ตัวเลือกนี้จะทําให้ผลการค้นหาแสดงเป็นกราฟที่มีทิศทางในรูปแบบ AT&T GraphViz ที่ได้รับความนิยม โดยทั่วไปแล้ว ระบบจะบันทึกผลลัพธ์ไปยังไฟล์ เช่น .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เพื่อให้โทโพโลยีของ สามารถสร้างกราฟทรัพยากร Dependency ใหม่ได้โดยไม่ต้องทราบว่า ตัวอย่างเช่น องค์ประกอบของแอตทริบิวต์ srcs ได้แก่ ทรัพยากร Dependency แบบส่งต่อ (ข้อกำหนดเบื้องต้น) และเนื้อหาของ แอตทริบิวต์ outs เป็นทรัพยากร Dependency แบบย้อนหลัง (ผู้บริโภค)

ระบบจะระงับองค์ประกอบ rule-input สำหรับทรัพยากร Dependency ที่ไม่ชัดแจ้งหากมีการระบุ --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

รีโพซิทอรีภายนอกไม่ใช่ทรัพยากร Dependency ของบิลด์ ซึ่งก็คือ ตัวอย่างข้างต้น //external:other-repo ไม่ใช่ทรัพยากร Dependency แต่สามารถค้นหาได้ในฐานะสมาชิกของแพ็กเกจ //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