ParameterizedQuery.and(), or()

Author: fluentfuture

mug-bigquery/src/main/java/com/google/mu/bigquery/ParameterizedQuery.java

@@ -2,6 +2,8 @@
 
 import static java.util.Collections.emptyMap;
 import static java.util.Objects.requireNonNull;
+import static java.util.stream.Collectors.collectingAndThen;
+import static java.util.stream.Collectors.mapping;
 
 import java.math.BigDecimal;
 import java.time.Instant;
@@ -16,7 +18,10 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
+import java.util.function.BiConsumer;
+import java.util.function.Predicate;
 import java.util.stream.Collector;
+import java.util.stream.Collector.Characteristics;
 import java.util.stream.Stream;
 
 import com.google.cloud.bigquery.BigQuery.JobOption;
@@ -117,6 +122,16 @@ private ParameterizedQuery(
    */
   public static ParameterizedQuery EMPTY = of("");
 
+  /**
+   * Returns a query using a compile-time constant query with no parameters.
+   *
+   * @since 8.2
+   */
+  @TemplateFormatMethod
+  public static ParameterizedQuery of(@CompileTimeConstant @TemplateString String query) {
+    return new ParameterizedQuery(query, emptyMap(), emptyMap());
+  }
+
   /**
    * Convenience method when you need to create the {@link ParameterizedQuery} inline, with both the
    * query template and the arguments.
@@ -225,6 +240,36 @@ public static Stream<ParameterizedQuery> enumConstants(Class<? extends Enum<?>>
         .map(e -> new ParameterizedQuery(e.name(), emptyMap(), emptyMap()));
   }
 
+  /**
+   * A collector that joins boolean query snippets using {@code AND} operator. The
+   * AND'ed sub-queries will be enclosed in pairs of parenthesis to avoid
+   * ambiguity. If the input is empty, the result will be "TRUE".
+   *
+   * <p>Empty ParameterizedQuery elements are ignored and not joined.
+   *
+   * @since 8.2
+   */
+  public static Collector<ParameterizedQuery, ?, ParameterizedQuery> and() {
+    return collectingAndThen(
+        nonEmptyQueries(mapping(ParameterizedQuery::parenthesized, joining(" AND "))),
+        query -> query.query.isEmpty() ? of("TRUE") : query);
+  }
+
+  /**
+   * A collector that joins boolean query snippets using {@code OR} operator. The
+   * OR'ed sub-queries will be enclosed in pairs of parenthesis to avoid
+   * ambiguity. If the input is empty, the result will be "FALSE".
+   *
+   * <p>Empty ParameterizedQuery elements are ignored and not joined.
+   *
+   * @since 8.2
+   */
+  public static Collector<ParameterizedQuery, ?, ParameterizedQuery> or() {
+    return collectingAndThen(
+        nonEmptyQueries(mapping(ParameterizedQuery::parenthesized, joining(" OR "))),
+        query -> query.query.isEmpty() ? of("FALSE") : query);
+  }
+
   /**
    * Returns a collector that joins ParameterizedQuery elements using {@code delimiter}.
    *
@@ -391,4 +436,25 @@ public boolean equals(Object obj) {
   public String toString() {
     return query;
   }
+
+  private ParameterizedQuery parenthesized() {
+    return new ParameterizedQuery("(" + query + ")", emptyMap(), emptyMap());
+  }
+
+  private static <R> Collector<ParameterizedQuery, ?, R> nonEmptyQueries(
+      Collector<ParameterizedQuery, ?, R> downstream) {
+    return filtering(q -> !q.query.isEmpty(), downstream);
+  }
+
+  // Not in Java 8
+  private static <T, A, R> Collector<T, A, R> filtering(
+      Predicate<? super T> filter, Collector<? super T, A, R> collector) {
+    BiConsumer<A, ? super T> accumulator = collector.accumulator();
+    return Collector.of(
+        collector.supplier(),
+        (a, input) -> {if (filter.test(input)) {accumulator.accept(a, input);}},
+        collector.combiner(),
+        collector.finisher(),
+        collector.characteristics().toArray(new Characteristics[0]));
+  }
 }

mug-bigquery/src/test/java/com/google/mu/bigquery/ParameterizedQueryTest.java

@@ -18,6 +18,7 @@
 
 import com.google.cloud.bigquery.QueryJobConfiguration;
 import com.google.cloud.bigquery.QueryParameterValue;
+import com.google.common.collect.ImmutableList;
 import com.google.common.testing.EqualsTester;
 import com.google.mu.util.StringFormat.Template;
 
@@ -274,6 +275,80 @@ public void testJoining_parallel() {
     assertThat(query).isEqualTo(ParameterizedQuery.of("{v1}, {v2}, {v3}", 1, "2", 3));
   }
 
+  @Test
+  public void andCollector_empty() {
+    ImmutableList<ParameterizedQuery> queries = ImmutableList.of();
+    assertThat(queries.stream().collect(ParameterizedQuery.and())).isEqualTo(ParameterizedQuery.of("TRUE"));
+  }
+
+  @Test
+  public void andCollector_singleCondition() {
+    ImmutableList<ParameterizedQuery> queries = ImmutableList.of(ParameterizedQuery.of("a = 1"));
+    assertThat(queries.stream().collect(ParameterizedQuery.and())).isEqualTo(ParameterizedQuery.of("(a = 1)"));
+  }
+
+  @Test
+  public void andCollector_twoConditions() {
+    ImmutableList<ParameterizedQuery> queries =
+        ImmutableList.of(ParameterizedQuery.of("a = 1"), ParameterizedQuery.of("b = 2 OR c = 3"));
+    assertThat(queries.stream().collect(ParameterizedQuery.and()))
+        .isEqualTo(ParameterizedQuery.of("(a = 1) AND (b = 2 OR c = 3)"));
+  }
+
+  @Test
+  public void andCollector_threeConditions() {
+    ImmutableList<ParameterizedQuery> queries =
+        ImmutableList.of(
+            ParameterizedQuery.of("a = 1"), ParameterizedQuery.of("b = 2 OR c = 3"), ParameterizedQuery.of("d = 4"));
+    assertThat(queries.stream().collect(ParameterizedQuery.and()))
+        .isEqualTo(ParameterizedQuery.of("(a = 1) AND (b = 2 OR c = 3) AND (d = 4)"));
+  }
+
+  @Test
+  public void andCollector_ignoresEmpty() {
+    ImmutableList<ParameterizedQuery> queries =
+        ImmutableList.of(ParameterizedQuery.EMPTY, ParameterizedQuery.of("b = 2 OR c = 3"), ParameterizedQuery.of("d = 4"));
+    assertThat(queries.stream().collect(ParameterizedQuery.and()))
+        .isEqualTo(ParameterizedQuery.of("(b = 2 OR c = 3) AND (d = 4)"));
+  }
+
+  @Test
+  public void orCollector_empty() {
+    ImmutableList<ParameterizedQuery> queries = ImmutableList.of();
+    assertThat(queries.stream().collect(ParameterizedQuery.or())).isEqualTo(ParameterizedQuery.of("FALSE"));
+  }
+
+  @Test
+  public void orCollector_singleCondition() {
+    ImmutableList<ParameterizedQuery> queries = ImmutableList.of(ParameterizedQuery.of("a = 1"));
+    assertThat(queries.stream().collect(ParameterizedQuery.or())).isEqualTo(ParameterizedQuery.of("(a = 1)"));
+  }
+
+  @Test
+  public void orCollector_twoConditions() {
+    ImmutableList<ParameterizedQuery> queries =
+        ImmutableList.of(ParameterizedQuery.of("a = 1"), ParameterizedQuery.of("b = 2 AND c = 3"));
+    assertThat(queries.stream().collect(ParameterizedQuery.or()))
+        .isEqualTo(ParameterizedQuery.of("(a = 1) OR (b = 2 AND c = 3)"));
+  }
+
+  @Test
+  public void orCollector_threeConditions() {
+    ImmutableList<ParameterizedQuery> queries =
+        ImmutableList.of(
+            ParameterizedQuery.of("a = 1"), ParameterizedQuery.of("b = 2 AND c = 3"), ParameterizedQuery.of("d = 4"));
+    assertThat(queries.stream().collect(ParameterizedQuery.or()))
+        .isEqualTo(ParameterizedQuery.of("(a = 1) OR (b = 2 AND c = 3) OR (d = 4)"));
+  }
+
+  @Test
+  public void orCollector_ignoresEmpty() {
+    ImmutableList<ParameterizedQuery> queries =
+        ImmutableList.of(ParameterizedQuery.EMPTY, ParameterizedQuery.of("b = 2 AND c = 3"), ParameterizedQuery.of("d = 4"));
+    assertThat(queries.stream().collect(ParameterizedQuery.or()))
+        .isEqualTo(ParameterizedQuery.of("(b = 2 AND c = 3) OR (d = 4)"));
+  }
+
   @Test
   public void testEquals() {
     new EqualsTester()