หน้านี้เป็นคู่มืออ้างอิงสำหรับ Bazel Query Language ที่ใช้เมื่อคุณใช้ bazel query
เพื่อวิเคราะห์ข้อกำหนดของบิลด์ ทั้งยังมีการอธิบายรูปแบบเอาต์พุตที่ bazel query
รองรับด้วย
ดูกรณีการใช้งานจริงได้ที่วิธีการค้นหาด้วย Bazel
ข้อมูลอ้างอิงการค้นหาเพิ่มเติม
นอกจาก query
ที่ทำงานในกราฟเป้าหมายระยะหลังการโหลดแล้ว Bazel ยังมีการค้นหากราฟการดำเนินการและการค้นหาที่กำหนดค่าได้
การค้นหากราฟการดำเนินการ
การค้นหากราฟการดำเนินการ (aquery
) จะดำเนินการในกราฟเป้าหมายที่กำหนดค่าไว้หลังการวิเคราะห์ และแสดงข้อมูลเกี่ยวกับการดำเนินการ อาร์ติแฟกต์ และความสัมพันธ์ aquery
มีประโยชน์เมื่อคุณสนใจพร็อพเพอร์ตี้ของการดำเนินการ/อาร์ติแฟกต์ที่สร้างขึ้นจากกราฟเป้าหมายที่กำหนดค่าไว้
เช่น คำสั่งจริงที่เรียกใช้ รวมถึงอินพุต เอาต์พุต และกลวิธีช่วยจำ
ดูรายละเอียดเพิ่มเติมได้ที่ข้อมูลอ้างอิง aquery
การค้นหาที่กําหนดค่าได้
การค้นหา Bazel แบบดั้งเดิมจะทำงานในกราฟเป้าหมายระยะหลังการโหลด จึงไม่มีแนวคิดเกี่ยวกับการกำหนดค่าและแนวคิดที่เกี่ยวข้อง สิ่งที่น่าสังเกตคือ เครื่องมือนี้ไม่ได้แก้ไขคำสั่ง Select อย่างถูกต้อง และแสดงผลลัพธ์ที่เป็นไปได้ทั้งหมดของ Select แทน อย่างไรก็ตาม 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
คีย์เวิร์ดคือคำที่สงวนไว้ของภาษานั้นๆ ซึ่งจะอธิบายแต่ละคำด้านล่างนี้ คีย์เวิร์ดทั้งหมดมีดังนี้คํา เช่น "
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 ชื่อ ให้ใช้เครื่องหมายคำพูดเพียง 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
จะพิจารณาทรัพยากร Dependency โดยนัยเมื่อคำนวณผลการค้นหา คุณเปลี่ยนลักษณะการทำงานนี้ได้โดยใช้ตัวเลือก --[no]implicit_deps
โปรดทราบว่าเนื่องจากคําค้นหาไม่พิจารณาการกําหนดค่า ระบบจะไม่พิจารณาเครื่องมือทางเทคนิคที่เป็นไปได้
ความเสียง
นิพจน์ภาษาการค้นหาของ Bazel จะทำงานกับกราฟความเกี่ยวข้องของบิลด์ ซึ่งเป็นกราฟที่การประกาศกฎทั้งหมดในไฟล์ BUILD
ทั้งหมดกำหนดไว้โดยนัย คุณควรเข้าใจว่ากราฟนี้ค่อนข้างเป็นนามธรรม และไม่ถือว่าเป็นคำอธิบายที่สมบูรณ์เกี่ยวกับวิธีดำเนินการตามขั้นตอนทั้งหมดของการสร้าง คุณต้องกําหนดค่าด้วยเพื่อทําบิลด์ ดูรายละเอียดเพิ่มเติมได้ในส่วนการกําหนดค่าของคู่มือผู้ใช้
ผลลัพธ์จากการประเมินนิพจน์ในภาษาการค้นหาของ Bazel จะถือเป็นจริงสำหรับการกำหนดค่าทั้งหมด ซึ่งหมายความว่าผลลัพธ์อาจเป็นการประมาณแบบอนุรักษ์นิยมที่เกินจริงและไม่ใช่ค่าที่แน่นอน หากคุณใช้เครื่องมือค้นหาเพื่อคํานวณชุดไฟล์ต้นฉบับทั้งหมดที่จําเป็นในระหว่างการสร้าง เครื่องมืออาจรายงานมากกว่าที่จําเป็นจริง เนื่องจากเครื่องมือค้นหาจะรวมไฟล์ทั้งหมดที่จําเป็นสําหรับรองรับการแปลข้อความ แม้ว่าคุณจะไม่ได้ตั้งใจจะใช้ฟีเจอร์นั้นในบิลด์ก็ตาม
เกี่ยวกับการคงลําดับของกราฟ
การดำเนินการจะรักษาข้อจำกัดการจัดเรียงที่รับค่ามาจากนิพจน์ย่อย คุณอาจมองว่านี่คือ "กฎแห่งการอนุรักษ์กฎเกณฑ์บางส่วน" ก็ได้ พิจารณาตัวอย่างต่อไปนี้ หากคุณส่งคําค้นหาเพื่อระบุการปิดเชิงสื่อกลางของข้อกําหนดของเป้าหมายหนึ่งๆ ชุดผลลัพธ์จะจัดเรียงตามกราฟข้อกําหนด หากคุณกรองซึ่งตั้งค่าให้รวมเฉพาะเป้าหมายประเภท file
ความสัมพันธ์ในการจัดลำดับบางส่วนแบบทางอ้อมเดียวกันระหว่างเป้าหมายทุกคู่ในเซตย่อยผลลัพธ์ แม้ว่าจริงๆ แล้วจะไม่มีคู่ใดที่เชื่อมต่อกันโดยตรงในกราฟต้นฉบับก็ตาม
(ไม่มีขอบของไฟล์ในกราฟทรัพยากร Dependency ของบิลด์)
อย่างไรก็ตาม แม้ว่าโอเปอเรเตอร์ทั้งหมดเก็บรักษาลำดับไว้ แต่การดำเนินการบางอย่าง เช่น การดำเนินการตั้งค่าจะไม่นำข้อจำกัดการจัดลำดับของตนเองมาใช้ ลองพิจารณานิพจน์นี้
deps(x) union y
รับประกันได้ว่าลำดับของชุดผลลัพธ์สุดท้ายจะคงข้อจำกัดการจัดลำดับทั้งหมดของนิพจน์ย่อยไว้ กล่าวคือ ทรัพยากร Dependency แบบสับเปลี่ยนทั้งหมดของ x
จะได้รับการเรียงลำดับอย่างถูกต้องโดยคำนึงถึงกันและกัน อย่างไรก็ตาม การค้นหาไม่ได้รับประกันเกี่ยวกับการจัดลําดับเป้าหมายใน y
หรือการจัดลําดับเป้าหมายใน deps(x)
เทียบกับเป้าหมายใน y
(ยกเว้นเป้าหมายใน y
ที่อยู่ใน deps(x)
ด้วย)
โอเปอเรเตอร์ที่ทำให้เกิดข้อจำกัดในการสั่งซื้อ ได้แก่
allpaths
, deps
, rdeps
, somepath
และไวลด์การ์ดรูปแบบเป้าหมาย
package:*
, dir/...
ฯลฯ
การค้นหาท้องฟ้า
Sky Query คือโหมดการค้นหาที่ทำงานในขอบเขตจักรวาลที่ระบุ
ฟังก์ชันพิเศษที่ใช้ได้เฉพาะใน SkyQuery
โหมดการค้นหาท้องฟ้ามีฟังก์ชันการค้นหาเพิ่มเติม allrdeps
และ
rbuildfiles
ฟังก์ชันเหล่านี้ทำงานในขอบเขตทั้งจักรวาล (ซึ่งเป็นเหตุผลที่ทำให้ไม่สมเหตุสมผลสำหรับการค้นหาปกติ)
การระบุขอบเขตจักรวาล
โหมดการค้นหาท้องฟ้าจะเปิดใช้งานโดยการส่ง 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 มีข้อดีและข้อเสียบางอย่างเมื่อเทียบกับการค้นหาเริ่มต้น แต่ข้อเสียหลักๆ คือไม่สามารถเรียงลำดับเอาต์พุตตามลำดับกราฟได้ ทำให้ระบบไม่อนุญาตให้ใช้รูปแบบเอาต์พุตบางรูปแบบ ข้อดีคือมีโอเปอเรเตอร์ 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 = expr1 in expr2
| $name
ภาษาการค้นหาของ Bazel อนุญาตให้มีการกําหนดและการอ้างอิงตัวแปร ผลลัพธ์ของการประเมินนิพจน์ let
เหมือนกับของ expr2 โดยจะแทนที่ตัวแปร name โดยไม่เสียค่าใช้จ่ายทั้งหมดด้วยค่า expr1
เช่น 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/...
คุณสามารถเขียน Query แบบเดียวกับ
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 ...)
จะคำนวณการรวมของรูปแบบเป้าหมายชุดหนึ่งหรือมากกว่า โดยคั่นด้วยช่องว่าง (โดยไม่ใช้เครื่องหมายจุลภาค)
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 การค้นหาจะเป็นแบบไม่จำกัด โดยจะคํานวณการปิดแบบสะท้อนกลับแบบทรานซิทีฟของข้อกําหนดเบื้องต้น
การปิดแบบทางอ้อมของทรัพยากร Dependency แบบย้อนกลับ: rdeps
expr ::= rdeps(expr, expr)
| rdeps(expr, expr, depth)
การดำเนินการ rdeps(u, x)
จะประเมินเป็นความสัมพันธ์แบบย้อนกลับของชุดอาร์กิวเมนต์
xภายในการปิดเชิงการเปลี่ยนรูปแบบของชุดจักรวาล
u
กราฟผลลัพธ์จะเรียงลำดับตามความสัมพันธ์ของทรัพยากร Dependency ดูรายละเอียดเพิ่มเติมได้ที่ส่วนลำดับกราฟ
โอเปอเรเตอร์ 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 หรือไม่ก็ได้ หากไม่มี ผลลัพธ์จะเป็นชุดเดี่ยวที่มีการเลือกเป้าหมายเพียง 1 รายการโดยไม่มีกฎเกณฑ์ หากขนาดของชุดอาร์กิวเมนต์ 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
กราฟผลลัพธ์จะถูกเรียงลำดับตามความสัมพันธ์ในการพึ่งพา ดูรายละเอียดเพิ่มเติมได้ที่ส่วนลำดับกราฟ
การกรองประเภทเป้าหมาย: 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
อาจมีผู้ประเมิน
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 ที่ระบุ โดยจะประเมินเฉพาะข้อมูลย่อยของอินพุต
อ argum แรก name คือชื่อแอตทริบิวต์ของกฎที่ควรจับคู่กับรูปแบบนิพจน์ทั่วไปที่ระบุ อาร์กิวเมนต์ที่ 2 ซึ่งก็คือ pattern คือนิพจน์ทั่วไปสำหรับค่าแอตทริบิวต์ นิพจน์ attr
จะประเมินชุดที่มีเป้าหมายทั้งหมด
x โดยที่ x เป็นสมาชิกของชุด input เป็นกฎที่มีแอตทริบิวต์ที่กำหนดไว้ name และค่าแอตทริบิวต์มีการจับคู่ที่ตรงกัน (ไม่เชื่อมโยง) สำหรับนิพจน์ทั่วไป
pattern หาก name เป็นแอตทริบิวต์ที่ไม่บังคับและกฎไม่ได้ระบุไว้อย่างชัดเจน ระบบจะใช้ค่าแอตทริบิวต์เริ่มต้นสำหรับการเปรียบเทียบ ตัวอย่างเช่น
attr(linkshared, 0, deps(//foo))
จะเลือก //foo
ทั้งหมดที่อนุญาตให้มีแอตทริบิวต์ cc_binary
(เช่น กฎ 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))
จะเลือกกฎทั้งหมดในทรัพยากร Dependency ของ //foo
ที่ระบุอย่างน้อย 1 ค่าในแอตทริบิวต์ data
(ทุกป้ายกำกับมีความยาวอย่างน้อย 3 อักขระเนื่องจาก //
และ :
)
หากต้องการเลือกกฎทั้งหมดในทรัพยากร Dependency //foo
ที่มี value
เฉพาะในแอตทริบิวต์ list-type ให้ใช้
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: การทดสอบ
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
ขอบเขตของโอเปอเรเตอร์ --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)
โอเปอเรเตอร์ 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 เท่านั้น นอกจากนี้ โหนดที่เทียบเท่ากันในลําดับความขึ้นต่อกันอาจเรียงตามลําดับตัวอักษรหรือไม่ก็ได้
คุณใช้ Flag --order_output
เพื่อควบคุมลักษณะการทำงานนี้ได้
(ธง --[no]order_results
มีฟังก์ชันการทำงานส่วนหนึ่งของธง --order_output
และเลิกใช้งานแล้ว)
ค่าเริ่มต้นของ Flag นี้คือ auto
ซึ่งจะพิมพ์ผลลัพธ์ตามลําดับคํา อย่างไรก็ตาม เมื่อใช้ somepath(a,b)
ระบบจะพิมพ์ผลลัพธ์ตามลําดับ deps
แทน
เมื่อแฟล็กนี้คือ no
และ --output
เป็นหนึ่งใน
build
, label
, label_kind
, location
, package
, proto
หรือ
xml
ระบบจะพิมพ์เอาต์พุตตามลำดับที่กำหนดเอง โดยทั่วไปแล้ว ตัวเลือกนี้เป็นตัวเลือกที่เร็วที่สุด แต่จะไม่รองรับเมื่อ --output
เป็นหนึ่งใน graph
, minrank
หรือ maxrank
เนื่องจาก Bazel จะพิมพ์ผลลัพธ์ตามลําดับหรือลําดับความสำคัญของการพึ่งพาเสมอเมื่อใช้รูปแบบเหล่านี้
เมื่อแฟล็กนี้มีค่าเป็น deps
Bazel จะพิมพ์ผลลัพธ์ตามลำดับโทโพโลยี ซึ่งก็คือการขึ้นต่อกันก่อน อย่างไรก็ตาม ระบบอาจพิมพ์โหนดที่ไม่มีลําดับตามลําดับความเกี่ยวข้อง (เนื่องจากไม่มีเส้นทางจากโหนดหนึ่งไปยังอีกโหนดหนึ่ง) ในลําดับใดก็ได้
เมื่อ Flag นี้เป็น 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
(ดูด้านล่าง) ความแตกต่างจะชัดเจนขึ้น เป้าหมาย 2 รายการมีชื่อเดียวกัน แต่รายการหนึ่งมีประเภท sh_binary rule
และอีกรายการมีประเภท source file
พิมพ์ป้ายกำกับและประเภทของเป้าหมายแต่ละรายการ
--output label_kind
เช่นเดียวกับ label
รูปแบบเอาต์พุตนี้จะพิมพ์ป้ายกำกับของเป้าหมายแต่ละรายการในกราฟที่แสดงตามลําดับเชิงเรขาคณิต แต่นอกจากนี้ยังใส่kind ของเป้าหมายไว้ข้างหน้าป้ายกำกับด้วย
พิมพ์เป้าหมายในรูปแบบ Protocol Buffer
--output proto
พิมพ์เอาต์พุตการค้นหาเป็นบัฟเฟอร์โปรโตคอล QueryResult
พิมพ์เป้าหมายในรูปแบบบัฟเฟอร์โปรโตคอลที่กําหนดความยาว
--output streamed_proto
พิมพ์สตรีมบัฟเฟอร์โปรโตคอล Target
แบบแบ่งความยาว ซึ่งมีประโยชน์ในการ(1) หลีกเลี่ยงข้อจำกัดด้านขนาดของบัฟเฟอร์โปรโตคอลเมื่อมีเป้าหมายมากเกินไปที่จะใส่ในQueryResult
รายการเดียว หรือ(2) เพื่อเริ่มการประมวลผลขณะที่ Bazel ยังคงแสดงผลอยู่
พิมพ์เป้าหมายในรูปแบบโปรโตคอลข้อความ
--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 ของไฟล์จริง สำหรับไฟล์ที่สร้างขึ้น ระบบจะพิมพ์ตำแหน่งของกฎที่สร้างไฟล์ (เครื่องมือ Query มีข้อมูลไม่เพียงพอที่จะค้นหาตำแหน่งจริงของไฟล์ที่สร้างขึ้น และไม่ว่าในกรณีใดก็ตาม เครื่องมือนี้อาจไม่มีอยู่หากยังไม่มีการดำเนินการสร้าง)
พิมพ์ชุดแพ็กเกจ
--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
เพื่อให้สร้างโทโพโลยีของกราฟการขึ้นต่อกันใหม่ได้โดยไม่ต้องทราบว่า ตัวอย่างเช่น องค์ประกอบของแอตทริบิวต์ 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) ผลการค้นหาจะรวมทรัพยากร Dependency เหล่านี้ไว้ด้วย ตัวอย่างเช่น หาก //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