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

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

  • 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) ของเป้าหมาย เหลือเพียง ประเภทข้อมูล

การตั้งค่าและกราฟอ้างอิงถึงประเภทข้อมูลเดียวกัน แต่เน้นที่ข้อมูลที่แตกต่างกัน ของโมเดล เช่น

• Set: ลำดับบางส่วนของเป้าหมายไม่น่าสนใจ
• กราฟ: ลำดับบางส่วนของเป้าหมายมีนัยสำคัญ

วงจรในกราฟทรัพยากร Dependency

กราฟทรัพยากร Dependency ควรเป็นแบบวนซ้ำ

อัลกอริทึมที่ใช้โดยภาษาในการค้นหานั้นมีไว้เพื่อใช้ใน กราฟแบบวนซ้ำ แต่มีความทนทานเมื่อเทียบกับวงจร รายละเอียดเกี่ยวกับวิธีการ จะไม่ได้ระบุรอบ และไม่ควรนำมาใช้

ทรัพยากร Dependency โดยนัย

นอกจากการสร้างทรัพยากร Dependency ที่กําหนดไว้อย่างชัดแจ้งในไฟล์ BUILD แล้ว Bazel เพิ่มการพึ่งพา implicit เพิ่มเติมลงในกฎ ทรัพยากร Dependency โดยนัย อาจกำหนดโดย:

• แอตทริบิวต์ส่วนตัว
• ข้อกำหนดของ Toolchain

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

โปรดทราบว่าเนื่องจากคำค้นหาไม่ได้พิจารณาการกำหนดค่า อาจมี Toolchain ที่เป็นไปได้ การติดตั้งใช้งานไม่ถือว่าเป็นทรัพยากร Dependency แต่มีเพียง ประเภท 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 เหมือนกับ ของ expr₂ รายการ โดยไม่มีค่าใช้จ่ายทั้งหมด ของตัวแปร name ถูกแทนที่ด้วยค่าของ expr₁

ตัวอย่างเช่น 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) ประเมินหาการอ้างอิงกลับของชุดอาร์กิวเมนต์ 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 = "...",
        )
      

ดังนั้น 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

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

เมื่อแฟล็กนี้มีค่าเป็น 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

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

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