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

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

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

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

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

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

การค้นหากราฟการดำเนินการ (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 คีย์เวิร์ดคือคำที่สงวนไว้ของภาษานั้นๆ ซึ่งจะอธิบายแต่ละคำด้านล่างนี้ คีย์เวิร์ดทั้งหมดมีดังนี้

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

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

ความเสียง

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

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

เกี่ยวกับการคงลําดับของกราฟ

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

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

deps(x) union y

ลำดับของชุดผลลัพธ์สุดท้ายจะรับประกันว่าข้อจำกัดการจัดเรียงทั้งหมดของนิพจน์ย่อยจะยังคงอยู่ กล่าวคือ ลำดับความเกี่ยวข้องแบบทรานซิทีฟทั้งหมดของ 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 เท่านั้น ไม่มีทรัพยากร 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 มีข้อดีและข้อเสียบางอย่างเมื่อเทียบกับการค้นหาเริ่มต้น แต่ข้อเสียหลักๆ คือไม่สามารถเรียงลำดับเอาต์พุตตามลำดับกราฟได้ ทำให้ระบบไม่อนุญาตให้ใช้รูปแบบเอาต์พุตบางรูปแบบ ข้อดีคือมีโอเปอเรเตอร์ 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 จะประเมินชุดที่มีองค์ประกอบเดียว เป้าหมาย และกฎ 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/... ซึ่งมีองค์ประกอบหลายพันรายการ) หรือกับชุดว่างเปล่าหากรูปแบบเป้าหมายไม่ตรงกับเป้าหมาย

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

ตัวแปร

expr ::= let name = expr1 in expr2
       | $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 ...) โอเปอเรเตอร์จะคํานวณยูเนียนของชุดรูปแบบเป้าหมายอย่างน้อย 1 ชุด โดยคั่นด้วยเว้นวรรค (ไม่มีคอมมา)

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

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

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

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

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

หมายเหตุ: set() ไม่ได้กำหนดข้อจำกัดการเรียงลำดับกราฟ ดังนั้นข้อมูลเส้นทางอาจสูญหายไปเมื่อบันทึกและโหลดชุดของโหนดซ้ำที่ใช้ชุดข้อมูลดังกล่าว ดูรายละเอียดเพิ่มเติมได้ที่ส่วนลําดับกราฟด้านล่าง

ฟังก์ชัน

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) จะประเมินทรัพยากร Dependency แบบย้อนกลับของชุดอาร์กิวเมนต์ x ภายในปิดทรานซิทีฟของชุดจักรวาล u

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

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

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

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

หมายเหตุ: ใช้ได้กับ Sky Query

เท่านั้น

โอเปอเรเตอร์ allrdeps ทํางานเหมือนกับโอเปอเรเตอร์ rdeps เว้นแต่ "ชุดจักรวาล" จะเป็นอะไรก็ตามที่แฟล็ก --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 หรือไม่ก็ได้ หากไม่มี ผลลัพธ์จะเป็นชุดเดี่ยวที่มีการเลือกเป้าหมายเพียง 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

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

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

somepath(S1 + S2, E) ผลลัพธ์อื่นที่เป็นไปได้

allpaths(S1 + S2, 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)) จะประเมินเป็นชุดของไฟล์ต้นฉบับทั้งหมดใน 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 เนื่องจากชื่อเป้าหมายทั้งหมดขึ้นต้นด้วย // จึงอาจใช้แทน Anchor ของนิพจน์ทั่วไป ^ ได้

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

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

จะเลือก //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 โดยตรงหรือโดยอ้อม

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

expr ::= buildfiles(expr)

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

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

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

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

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

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

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

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

หมายเหตุ: ใช้ได้กับ Sky Query เท่านั้น

โอเปอเรเตอร์ 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 คือจักรวาลที่ระบุโดย Flag --universe_scope ไฟล์ที่ไม่ตรงกับไฟล์ BUILD และไฟล์ .bzlโดยตรงจะไม่ส่งผลต่อผลลัพธ์ ตัวอย่างเช่น ระบบจะไม่สนใจไฟล์ต้นทาง (เช่น foo.cc) แม้ว่าจะมีการพูดถึงไฟล์ดังกล่าวอย่างชัดเจนในไฟล์ BUILD อย่างไรก็ตาม ระบบจะยึดตามลิงก์สัญลักษณ์ ดังนั้นหาก foo/BUILD เป็นลิงก์สัญลักษณ์ไปยัง bar/BUILD แล้ว rbuildfiles(bar/BUILD) ก็จะรวม //foo:BUILD ไว้ในผลลัพธ์ด้วย

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

ไฟล์การกำหนดแพ็กเกจ: ไฟล์โหลด

expr ::= loadfiles(expr)

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

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

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

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

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

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

เกี่ยวกับลําดับของผลการค้นหา

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

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

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

เมื่อ Flag นี้เป็น 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 รูปแบบเอาต์พุตนี้จะพิมพ์ป้ายกำกับของเป้าหมายแต่ละรายการในกราฟผลลัพธ์ตามลำดับของโทโพโลยี แต่อยู่ก่อนป้ายกำกับด้วย ประเภท ของเป้าหมาย

พิมพ์เป้าหมายในรูปแบบ Protocol Buffer

--output proto

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

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

--output streamed_proto

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

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

--output textproto

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

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

--output streamed_jsonproto

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

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

--output minrank --output maxrank

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

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

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

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

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

หมายเหตุ: เอาต์พุตที่จัดอันดับของการค้นหา somepath นั้นโดยทั่วไปแล้วไม่มีความหมาย เนื่องจาก somepath ไม่รับประกันว่าจะแสดงผลเส้นทางที่สั้นที่สุดหรือยาวที่สุด และอาจรวมขอบ "แบบสื่อกลาง" จากโหนดเส้นทางหนึ่งไปยังอีกโหนดหนึ่งซึ่งไม่ใช่ขอบโดยตรงในกราฟต้นฉบับ

เช่น กราฟทางด้านซ้ายให้เอาต์พุตทางด้านขวาเมื่อระบุ --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 เป็น "grep for BUILD files" แบบ Dependency-graph-aware "grep for BUILD files"

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

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

--output package

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

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

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

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

--output graph

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

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

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

--graph:node_limit n

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

--[no]graph:factored

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

XML

--output xml

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

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

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

</query>

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

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

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

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

ระบบจะระงับองค์ประกอบ 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 ได้

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

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