Build Foundation เริ่มรับสมัครสมาชิกผู้ก่อตั้งแล้ว เข้าร่วมรายชื่ออีเมล อ่านข้อตกลงในการเข้าร่วม และลงทะเบียน

Google ใช้เทคโนโลยี AI เพื่อแปลเนื้อหาเป็นภาษาที่คุณต้องการ การแปลโดย AI อาจมีข้อผิดพลาด

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

Nightly · 9.2 · 9.1 · 9.0 · 8.7 · 8.6

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

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

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

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

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

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

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

การใส่เครื่องหมายคำพูดเป็นสิ่งจำเป็นเมื่อเขียนสคริปต์ที่สร้างนิพจน์การค้นหา 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 ยังเพิ่มทรัพยากร Dependency โดยนัยเพิ่มเติมลงในกฎด้วย เช่น กฎ Java ทุกข้อขึ้นอยู่กับ JavaBuilder โดยนัย การกำหนดการขึ้นต่อกันโดยนัย จะทำโดยใช้แอตทริบิวต์ที่ขึ้นต้นด้วย $ และจะ ลบล้างในไฟล์ BUILD ไม่ได้

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

ความสมบูรณ์

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

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

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

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

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

deps(x) union y

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

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

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

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

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

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

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

ระบบจะเปิดใช้งานโหมด Sky Query โดยส่ง 2 Flag ต่อไปนี้ (--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 รวมถึงทรัพยากร Dependency ทั้งหมด ค่าของ 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 ภายใน Closure แบบทรานซิทีฟของชุดจักรวาล u

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

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

การปิดทรานซิทีฟของการขึ้นย้อนกลับทั้งหมด: 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 เช่น หากต้องการดูการขึ้นต่อกัน barทั้งหมดของเป้าหมาย //foo:foo คุณสามารถ ประเมิน

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 ขึ้นอยู่กับ

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

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

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

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

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

พิมพ์แบบฟอร์มแหล่งที่มาของเป้าหมายตามที่ปรากฏใน 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 proto

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

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

--output streamed_proto

พิมพ์สตรีมที่คั่นด้วยความยาวของบัฟเฟอร์โปรโตคอล Target ซึ่งมีประโยชน์ในการ (i) หลีกเลี่ยงข้อจำกัดด้านขนาดของบัฟเฟอร์โปรโตคอลเมื่อมีเป้าหมายมากเกินกว่าที่จะใส่ในQueryResultเดียว หรือ (ii) เพื่อเริ่มประมวลผลขณะที่ 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 (ดูหมายเหตุเกี่ยวกับการจัดลำดับผลการค้นหา)

รูปแบบนี้มี 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