Add compatibility with Cache Index Auto Creation

Author: cherylEnkidu

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

@@ -73,7 +73,7 @@ enum IndexType {
    * <p>Values for this index are persisted asynchronously. The index will only be used for query
    * execution once values are persisted.
    */
-  void addFieldIndex(FieldIndex index);
+  void addFieldIndex(@Nullable FieldIndex index);
 
   /** Removes the given field index and deletes all index values. */
   void deleteFieldIndex(FieldIndex index);

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

@@ -51,7 +51,7 @@ public List<ResourcePath> getCollectionParents(String collectionId) {
   }
 
   @Override
-  public void addFieldIndex(FieldIndex index) {
+  public void addFieldIndex(@Nullable FieldIndex index) {
     // Field indices are not supported with memory persistence.
   }
 

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

@@ -201,9 +201,11 @@ public List<ResourcePath> getCollectionParents(String collectionId) {
   }
 
   @Override
-  public void addFieldIndex(FieldIndex index) {
+  public void addFieldIndex(@Nullable FieldIndex index) {
     hardAssert(started, "IndexManager not started");
 
+    if (index == null) return;
+
     int nextIndexId = memoizedMaxIndexId + 1;
     index =
         FieldIndex.create(

firebase-firestore/src/main/java/com/google/firebase/firestore/model/TargetIndexMatcher.java

@@ -115,6 +115,10 @@ public TargetIndexMatcher(Target target) {
     }
   }
 
+  public boolean hasMultipleInequality() {
+    return inequalityFilters.size() > 1;
+  }
+
   /**
    * Returns whether the index can be used to serve the TargetIndexMatcher's target.
    *
@@ -139,6 +143,11 @@ public TargetIndexMatcher(Target target) {
   public boolean servedByIndex(FieldIndex index) {
     hardAssert(index.getCollectionGroup().equals(collectionId), "Collection IDs do not match");
 
+    if (hasMultipleInequality()) {
+      // Only single inequality is supported for now.
+      return false;
+    }
+
     // If there is an array element, find a matching filter.
     FieldIndex.Segment arraySegment = index.getArraySegment();
     if (arraySegment != null && !hasMatchingEqualityFilter(arraySegment)) {
@@ -171,11 +180,6 @@ public boolean servedByIndex(FieldIndex index) {
     }
 
     if (inequalityFilters.size() > 0) {
-      if (this.inequalityFilters.size() > 1) {
-        // Only single inequality is supported for now.
-        return false;
-      }
-
       // Only a single inequality is currently supported. Get the only entry in the set.
       FieldFilter inequalityFilter = this.inequalityFilters.first();
 
@@ -204,7 +208,12 @@ public boolean servedByIndex(FieldIndex index) {
   }
 
   /** Returns a full matched field index for this target. */
+  @Nullable
   public FieldIndex buildTargetIndex() {
+    if (hasMultipleInequality()) {
+      return null;
+    }
+
     // We want to make sure only one segment created for one field. For example, in case like
     // a == 3 and a > 2, Index: {a ASCENDING} will only be created once.
     Set<FieldPath> uniqueFields = new HashSet<>();

firebase-firestore/src/test/java/com/google/firebase/firestore/local/SQLiteLocalStoreTest.java

@@ -712,4 +712,34 @@ public void testIndexAutoCreationWorksWithMutation() {
     assertOverlaysRead(/* byKey= */ 1, /* byCollection= */ 1);
     assertQueryReturned("coll/a", "coll/f");
   }
+
+  @Test
+  public void testIndexAutoCreationDoesnotWorkWithMultipleInequality() {
+    Query query = query("coll").filter(filter("field1", "<", 5)).filter(filter("field2", "<", 5));
+    int targetId = allocateQuery(query);
+
+    setIndexAutoCreationEnabled(true);
+    setMinCollectionSizeToAutoCreateIndex(0);
+    setRelativeIndexReadCostPerDocument(2);
+
+    applyRemoteEvent(addedRemoteEvent(doc("coll/a", 10, map("field1", 1, "field2", 2)), targetId));
+    applyRemoteEvent(addedRemoteEvent(doc("coll/b", 10, map("field1", 8, "field2", 2)), targetId));
+    applyRemoteEvent(
+        addedRemoteEvent(doc("coll/c", 10, map("field1", "string", "field2", 2)), targetId));
+    applyRemoteEvent(addedRemoteEvent(doc("coll/d", 10, map("field1", 2)), targetId));
+    applyRemoteEvent(addedRemoteEvent(doc("coll/e", 10, map("field1", 4, "field2", 4)), targetId));
+
+    // First time query is running without indexes.
+    // Based on current heuristic, collection document counts (5) > 2 * resultSize (2).
+    // Full matched index will not be created since FieldIndex does not support multiple inequality.
+    executeQuery(query);
+    assertRemoteDocumentsRead(/* byKey= */ 0, /* byCollection= */ 2);
+    assertQueryReturned("coll/a", "coll/e");
+
+    backfillIndexes();
+
+    executeQuery(query);
+    assertRemoteDocumentsRead(/* byKey= */ 0, /* byCollection= */ 2);
+    assertQueryReturned("coll/a", "coll/e");
+  }
 }