หน้านี้คือคู่มืออ้างอิงสำหรับภาษาในการค้นหาบาเซลที่ใช้
เมื่อคุณใช้ bazel query
เพื่อวิเคราะห์ทรัพยากร Dependency ของบิลด์ และ
อธิบายรูปแบบเอาต์พุตที่ bazel query
รองรับ
สำหรับกรณีการใช้งานที่นำไปปฏิบัติได้จริง โปรดดูวิธีการเกี่ยวกับการค้นหาด้วย Bazel
การอ้างอิงการค้นหาเพิ่มเติม
นอกเหนือจาก query
ซึ่งทำงานบนกราฟเป้าหมายหลังการโหลดแล้ว
Bazel ประกอบด้วยคำค้นหาในรูปแบบกราฟการดำเนินการและคำค้นหาที่กำหนดค่าได้
การค้นหากราฟการดำเนินการ
การค้นหากราฟการดำเนินการ (aquery
) จะดำเนินการในส่วนหลังการวิเคราะห์ที่กําหนดค่าไว้
กราฟเป้าหมายและแสดงข้อมูลเกี่ยวกับการดำเนินการ อาร์ติแฟกต์ และ
ความสัมพันธ์ของพวกเขา aquery
มีประโยชน์เมื่อคุณสนใจ
ของการดำเนินการ/อาร์ติแฟกต์ที่สร้างขึ้นจากกราฟเป้าหมายที่กำหนดค่าแล้ว
เช่น การเรียกใช้คำสั่งจริงรวมถึงอินพุต เอาต์พุต และการช่วยจำ
ดูรายละเอียดเพิ่มเติมได้ที่ข้อมูลอ้างอิงการค้นหา
การค้นหาที่กำหนดค่าได้
ข้อความค้นหา Bazel แบบเดิมจะทำงานบนกราฟเป้าหมายหลังการโหลดและ
จึงไม่มีแนวคิดของการกำหนดค่าและแนวคิดที่เกี่ยวข้อง สิ่งที่ควรทราบ
ไม่ได้แก้ไขคำสั่งที่เลือกอย่างถูกต้อง
และแสดงความละเอียดที่เป็นไปได้ทั้งหมดของการเลือกแทน อย่างไรก็ตาม
cquery
ซึ่งเป็นสภาพแวดล้อมของการค้นหาที่กำหนดค่าได้จะจัดการการกำหนดค่าได้อย่างเหมาะสม แต่
ไม่ได้มีฟังก์ชันการทำงานทั้งหมดของการค้นหาดั้งเดิมนี้
ดูรายละเอียดเพิ่มเติมได้ที่ข้อมูลอ้างอิง BigQuery
ตัวอย่าง
ผู้คนใช้ 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
คีย์เวิร์ดคือคำที่สงวนไว้ของ ซึ่งมีการอธิบายแต่ละแบบไว้ด้านล่างนี้ ทั้งชุด ของคีย์เวิร์ดคือคำ เช่น "
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) ของเป้าหมาย เหลือเพียง ประเภทข้อมูล
การตั้งค่าและกราฟอ้างอิงถึงประเภทข้อมูลเดียวกัน แต่เน้นที่ข้อมูลที่แตกต่างกัน ของโมเดล เช่น
- Set: ลำดับบางส่วนของเป้าหมายไม่น่าสนใจ
- กราฟ: ลำดับบางส่วนของเป้าหมายมีนัยสำคัญ
วงจรในกราฟทรัพยากร Dependency
กราฟทรัพยากร Dependency ควรเป็นแบบวนซ้ำ
อัลกอริทึมที่ใช้โดยภาษาในการค้นหานั้นมีไว้เพื่อใช้ใน กราฟแบบวนซ้ำ แต่มีความทนทานเมื่อเทียบกับวงจร รายละเอียดเกี่ยวกับวิธีการ จะไม่ได้ระบุรอบ และไม่ควรนำมาใช้
ทรัพยากร Dependency โดยนัย
นอกจากการสร้างทรัพยากร Dependency ที่กําหนดไว้อย่างชัดแจ้งในไฟล์ BUILD
แล้ว
Bazel เพิ่มการพึ่งพา implicit เพิ่มเติมลงในกฎ ตัวอย่างเช่น
กฎ Java ทุกกฎจะขึ้นอยู่กับ JavaBuilder โดยปริยาย ทรัพยากร Dependency โดยนัย
สร้างขึ้นโดยใช้แอตทริบิวต์ที่ขึ้นต้นด้วย $
และ
ไม่สามารถลบล้างใน BUILD
ไฟล์
ตามค่าเริ่มต้น bazel query
จะพิจารณาทรัพยากร Dependency โดยนัย
เมื่อคำนวณผลการค้นหา คุณเปลี่ยนลักษณะการทำงานนี้ได้ด้วย
ตัวเลือก --[no]implicit_deps
โปรดทราบว่า ด้วยข้อมูลที่การค้นหาจะไม่พิจารณา
การกำหนดค่า Toolchain ที่เป็นไปได้จะไม่ได้รับการพิจารณา
ความเสียง
นิพจน์ภาษาของคำค้นหา Bazel จะดำเนินการในบิลด์
กราฟ Dependency สำหรับกราฟแบบ Dependency ทั้งหมด ซึ่งเป็นกราฟที่กำหนดโดย
การประกาศกฎในทั้ง BUILD
ไฟล์ โปรดทำความเข้าใจ
กราฟนี้ค่อนข้างเป็นนามธรรม และไม่ประกอบขึ้นเป็น
คำอธิบายแบบเต็มเกี่ยวกับวิธีดำเนินการตามขั้นตอนทั้งหมดของบิลด์ ใน
คุณจำเป็นต้องมีการกำหนดค่าเพื่อสร้างบิลด์ด้วย
โปรดดูการกำหนดค่า
ในคู่มือผู้ใช้เพื่อดูรายละเอียดเพิ่มเติม
ผลของการประเมินนิพจน์ในภาษาคำค้นหา Bazel เป็นจริงสำหรับการกำหนดค่าทั้งหมด ซึ่งหมายความว่าอาจเป็น ค่าประมาณเชิงรับให้สูงไว้ก่อน และไม่แม่นยำเสียทีเดียว หากคุณ ใช้เครื่องมือ Query เพื่อคำนวณชุดของไฟล์แหล่งข้อมูลทั้งหมดที่ต้องใช้ ในระหว่างการสร้าง รายงานนั้นอาจรายงาน ตัวอย่างเช่น เครื่องมือ Query จะรวมไฟล์ทั้งหมด ในการสนับสนุนการแปลข้อความ แม้ว่าคุณจะไม่ได้ตั้งใจ เพื่อใช้ฟีเจอร์นั้นในงานสร้างของคุณ
เกี่ยวกับการรักษาลำดับกราฟ
การดำเนินการจะรักษาการจัดลำดับไว้
ที่รับช่วงมาจากนิพจน์ย่อย ลองนึกถึง
สิ่งนี้ว่าเป็น "กฎแห่งการอนุรักษ์คำสั่งศาลบางส่วน" ลองพิจารณา
ตัวอย่าง: หากคุณส่งคำค้นหาเพื่อกำหนดการปิดทางอ้อมของ
ทรัพยากร Dependency ของเป้าหมายที่เฉพาะเจาะจง ชุดผลลัพธ์จะถูกเรียงลำดับ
ตามกราฟการขึ้นต่อกัน ถ้าคุณกรองตั้งค่าเป็น
รวมเฉพาะเป้าหมายประเภท file
ซึ่ง
การระงับความสัมพันธ์ตามลำดับบางส่วนแบบสโลแกนระหว่างทุกๆ
เป้าหมาย 2 คู่ในเซตย่อยที่ได้ แม้ว่าจะไม่มี
ในกราฟต้นฉบับ คู่เหล่านี้จะเชื่อมต่อกันโดยตรง
(ไม่มีขอบของไฟล์ในกราฟทรัพยากร Dependency ของบิลด์)
แต่ในขณะที่โอเปอเรเตอร์ทั้งหมดเก็บรักษาคำสั่งซื้อ เช่น set Operations ไม่แนะนำข้อจำกัดในการสั่งซื้อของตนเอง ลองพิจารณานิพจน์นี้
deps(x) union y
รับประกันลำดับของชุดผลลัพธ์สุดท้ายได้เพื่อรักษา
ตามลำดับจำกัดของนิพจน์ย่อย ซึ่งก็คือ
ทรัพยากร Dependency แบบสับเปลี่ยนของ x
เรียงลำดับอย่างถูกต้องด้วย
เคารพซึ่งกันและกัน อย่างไรก็ตาม ข้อความค้นหาไม่ได้รับประกันว่า
ลำดับของเป้าหมายใน y
หรือเกี่ยวกับ
ลำดับของเป้าหมายใน deps(x)
เมื่อเทียบกับเป้าหมายใน
y
(ยกเว้นเป้าหมายใน
y
ที่เกิดขึ้นในภาษา deps(x)
)
ผู้ให้บริการที่มีข้อจำกัดในการสั่งซื้อมีดังนี้
allpaths
, deps
, rdeps
, somepath
และไวลด์การ์ดรูปแบบเป้าหมาย
package:*
, dir/...
ฯลฯ
การค้นหาเกี่ยวกับท้องฟ้า
Sky Query คือโหมดของคำค้นหาที่ดำเนินการตามขอบเขตระดับจักรวาลที่ระบุไว้
ฟังก์ชันพิเศษมีอยู่ใน SkyQuery เท่านั้น
โหมด Sky Query มีฟังก์ชันการค้นหาเพิ่มเติม allrdeps
และ
rbuildfiles
ฟังก์ชันเหล่านี้จะดำเนินการทั่วทั้ง
ขอบเขตที่แตกต่างกันไป (ซึ่งเป็นเหตุผลที่ทำให้ไม่สมเหตุสมผลสำหรับคำค้นหาปกติ)
การระบุขอบเขตจักรวาล
โหมด Sky Query ได้รับการเปิดใช้งานโดยการส่งผ่าน 2 การตั้งค่าต่อไปนี้
(--universe_scope
หรือ --infer_universe_scope
) และ
--order_output=no
--universe_scope=<target_pattern1>,...,<target_patternN>
บอกการค้นหาให้
โหลดการปิดแบบทรานซิทีฟของรูปแบบเป้าหมายที่ระบุโดยรูปแบบเป้าหมายไว้ล่วงหน้า ซึ่งสามารถ
เป็นทั้งส่วนบวกและการลบ จากนั้นคำค้นหาทั้งหมดจะได้รับการประเมินใน "ขอบเขต" นี้ โดยเฉพาะอย่างยิ่ง
allrdeps
และ
โอเปอเรเตอร์ rbuildfiles
จะแสดงผลการค้นหาจากขอบเขตนี้เท่านั้น
--infer_universe_scope
บอกให้ Bazel อนุมานค่าสำหรับ --universe_scope
จากนิพจน์คำค้นหา ค่าที่อนุมานนี้คือรายการรูปแบบเป้าหมายที่ไม่ซ้ำใน
นิพจน์คำค้นหา แต่นี่ไม่ใช่สิ่งที่คุณต้องการ เช่น
bazel query --infer_universe_scope --order_output=no "allrdeps(//my:target)"
รายการรูปแบบเป้าหมายที่ไม่ซ้ำในนิพจน์การค้นหานี้คือ ["//my:target"]
ดังนั้น
Bazel ดำเนินการตามนี้เช่นเดียวกับการเรียกใช้
bazel query --universe_scope=//my:target --order_output=no "allrdeps(//my:target)"
แต่ผลลัพธ์ของคำค้นหาด้วย --universe_scope
นั้นคือ //my:target
เท่านั้น
ไม่มีทรัพยากร Dependency แบบย้อนกลับของ //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 = 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 รายการเป็น
เชื่อมโยงกับด้านซ้ายและมีลำดับความสำคัญเท่ากัน ดังนั้นคุณอาจต้องการใส่วงเล็บ สำหรับ
ตัวอย่างเช่น สองนิพจน์แรกนั้นเทียบเท่ากัน แต่นิพจน์ที่สามไม่ใช่
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)
แต่เป็น 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)
จะประเมินจากกราฟที่สร้างขึ้น
โดยการปิดทรานซิทีฟของทรัพยากร Dependency ของชุดอาร์กิวเมนต์
x ตัวอย่างเช่น ค่าของ deps(//foo)
คือค่า
กราฟทรัพยากร Dependency ที่รูทที่โหนดเดียว foo
รวมถึงโหนดทั้งหมด
ทรัพยากร Dependency ค่าของ deps(foo/...)
คือกราฟทรัพยากร Dependency ที่มีราก
เป็นกฎทั้งหมดในทุกแพ็กเกจภายใต้ไดเรกทอรี foo
ในบริบทนี้
"dependencies" หมายถึงกฎและไฟล์เป้าหมายเท่านั้น ดังนั้น BUILD
และ
ไฟล์ Starlark ที่ต้องใช้ในการสร้างเป้าหมายเหล่านี้ไม่ได้รวมอยู่ที่นี่ สำหรับกรณีนี้
คุณควรใช้โอเปอเรเตอร์ buildfiles
กราฟผลลัพธ์จะเรียงลำดับตามความสัมพันธ์ในการพึ่งพา สำหรับข้อมูลเพิ่มเติม ดูรายละเอียดได้ที่ส่วนลำดับกราฟ
โอเปอเรเตอร์ 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)
ประเมินหาทรัพยากร Dependency แบบย้อนกลับของชุดอาร์กิวเมนต์
x ภายในการปิดจักรวาลแบบสับเปลี่ยน
u
กราฟผลลัพธ์จะเรียงลำดับตามความสัมพันธ์ในการพึ่งพา โปรดดู ในลำดับกราฟสำหรับรายละเอียดเพิ่มเติม
โอเปอเรเตอร์ rdeps
ยอมรับอาร์กิวเมนต์ที่สาม (ไม่บังคับ) ซึ่งเป็นจำนวนเต็ม
ลิเทอรัลที่ระบุขอบเขตบนของความลึกของการค้นหา ผลลัพธ์ที่ได้
กราฟจะมีเฉพาะโหนดที่อยู่ในระยะของความลึกที่ระบุจากจุด
โหนดในชุดอาร์กิวเมนต์ ดังนั้น rdeps(//foo, //common, 1)
จะประเมินโหนดทั้งหมด
ในการปิดแบบทางอ้อมของ //foo
ที่ขึ้นอยู่กับ //common
โดยตรง (
ตัวเลขที่สอดคล้องกับอันดับที่แสดงในเอาต์พุต minrank
format.) หากเว้นพารามิเตอร์ depth ไว้
แบบไม่มีขอบเขตจำกัด
การปิดแบบทางอ้อมของทรัพยากร Dependency แบบย้อนกลับทั้งหมด: allrdeps
expr ::= allrdeps(expr)
| allrdeps(expr, depth)
โอเปอเรเตอร์ allrdeps
ทํางานเหมือนกับ rdeps
ยกเว้นว่า "หรือชุดจักรวาล" คืออะไรก็ตามที่ Flag --universe_scope
ประเมินผล แทนที่จะระบุแยกต่างหาก ดังนั้น หาก
ผ่าน--universe_scope=//foo/...
แล้ว allrdeps(//bar)
เทียบเท่ากับ rdeps(//foo/..., //bar)
ทรัพยากร Dependency แบบย้อนกลับโดยตรงในแพ็กเกจเดียวกัน: 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
กราฟผลลัพธ์จะถูกเรียงลำดับตามความสัมพันธ์ในการพึ่งพา ดูรายละเอียดเพิ่มเติมได้ที่ส่วนลำดับกราฟ
การกรองชนิดเป้าหมาย: ชนิด
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))
ประเมินชุดของไฟล์ต้นฉบับทั้งหมดในการปิดแบบทรานซิทีฟ
ทรัพยากร 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 เนื่องจากทั้งหมด
ชื่อเป้าหมายที่ขึ้นต้นด้วย //
อาจใช้เป็นชื่ออื่นได้
ไปยังแท็ก Anchor ของนิพจน์ทั่วไป ^
โอเปอเรเตอร์นี้มักมอบทางเลือกที่รวดเร็วและมีประสิทธิภาพมากกว่า
โอเปอเรเตอร์ intersect
รายการ เช่น หากต้องการดูทั้งหมด
ทรัพยากร Dependency bar
ของเป้าหมาย //foo:foo
มี 1 รายการ
ประเมินผล
deps(//foo) intersect //bar/...
อย่างไรก็ตาม คำสั่งนี้ต้องมีการแยกวิเคราะห์ไฟล์ BUILD
ทั้งหมดใน
แผนผัง bar
ลำดับ ซึ่งจะทำงานช้าและมีแนวโน้มว่าจะเกิดข้อผิดพลาด
BUILD
ไฟล์ที่ไม่เกี่ยวข้อง อีกทางเลือกหนึ่งคือ
filter(//bar, deps(//foo))
ซึ่งจะคำนวณชุดทรัพยากร Dependency ของ //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))
จะเลือกทรัพยากร 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))
จะเลือกกฎทั้งหมดในทรัพยากร Dependency //foo
ที่ระบุ
ค่าในแอตทริบิวต์ data
อย่างน้อย 1 ค่า (ทุกป้ายกำกับต้องมีค่าอย่างน้อย
3 อักขระเนื่องจาก //
และ :
)
หากต้องการเลือกกฎทั้งหมดในทรัพยากร Dependency //foo
ที่มี value
ที่เฉพาะเจาะจงใน
แอตทริบิวต์ประเภทรายการ ให้ใช้
attr("tags", "[\[ ]value[,\]]", deps(//foo))
ซึ่งทำได้เนื่องจากอักขระที่อยู่ก่อน value
จะเป็น [
หรือการเว้นวรรคและ
อักขระที่อยู่หลัง value
จะเป็นเครื่องหมายจุลภาคหรือ ]
การกรองระดับการเข้าถึงกฎ: มองเห็นได้
expr ::= visible(expr, expr)
โอเปอเรเตอร์ visible(predicate, input)
ใช้ตัวกรองกับชุดของเป้าหมาย และทิ้งเป้าหมายที่ไม่มีฟิลด์
ระดับการเข้าถึงที่ต้องการ
อาร์กิวเมนต์แรก predicate คือชุดของเป้าหมายที่ทุกเป้าหมาย ในเอาต์พุตจะต้องมองเห็นได้ นิพจน์ visible ประเมินชุดที่มีเป้าหมายทั้งหมด x เพื่อให้ x เป็นสมาชิกของชุด input และสำหรับเป้าหมายทั้งหมด y ใน y มองเห็น predicate x เช่น
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
ข้อ
ไฟล์คำจำกัดความของแพ็กเกจ: ไฟล์บิลด์
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
อย่างชัดเจนก็ตาม แต่ระบบจะใช้ Symlinks เพื่อให้
ถ้า foo/BUILD
เป็นลิงก์สัญลักษณ์ไปยัง bar/BUILD
แล้ว
rbuildfiles(bar/BUILD)
จะรวม //foo:BUILD
ในผลลัพธ์
ตัวดำเนินการ rbuildfiles
เกือบจะมีค่าผกผันกับ
โอเปอเรเตอร์ buildfiles
แต่การกลับทางศีลธรรมนี้
มีผลในทิศทางเดียวมากกว่า เอาต์พุตของ rbuildfiles
เหมือนกับ
อินพุตของ buildfiles
ไฟล์แรกจะมีเป้าหมายไฟล์เพียง BUILD
รายการในแพ็กเกจ
และเป้าหมายหลังอาจมีเป้าหมายเหล่านั้น ในอีกทิศทางหนึ่ง การสื่อสารจะอ่อนกว่า
เอาต์พุตของโอเปอเรเตอร์ buildfiles
คือเป้าหมายที่ตรงกับแพ็กเกจทั้งหมดและbzl
ที่จำเป็นตามอินพุตที่กำหนด แต่อินพุตของโอเปอเรเตอร์ rbuildfiles
จะ
ไม่ใช่เป้าหมายเหล่านั้น แต่เป็นส่วนย่อยของเส้นทางที่สอดคล้องกับเป้าหมายเหล่านั้น
ไฟล์การกำหนดแพ็กเกจ: ไฟล์โหลด
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 จะพิมพ์ผลลัพธ์เสมอ
เรียงลำดับตามอันดับหรืออันดับทรัพยากร Dependency
เมื่อธงนี้คือ deps
แล้ว Bazel จะพิมพ์ผลลัพธ์ตามลำดับโทโพโลยี กล่าวคือ
ทรัพยากร Dependency ก่อน แต่โหนดที่ไม่ได้เรียงลำดับตามการขึ้นต่อกัน
(เนื่องจากไม่มีเส้นทางจากที่หนึ่งไปยังอีกที่หนึ่ง) สามารถพิมพ์ในลำดับใดก็ได้
เมื่อแฟล็กนี้มีค่าเป็น full
Bazel จะพิมพ์โหนดตามลำดับที่กำหนดโดยสมบูรณ์ (ทั้งหมด)
ขั้นแรก โหนดทั้งหมดจัดเรียงตามตัวอักษร จากนั้น แต่ละโหนดในรายการจะใช้เป็นจุดเริ่มต้นของ
การค้นหาหลังจากคำสั่งซื้อที่มีความลึกเป็นหลัก ซึ่งมีการข้ามผ่านขอบขาออกไปยังโหนดที่ยังไม่ได้เข้าชม
ลำดับตัวอักษรของโหนดที่สืบทอดมา สุดท้าย โหนดจะถูกพิมพ์กลับกันของลำดับ
ที่ได้เข้าชม
โหนดการพิมพ์ในลำดับนี้อาจทำงานได้ช้าลง ดังนั้นจึงควรใช้เมื่อการกำหนดเงื่อนไขคือเท่านั้น เป็นอย่างมาก
พิมพ์รูปแบบแหล่งที่มาของเป้าหมายตามที่จะปรากฏใน BUILD
--output build
ด้วยตัวเลือกนี้ การนำเสนอของแต่ละเป้าหมายจะเป็นเสมือน
ที่เขียนด้วยลายมือในภาษา BUILD ตัวแปรและการเรียกใช้ฟังก์ชันทั้งหมด
(เช่น glob, มาโคร) จะถูกขยายออก ซึ่งมีประโยชน์สำหรับการดูผลลัพธ์
ของมาโคร Starlark นอกจากนี้ กฎที่มีผลแต่ละกฎจะรายงาน
generator_name
และ/หรือ generator_function
)
ด้วยชื่อของมาโครที่ได้รับการประเมินเพื่อสร้างกฎที่มีประสิทธิภาพ
แม้ว่าเอาต์พุตจะใช้ไวยากรณ์เดียวกันกับไฟล์ BUILD
แต่ก็ไม่ใช่
รับประกันว่าจะสร้างไฟล์ BUILD
ที่ถูกต้อง
พิมพ์ป้ายกำกับของแต่ละเป้าหมาย
--output label
เมื่อใช้ตัวเลือกนี้ ชุดชื่อ (หรือ ป้ายกำกับ) ของแต่ละเป้าหมาย
ในกราฟผลลัพธ์จะถูกพิมพ์ หนึ่งป้ายกำกับต่อบรรทัด
ลำดับต้นๆ (ยกเว้นที่ระบุ --noorder_results
โปรดดู
หมายเหตุเกี่ยวกับลำดับของผลลัพธ์)
(ลำดับโทโพโลยีคือการที่กราฟ
ปรากฏก่อนโหนดสืบทอดทั้งหมด) แน่นอน
เป็นลำดับต้นๆ ของกราฟที่เป็นไปได้หลายแบบ (ย้อนกลับ
Postorder เป็นเพียง 1 บริษัทเท่านั้น) ไม่ได้เลือกอันไหน
เมื่อพิมพ์เอาต์พุตของคำค้นหา somepath
คำสั่งซื้อ
ที่จะพิมพ์โหนดคือลำดับของเส้นทาง
ข้อควรระวัง: ในบางกรณี อาจมีเป้าหมายที่ต่างกัน 2 เป้าหมาย
ป้ายกำกับเดียวกัน ตัวอย่างเช่น กฎ sh_binary
และ
สามารถเรียกไฟล์ srcs
เพียงไฟล์เดียว (โดยนัย) ได้ทั้งคู่
foo.sh
หากผลการค้นหามีทั้ง 2 แบบ
เป้าหมายเหล่านี้ เอาต์พุต (ในรูปแบบ label
) จะปรากฏ
ที่จะมีสำเนา เมื่อใช้ label_kind
(โปรดดู
ด้านล่าง) จะมีความแตกต่างที่ชัดเจน นั่นคือเป้าหมายทั้งสองมี
ชื่อเดียวกัน แต่มีประเภท sh_binary rule
และ
ประเภทอื่น ๆ อย่าง source file
พิมพ์ป้ายกำกับและชนิดของเป้าหมายแต่ละรายการ
--output label_kind
เช่นเดียวกับ label
รูปแบบเอาต์พุตนี้จะพิมพ์ป้ายกำกับของ
แต่ละเป้าหมายในกราฟผลลัพธ์ โดยเรียงตามลำดับโทโพโลยี แต่
และอยู่ก่อนหน้าป้ายกำกับด้วย kind ของเป้าหมาย
เป้าหมายที่พิมพ์ในรูปแบบบัฟเฟอร์โปรโตคอล
--output proto
พิมพ์ผลลัพธ์การค้นหาเป็น
QueryResult
บัฟเฟอร์โปรโตคอล
เป้าหมายที่พิมพ์ในรูปแบบบัฟเฟอร์โปรโตคอลที่คั่นด้วยความยาว
--output streamed_proto
พิมพ์
ตัวคั่นความยาว
สตรีมของ
Target
และบัฟเฟอร์โปรโตคอล วิธีนี้มีประโยชน์ในการ (1) ไปยังที่ต่างๆ
ข้อจำกัดด้านขนาด
ของบัฟเฟอร์โปรโตคอลเมื่อมีการกำหนดเป้าหมายจำนวนมากเกินกว่าที่จะพอดีกับ 1 รายการ
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
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) สามารถใช้ผลลัพธ์การค้นหาเพื่อทำตามขั้นตอน
ซึ่งช่วยให้เครื่องมือ Query ของ Bazel สามารถใช้เป็น
Dependency-graph-aware "grep for BUILD files"
ข้อมูลตำแหน่งจะแตกต่างกันไปตามประเภทเป้าหมาย (ดูโอเปอเรเตอร์ kind) สำหรับกฎ พารามิเตอร์
พิมพ์ตำแหน่งของการประกาศกฎภายในไฟล์ BUILD
แล้ว
สำหรับไฟล์ต้นฉบับ ตำแหน่งของบรรทัดที่ 1 ของไฟล์จริงคือ
พิมพ์แล้ว สำหรับไฟล์ที่สร้างขึ้น ตำแหน่งของกฎที่
แล้วพิมพ์ออกมา (เครื่องมือสืบค้นข้อมูลมี
เพื่อหาตำแหน่งที่แท้จริงของไฟล์ที่สร้างขึ้น และ
ไม่ว่าในกรณีใดๆ อาจไม่มีอยู่หากยังไม่มีการดำเนินการสร้าง)
พิมพ์ชุดแพ็กเกจ
--output package
ตัวเลือกนี้จะพิมพ์ชื่อแพ็กเกจทั้งหมด เป้าหมายบางส่วนในชุดผลลัพธ์เป็น ชื่อจะพิมพ์อยู่ใน ลำดับแบบพจนานุกรม ไม่รวมรายการซ้ำ อย่างเป็นทางการ เป็นการคาดคะเนจากชุดป้ายกำกับ (แพ็กเกจ เป้าหมาย) ไปยัง แพ็กเกจของคุณ
แพ็กเกจในที่เก็บภายนอกมีการจัดรูปแบบเป็น
@repo//foo/bar
ในขณะที่แพ็กเกจในที่เก็บหลัก
มีรูปแบบเป็น foo/bar
เอาต์พุตนี้ที่ใช้ร่วมกับการค้นหา deps(...)
เพื่อค้นหาชุดแพ็กเกจที่ต้องทำเครื่องหมายได้
เพื่อสร้างชุดเป้าหมายหนึ่งๆ
แสดงกราฟของผลลัพธ์
--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
องค์ประกอบเพื่อให้โทโพโลยีของ
สามารถสร้างกราฟทรัพยากร 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) แล้วผลการค้นหาจะรวมทรัพยากร 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
ที่เก็บภายนอกนั้นไม่ใช่ทรัพยากร 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