Add support for 'build --query'

keith · keith · commit 4307f8c768ab · 2025-09-22T22:31:06.000Z
This allows combining the common pattern of build and then query into a single build command that executes the passed query (or query_file) Fixes #26938 RELNOTES[inc]: Add 'build --query' flag for building the result of a bazel query in a single command
diff --git a/src/main/java/com/google/devtools/build/lib/buildtool/BuildRequestOptions.java b/src/main/java/com/google/devtools/build/lib/buildtool/BuildRequestOptions.java
@@ -366,6 +366,28 @@ public String getSymlinkPrefix(String productName) {
               + "line. It is an error to specify a file here as well as command-line patterns.")
   public String targetPatternFile;
 
+  @Option(
+      name = "query",
+      defaultValue = "",
+      documentationCategory = OptionDocumentationCategory.GENERIC_INPUTS,
+      effectTags = {OptionEffectTag.CHANGES_INPUTS},
+      help =
+          "If set, build will evaluate the query expression and build the resulting targets. "
+              + "Example: --query='deps(//foo) - deps(//bar)'. It is an error to specify this "
+              + "along with command-line patterns or --target_pattern_file.")
+  public String query;
+
+  @Option(
+      name = "query_file",
+      defaultValue = "",
+      documentationCategory = OptionDocumentationCategory.GENERIC_INPUTS,
+      effectTags = {OptionEffectTag.CHANGES_INPUTS},
+      help =
+          "If set, build will read a query expression from the file named here and build the "
+              + "resulting targets. It is an error to specify this along with command-line patterns, "
+              + "--target_pattern_file, or --query.")
+  public String queryFile;
+
   /**
    * Do not use directly. Instead use {@link
    * com.google.devtools.build.lib.runtime.CommandEnvironment#withMergedAnalysisAndExecutionSourceOfTruth()}.
diff --git a/src/main/java/com/google/devtools/build/lib/runtime/commands/TargetPatternsHelper.java b/src/main/java/com/google/devtools/build/lib/runtime/commands/TargetPatternsHelper.java
@@ -20,19 +20,41 @@
 import com.google.common.base.Preconditions;
 import com.google.common.base.Splitter;
 import com.google.devtools.build.lib.buildtool.BuildRequestOptions;
+import com.google.devtools.build.lib.cmdline.RepositoryMapping;
+import com.google.devtools.build.lib.cmdline.RepositoryName;
+import com.google.devtools.build.lib.cmdline.TargetPattern;
+import com.google.devtools.build.lib.packages.LabelPrinter;
+import com.google.devtools.build.lib.packages.Target;
+import com.google.devtools.build.lib.packages.semantics.BuildLanguageOptions;
 import com.google.devtools.build.lib.profiler.Profiler;
 import com.google.devtools.build.lib.profiler.SilentCloseable;
+import com.google.devtools.build.lib.query2.common.AbstractBlazeQueryEnvironment;
+import com.google.devtools.build.lib.query2.common.UniverseScope;
+import com.google.devtools.build.lib.query2.engine.QueryEnvironment;
+import com.google.devtools.build.lib.query2.engine.QueryEnvironment.Setting;
+import com.google.devtools.build.lib.query2.engine.QueryEvalResult;
+import com.google.devtools.build.lib.query2.engine.QueryException;
+import com.google.devtools.build.lib.query2.engine.QueryExpression;
+import com.google.devtools.build.lib.query2.engine.QuerySyntaxException;
+import com.google.devtools.build.lib.query2.engine.ThreadSafeOutputFormatterCallback;
+import com.google.devtools.build.lib.query2.query.output.QueryOptions;
 import com.google.devtools.build.lib.runtime.CommandEnvironment;
+import com.google.devtools.build.lib.runtime.LoadingPhaseThreadsOption;
 import com.google.devtools.build.lib.runtime.ProjectFileSupport;
 import com.google.devtools.build.lib.runtime.events.InputFileEvent;
+import com.google.devtools.build.lib.skyframe.RepositoryMappingValue.RepositoryMappingResolutionException;
 import com.google.devtools.build.lib.server.FailureDetails.FailureDetail;
 import com.google.devtools.build.lib.server.FailureDetails.TargetPatterns;
 import com.google.devtools.build.lib.vfs.FileSystemUtils;
 import com.google.devtools.build.lib.vfs.Path;
 import com.google.devtools.common.options.OptionsParsingResult;
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.Set;
 import java.util.function.Predicate;
+import net.starlark.java.eval.StarlarkSemantics;
 
 /** Provides support for reading target patterns from a file or the command-line. */
 public final class TargetPatternsHelper {
@@ -42,20 +64,58 @@ public final class TargetPatternsHelper {
   private TargetPatternsHelper() {}
 
   /**
-   * Reads a list of target patterns, either from the command-line residue or by reading newline
-   * delimited target patterns from the --target_pattern_file flag. If --target_pattern_file is
-   * specified and options contain a residue, or if the file cannot be read, throws {@link
-   * TargetPatternsHelperException}.
+   * Reads a list of target patterns, either from the command-line residue, by reading newline
+   * delimited target patterns from the --target_pattern_file flag, or from --query/--query_file.
+   * If multiple options are specified, throws {@link TargetPatternsHelperException}.
+   *
+   * @return A list of target patterns.
    */
   public static List<String> readFrom(CommandEnvironment env, OptionsParsingResult options)
       throws TargetPatternsHelperException {
     List<String> targets = options.getResidue();
     BuildRequestOptions buildRequestOptions = options.getOptions(BuildRequestOptions.class);
-    if (!targets.isEmpty() && !buildRequestOptions.targetPatternFile.isEmpty()) {
+
+    int optionCount = 0;
+    if (!targets.isEmpty()) optionCount++;
+    if (!buildRequestOptions.targetPatternFile.isEmpty()) optionCount++;
+    if (!buildRequestOptions.query.isEmpty()) optionCount++;
+    if (!buildRequestOptions.queryFile.isEmpty()) optionCount++;
+    if (optionCount > 1) {
       throw new TargetPatternsHelperException(
-          "Command-line target pattern and --target_pattern_file cannot both be specified",
+          "Only one of command-line target patterns, --target_pattern_file, --query, "
+              + "or --query_file may be specified",
           TargetPatterns.Code.TARGET_PATTERN_FILE_WITH_COMMAND_LINE_PATTERN);
-    } else if (!buildRequestOptions.targetPatternFile.isEmpty()) {
+    }
+
+    if (!buildRequestOptions.query.isEmpty()) {
+      try {
+        return executeQuery(env, buildRequestOptions.query, options);
+      } catch (QueryException | InterruptedException | IOException e) {
+        throw new TargetPatternsHelperException(
+            "Error executing query: " + e.getMessage(),
+            TargetPatterns.Code.TARGET_PATTERNS_UNKNOWN);
+      }
+    } else if (!buildRequestOptions.queryFile.isEmpty()) {
+      Path queryFilePath = env.getWorkingDirectory().getRelative(buildRequestOptions.queryFile);
+      try {
+        env.getEventBus()
+            .post(
+                InputFileEvent.create(
+                    /* type= */ "query_file", queryFilePath.getFileSize()));
+        String queryExpression = FileSystemUtils.readContent(queryFilePath, ISO_8859_1).trim();
+        return executeQuery(env, queryExpression, options);
+      } catch (IOException e) {
+        throw new TargetPatternsHelperException(
+            "I/O error reading from " + queryFilePath.getPathString() + ": " + e.getMessage(),
+            TargetPatterns.Code.TARGET_PATTERN_FILE_READ_FAILURE);
+      } catch (QueryException | InterruptedException e) {
+        throw new TargetPatternsHelperException(
+            "Error executing query from file: " + e.getMessage(),
+            TargetPatterns.Code.TARGET_PATTERNS_UNKNOWN);
+      }
+    }
+
+    if (!buildRequestOptions.targetPatternFile.isEmpty()) {
       // Works for absolute or relative file.
       Path residuePath =
           env.getWorkingDirectory().getRelative(buildRequestOptions.targetPatternFile);
@@ -100,4 +160,64 @@ public FailureDetail getFailureDetail() {
           .build();
     }
   }
+
+  /** Executes a query and returns the resulting target patterns. */
+  private static List<String> executeQuery(
+      CommandEnvironment env, String queryExpression, OptionsParsingResult options)
+      throws QueryException, InterruptedException, IOException, TargetPatternsHelperException {
+    try {
+      LoadingPhaseThreadsOption threadsOption = options.getOptions(LoadingPhaseThreadsOption.class);
+      RepositoryMapping repoMapping =
+          env.getSkyframeExecutor()
+              .getMainRepoMapping(false, threadsOption.threads, env.getReporter());
+      TargetPattern.Parser mainRepoTargetParser =
+          new TargetPattern.Parser(env.getRelativeWorkingDirectory(), RepositoryName.MAIN, repoMapping);
+
+      StarlarkSemantics starlarkSemantics =
+          options.getOptions(BuildLanguageOptions.class).toStarlarkSemantics();
+      LabelPrinter labelPrinter =
+          new QueryOptions().getLabelPrinter(starlarkSemantics, mainRepoTargetParser.getRepoMapping());
+
+      AbstractBlazeQueryEnvironment<Target> queryEnv =
+          QueryEnvironmentBasedCommand.newQueryEnvironment(
+              env,
+              /* keepGoing=*/ false,
+              /* orderedResults= */ false,
+              UniverseScope.EMPTY,
+              threadsOption.threads,
+              Set.of(),
+              /* useGraphlessQuery= */ true,
+              mainRepoTargetParser,
+              labelPrinter);
+
+      QueryExpression expr = QueryExpression.parse(queryExpression, queryEnv);
+      Set<String> targetPatterns = new LinkedHashSet<>();
+      ThreadSafeOutputFormatterCallback<Target> callback =
+          new ThreadSafeOutputFormatterCallback<Target>() {
+            @Override
+            public void processOutput(Iterable<Target> partialResult) {
+              for (Target target : partialResult) {
+                targetPatterns.add(target.getLabel().toString());
+              }
+            }
+          };
+
+      QueryEvalResult result = queryEnv.evaluateQuery(expr, callback);
+      if (!result.getSuccess()) {
+        throw new TargetPatternsHelperException("Query evaluation failed",
+            TargetPatterns.Code.TARGET_PATTERNS_UNKNOWN);
+      }
+
+      return new ArrayList<>(targetPatterns);
+    } catch (InterruptedException e) {
+      throw new TargetPatternsHelperException("Query interrupted",
+          TargetPatterns.Code.TARGET_PATTERNS_UNKNOWN);
+    } catch (RepositoryMappingResolutionException e) {
+      throw new TargetPatternsHelperException(e.getMessage(),
+          TargetPatterns.Code.TARGET_PATTERNS_UNKNOWN);
+    } catch (QuerySyntaxException e) {
+      throw new TargetPatternsHelperException("Query syntax error: " + e.getMessage(),
+          TargetPatterns.Code.TARGET_PATTERNS_UNKNOWN);
+    }
+  }
 }
diff --git a/src/test/java/com/google/devtools/build/lib/runtime/commands/TargetPatternsHelperTest.java b/src/test/java/com/google/devtools/build/lib/runtime/commands/TargetPatternsHelperTest.java
@@ -112,7 +112,8 @@ public void testSpecifyPatternAndFileThrows() throws OptionsParsingException {
             TargetPatternsHelperException.class, () -> TargetPatternsHelper.readFrom(env, options));
 
     String message =
-        "Command-line target pattern and --target_pattern_file cannot both be specified";
+        "Only one of command-line target patterns, --target_pattern_file, --query, "
+            + "or --query_file may be specified";
     assertThat(expected).hasMessageThat().isEqualTo(message);
     assertThat(expected.getFailureDetail())
         .isEqualTo(
@@ -140,6 +141,58 @@ public void testSpecifyNonExistingFileThrows() throws OptionsParsingException {
         .isEqualTo(Code.TARGET_PATTERN_FILE_READ_FAILURE);
   }
 
+  @Test
+  public void testSpecifyMultipleOptionsThrows() throws OptionsParsingException {
+    options.parse("--target_pattern_file=patterns.txt", "--query=deps(//...)");
+
+    TargetPatternsHelperException expected =
+        assertThrows(
+            TargetPatternsHelperException.class, () -> TargetPatternsHelper.readFrom(env, options));
+
+    String message =
+        "Only one of command-line target patterns, --target_pattern_file, --query, "
+            + "or --query_file may be specified";
+    assertThat(expected).hasMessageThat().isEqualTo(message);
+    assertThat(expected.getFailureDetail())
+        .isEqualTo(
+            FailureDetail.newBuilder()
+                .setMessage(message)
+                .setTargetPatterns(
+                    TargetPatterns.newBuilder()
+                        .setCode(Code.TARGET_PATTERN_FILE_WITH_COMMAND_LINE_PATTERN))
+                .build());
+  }
+
+  @Test
+  public void testSpecifyQueryAndPatternThrows() throws OptionsParsingException {
+    options.parse("--query=deps(//...)");
+    options.setResidue(ImmutableList.of("//some:pattern"), ImmutableList.of());
+
+    TargetPatternsHelperException expected =
+        assertThrows(
+            TargetPatternsHelperException.class, () -> TargetPatternsHelper.readFrom(env, options));
+
+    String message =
+        "Only one of command-line target patterns, --target_pattern_file, --query, "
+            + "or --query_file may be specified";
+    assertThat(expected).hasMessageThat().isEqualTo(message);
+  }
+
+  @Test
+  public void testQueryFileWithNonExistingFileThrows() throws OptionsParsingException {
+    options.parse("--query_file=query.txt");
+
+    TargetPatternsHelperException expected =
+        assertThrows(
+            TargetPatternsHelperException.class, () -> TargetPatternsHelper.readFrom(env, options));
+
+    String regex = "I/O error reading from .*query.txt.*\\(No such file or directory\\)";
+    assertThat(expected).hasMessageThat().matches(regex);
+    assertThat(expected.getFailureDetail().hasTargetPatterns()).isTrue();
+    assertThat(expected.getFailureDetail().getTargetPatterns().getCode())
+        .isEqualTo(Code.TARGET_PATTERN_FILE_READ_FAILURE);
+  }
+
   private static class MockEventBus extends EventBus {
     final Set<InputFileEvent> inputFileEvents = Sets.newConcurrentHashSet();
 
diff --git a/src/test/shell/integration/BUILD b/src/test/shell/integration/BUILD
@@ -113,6 +113,16 @@ sh_test(
     ],
 )
 
+sh_test(
+    name = "build_query_test",
+    size = "medium",
+    srcs = ["build_query_test.sh"],
+    data = [
+        ":test-deps",
+        "@bazel_tools//tools/bash/runfiles",
+    ],
+)
+
 sh_test(
     name = "loading_phase_tests",
     size = "large",
diff --git a/src/test/shell/integration/build_query_test.sh b/src/test/shell/integration/build_query_test.sh
@@ -0,0 +1,106 @@
+#!/usr/bin/env bash
+#
+# Copyright 2025 The Bazel Authors. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# --- begin runfiles.bash initialization ---
+set -euo pipefail
+
+if [[ ! -d "${RUNFILES_DIR:-/dev/null}" && ! -f "${RUNFILES_MANIFEST_FILE:-/dev/null}" ]]; then
+  if [[ -f "$0.runfiles_manifest" ]]; then
+    export RUNFILES_MANIFEST_FILE="$0.runfiles_manifest"
+  elif [[ -f "$0.runfiles/MANIFEST" ]]; then
+    export RUNFILES_MANIFEST_FILE="$0.runfiles/MANIFEST"
+  elif [[ -f "$0.runfiles/bazel_tools/tools/bash/runfiles/runfiles.bash" ]]; then
+    export RUNFILES_DIR="$0.runfiles"
+  fi
+fi
+if [[ -f "${RUNFILES_DIR:-/dev/null}/bazel_tools/tools/bash/runfiles/runfiles.bash" ]]; then
+  source "${RUNFILES_DIR}/bazel_tools/tools/bash/runfiles/runfiles.bash"
+elif [[ -f "${RUNFILES_MANIFEST_FILE:-/dev/null}" ]]; then
+  source "$(grep -m1 "^bazel_tools/tools/bash/runfiles/runfiles.bash " \
+            "$RUNFILES_MANIFEST_FILE" | cut -d ' ' -f 2-)"
+else
+  echo >&2 "ERROR: cannot find @bazel_tools//tools/bash/runfiles:runfiles.bash"
+  exit 1
+fi
+# --- end runfiles.bash initialization ---
+
+source "$(rlocation "io_bazel/src/test/shell/integration_test_setup.sh")" \
+  || { echo "integration_test_setup.sh not found!" >&2; exit 1; }
+
+function set_up() {
+  touch MODULE.bazel
+  mkdir -p a b
+
+  cat > a/BUILD <<'EOF'
+filegroup(
+    name = "files",
+    srcs = ["file.txt"],
+    visibility = ["//visibility:public"],
+)
+
+genrule(
+    name = "rule_a",
+    srcs = [":files"],
+    outs = ["output_a.txt"],
+    cmd = "cp $< $@",
+)
+EOF
+
+  cat > a/file.txt <<'EOF'
+content a
+EOF
+
+  cat > b/BUILD <<'EOF'
+genrule(
+    name = "rule_b",
+    srcs = ["//a:files"],
+    outs = ["output_b.txt"],
+    cmd = "cp $< $@",
+)
+EOF
+}
+
+function test_build_with_query_deps() {
+  bazel build --query="//a:rule_a" >& "$TEST_log" || fail "Build with query failed"
+  expect_log "//a:rule_a"
+  [ -f "bazel-bin/a/output_a.txt" ] || fail "Output a/output_a.txt was not built"
+}
+
+function test_build_with_query_multiple() {
+  bazel build --query="//a:rule_a + //b:rule_b" >& "$TEST_log" || fail "Build with query failed"
+  [ -f "bazel-bin/a/output_a.txt" ] || fail "Output a/output_a.txt was not built"
+  [ -f "bazel-bin/b/output_b.txt" ] || fail "Output b/output_b.txt was not built"
+}
+
+function test_build_with_query_pattern() {
+  bazel build --query="//a:*" >& "$TEST_log" || fail "Build with pattern query failed"
+  [ -f "bazel-bin/a/output_a.txt" ] || fail "Output a/output_a.txt was not built"
+}
+
+function test_build_with_query_file() {
+  echo '//b:rule_b' > query.txt
+
+  bazel build --query_file=query.txt >& "$TEST_log" || fail "Build with query_file failed"
+  expect_log "//b:rule_b"
+  [ -f "bazel-bin/b/output_b.txt" ] || fail "Output b/output_b.txt was not built"
+}
+
+function test_build_with_empty_query_result() {
+  bazel build --query="//nonexistent:target" >& "$TEST_log" && fail "Should have failed with nonexistent target"
+  expect_log "Error executing query"
+}
+
+run_suite "build --query tests"
