Clean up.

Author: ehsannas

firebase-firestore/src/main/java/com/google/firebase/firestore/core/CompositeFilter.java

@@ -27,23 +27,10 @@
 public class CompositeFilter extends Filter {
   private final List<Filter> filters;
   private final Operator operator;
-  private boolean isFlatConjunction;
 
   public CompositeFilter(List<Filter> filters, Operator operator) {
     this.filters = filters;
     this.operator = operator;
-
-    // Memoize whether this is a flat conjunction filter.
-    isFlatConjunction = true;
-    if (operator != Operator.AND) {
-      isFlatConjunction = false;
-    } else {
-      for (Filter filter : filters) {
-        if (filter instanceof CompositeFilter) {
-          isFlatConjunction = false;
-        }
-      }
-    }
   }
 
   @Override
@@ -87,13 +74,6 @@ public boolean isDisjunction() {
     return operator == Operator.OPERATOR_UNSPECIFIED;
   }
 
-  /**
-   * Returns true if this filter is a conjunction of field filters only. Returns false otherwise.
-   */
-  public boolean isFlatConjunction() {
-    return isFlatConjunction;
-  }
-
   /**
    * Performs a depth-first search to find and return the first FieldFilter in the composite filter
    * that satisfies the condition. Returns {@code null} if none of the FieldFilters satisfy the

firebase-firestore/src/main/java/com/google/firebase/firestore/core/DnfTransform.java

@@ -0,0 +1,38 @@
+package com.google.firebase.firestore.core;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Provides utility functions that help with boolean logic transformations needed for handling
+ * complex filters used in queries.
+ */
+public class LogicUtils {
+  /**
+   * Given a composite filter, returns the list of terms in its disjunctive normal form.
+   *
+   * <p>Each element in the return value is one term of the resulting DNF.
+   *
+   * <p>For instance, for the input: (A || B) && C
+   *
+   * <p>The DNF form is: (A && C) || (B && C)
+   *
+   * <p>The return value is a list with two elements:
+   *
+   * <p>The first element is a composite filter that performs (A && C).
+   *
+   * <p>The second element is a composite filter that performs (B && C).
+   *
+   * @param filter the composite filter to calculate DNF transform for.
+   * @return the terms in the DNF transform.
+   */
+  public static List<Filter> DnfTransform(CompositeFilter filter) {
+    // TODO(orquery): write the DNF transform algorithm here.
+    // For now, assume all inputs are of the form AND(A, B, ...). Therefore the resulting DNF form
+    // is the same as the input.
+    if (filter.getFilters().isEmpty()) {
+      return Collections.emptyList();
+    }
+    return Collections.singletonList(filter);
+  }
+}

firebase-firestore/src/main/java/com/google/firebase/firestore/core/LogicUtils.java

@@ -21,16 +21,17 @@
 import static com.google.firebase.firestore.util.Util.repeatSequence;
 import static java.lang.Math.max;
 
+import android.text.TextUtils;
 import androidx.annotation.Nullable;
 import com.google.common.collect.ObjectArrays;
 import com.google.firebase.Timestamp;
 import com.google.firebase.database.collection.ImmutableSortedMap;
 import com.google.firebase.firestore.auth.User;
 import com.google.firebase.firestore.core.Bound;
 import com.google.firebase.firestore.core.CompositeFilter;
-import com.google.firebase.firestore.core.DnfTransform;
 import com.google.firebase.firestore.core.FieldFilter;
 import com.google.firebase.firestore.core.Filter;
+import com.google.firebase.firestore.core.LogicUtils;
 import com.google.firebase.firestore.core.Target;
 import com.google.firebase.firestore.index.DirectionalIndexByteEncoder;
 import com.google.firebase.firestore.index.FirestoreIndexValueWriter;
@@ -323,7 +324,7 @@ private List<Target> getSubTargets(Target target) {
     } else {
       // There is an implicit AND operation between all the filters stored in the target.
       List<Filter> dnf =
-          DnfTransform.get(
+          LogicUtils.DnfTransform(
               new CompositeFilter(
                   target.getFilters(), StructuredQuery.CompositeFilter.Operator.AND));
       for (Filter term : dnf) {
@@ -478,20 +479,16 @@ public Set<DocumentKey> getDocumentsMatchingTarget(Target target) {
       bindings.addAll(Arrays.asList(subQueryAndBindings).subList(1, subQueryAndBindings.length));
     }
 
-    // Construct "subQuery1 UNION subQuery2 UNION ... LIMIT N"
-    // If there's only one subQuery, just execute the one subQuery.
-    StringBuilder queryStatement = new StringBuilder();
-    for (int i = 0; i < subQueries.size(); ++i) {
-      if (i > 0) {
-        queryStatement.append(" UNION ");
-      }
-      queryStatement.append(subQueries.get(i));
-    }
-    if (subQueries.size() > 1) {
-      queryStatement.append("LIMIT ").append(target.getLimit());
-    }
+    String queryString =
+        subQueries.size() == 1
+            ?
+            // If there's only one subQuery, just execute the one subQuery.
+            subQueries.get(0)
+            :
+            // Construct "subQuery1 UNION subQuery2 UNION ... LIMIT N"
+            TextUtils.join(" UNION ", subQueries) + " LIMIT " + target.getLimit();
 
-    SQLitePersistence.Query query = db.query(queryStatement.toString()).binding(bindings.toArray());
+    SQLitePersistence.Query query = db.query(queryString).binding(bindings.toArray());
 
     Set<DocumentKey> result = new HashSet<>();
     query.forEach(

firebase-firestore/src/main/java/com/google/firebase/firestore/local/SQLiteIndexManager.java

@@ -31,7 +31,6 @@
 import static com.google.firebase.firestore.testutil.TestUtil.version;
 import static com.google.firebase.firestore.testutil.TestUtil.wrap;
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;