WIP: in expansion.

Author: ehsannas

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

@@ -19,6 +19,10 @@
 import com.google.firebase.firestore.core.CompositeFilter;
 import com.google.firebase.firestore.core.FieldFilter;
 import com.google.firebase.firestore.core.Filter;
+import com.google.firebase.firestore.core.InFilter;
+import com.google.firestore.v1.ArrayValue;
+import com.google.firestore.v1.Value;
+
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
@@ -286,6 +290,37 @@ protected static Filter computeDistributedNormalForm(Filter filter) {
     return runningResult;
   }
 
+  /**
+   * The `in` filter is only a syntactic sugar over a disjunction of equalities. For instance:
+   * `a in [1,2,3]` is in fact `a==1 || a==2 || a==3`. This method expands any `in` filter in the
+   * given input into a disjunction of equality filters and returns the expanded filter.
+   */
+  protected static Filter computeInExpansion(Filter filter) {
+    assertFieldFilterOrCompositeFilter(filter);
+
+    List<Filter> expandedFilters = new ArrayList<>();
+
+    if(filter instanceof FieldFilter) {
+      if(filter instanceof InFilter) {
+        // We have reached a field filter with `in` operator.
+        for(Value value : ((InFilter) filter).getValue().getArrayValue().getValuesList()) {
+          expandedFilters.add(FieldFilter.create(((InFilter) filter).getField(), FieldFilter.Operator.EQUAL, value));
+        }
+        return new CompositeFilter(expandedFilters, CompositeFilter.Operator.OR);
+      } else {
+        // We have reached other kinds of field filters.
+        return filter;
+      }
+    }
+
+    // We have a composite filter.
+    CompositeFilter compositeFilter = (CompositeFilter) filter;
+    for(Filter subfilter : compositeFilter.getFilters()) {
+      expandedFilters.add(computeInExpansion(subfilter));
+    }
+    return new CompositeFilter(expandedFilters, compositeFilter.getOperator());
+  }
+
   /**
    * Given a composite filter, returns the list of terms in its disjunctive normal form.
    *

firebase-firestore/src/test/java/com/google/firebase/firestore/util/LogicUtilsTest.java

@@ -21,6 +21,7 @@
 import static com.google.firebase.firestore.util.LogicUtils.applyAssociation;
 import static com.google.firebase.firestore.util.LogicUtils.applyDistribution;
 import static com.google.firebase.firestore.util.LogicUtils.computeDistributedNormalForm;
+import static com.google.firebase.firestore.util.LogicUtils.computeInExpansion;
 import static com.google.firebase.firestore.util.LogicUtils.getDnfTerms;
 import static org.junit.Assert.assertEquals;
 
@@ -275,4 +276,39 @@ public void testComputeDnf8() {
     assertThat(computeDistributedNormalForm(compositeFilter)).isEqualTo(expectedResult);
     assertThat(getDnfTerms(compositeFilter)).isEqualTo(Arrays.asList(expectedDnfTerms));
   }
+
+  @Test
+  public void testInExpansionForFieldFilters() {
+    FieldFilter input1 = filter("a", "in", Arrays.asList(1, 2, 3));
+    FieldFilter input2 = filter("a", "<", 1);
+    FieldFilter input3 = filter("a", "<=", 1);
+    FieldFilter input4 = filter("a", "==", 1);
+    FieldFilter input5 = filter("a", "!=", 1);
+    FieldFilter input6 = filter("a", ">", 1);
+    FieldFilter input7 = filter("a", ">=", 1);
+    FieldFilter input8 = filter("a", "array-contains", 1);
+    FieldFilter input9 = filter("a", "array-contains-any", Arrays.asList(1,2));
+    FieldFilter input10 = filter("a", "not-in", Arrays.asList(1,2));
+
+    assertThat(computeInExpansion(input1)).isEqualTo(
+         orFilters(
+            filter("a", "==", 1),
+            filter("a", "==", 2),
+            filter("a", "==", 3)));
+
+    // Other operators should remain the same
+    assertThat(computeInExpansion(input2)).isEqualTo(input2);
+    assertThat(computeInExpansion(input3)).isEqualTo(input3);
+    assertThat(computeInExpansion(input4)).isEqualTo(input4);
+    assertThat(computeInExpansion(input5)).isEqualTo(input5);
+    assertThat(computeInExpansion(input6)).isEqualTo(input6);
+    assertThat(computeInExpansion(input7)).isEqualTo(input7);
+    assertThat(computeInExpansion(input8)).isEqualTo(input8);
+    assertThat(computeInExpansion(input9)).isEqualTo(input9);
+    assertThat(computeInExpansion(input10)).isEqualTo(input10);
+  }
+  @Test
+  public void testInExpansionForCompositeFilters() {
+    // TODO
+  }
 }