CSI compatibility

Author: cherylEnkidu

packages/firestore/src/local/indexeddb_index_manager.ts

@@ -275,10 +275,10 @@ export class IndexedDbIndexManager implements IndexManager {
         return this.getIndexType(transaction, subTarget).next(type => {
           if (type === IndexType.NONE || type === IndexType.PARTIAL) {
             const targetIndexMatcher = new TargetIndexMatcher(subTarget);
-            return this.addFieldIndex(
-              transaction,
-              targetIndexMatcher.buildTargetIndex()
-            );
+            const fieldIndex = targetIndexMatcher.buildTargetIndex();
+            if (fieldIndex != null) {
+              return this.addFieldIndex(transaction, fieldIndex);
+            }
           }
         });
       }

packages/firestore/src/model/target_index_matcher.ts

@@ -83,6 +83,10 @@ export class TargetIndexMatcher {
     }
   }
 
+  hasMultipleInequality(): boolean {
+    return this.inequalityFilters.size > 1;
+  }
+
   /**
    * Returns whether the index can be used to serve the TargetIndexMatcher's
    * target.
@@ -110,6 +114,11 @@ export class TargetIndexMatcher {
       'Collection IDs do not match'
     );
 
+    if (this.hasMultipleInequality()) {
+      // Only single inequality is supported for now.
+      return false;
+    }
+
     // If there is an array element, find a matching filter.
     const arraySegment = fieldIndexGetArraySegment(index);
     if (
@@ -148,11 +157,6 @@ export class TargetIndexMatcher {
     }
 
     if (this.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.
       const inequalityFilter = this.inequalityFilters.getIterator().getNext();
       // If there is an inequality filter and the field was not in one of the
@@ -187,8 +191,15 @@ export class TargetIndexMatcher {
     return true;
   }
 
-  /** Returns a full matched field index for this target. */
-  buildTargetIndex(): FieldIndex {
+  /**
+   * Returns a full matched field index for this target. Currently multiple
+   * inequality query is not supported so function returns null.
+   */
+  buildTargetIndex(): FieldIndex | null {
+    if (this.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.

packages/firestore/test/unit/local/local_store.test.ts

@@ -3098,4 +3098,57 @@ function indexedDbLocalStoreTests(
       .toReturnChanged('coll/a')
       .finish();
   });
+
+  it('index auto creation does not work with multiple inequality', () => {
+    const query_ = query(
+      'coll',
+      filter('field1', '<', 5),
+      filter('field2', '<', 5)
+    );
+    return (
+      expectLocalStore()
+        .afterAllocatingQuery(query_)
+        .toReturnTargetId(2)
+        .afterIndexAutoCreationConfigure({
+          isEnabled: true,
+          indexAutoCreationMinCollectionSize: 0,
+          relativeIndexReadCostPerDocument: 2
+        })
+        .afterRemoteEvents([
+          docAddedRemoteEvent(
+            doc('coll/a', 10, { field1: 1, field2: 2 }),
+            [2],
+            []
+          ),
+          docAddedRemoteEvent(
+            doc('coll/b', 10, { field1: 8, field2: 2 }),
+            [2],
+            []
+          ),
+          docAddedRemoteEvent(
+            doc('coll/c', 10, { field1: 'string', field2: 2 }),
+            [2],
+            []
+          ),
+          docAddedRemoteEvent(doc('coll/d', 10, { field1: 1 }), [2], []),
+          docAddedRemoteEvent(
+            doc('coll/e', 10, { field1: 4, field2: 4 }),
+            [2],
+            []
+          )
+        ])
+        // First time query runs 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.
+        .afterExecutingQuery(query_)
+        .toHaveRead({ documentsByKey: 0, documentsByCollection: 2 })
+        .toReturnChanged('coll/a', 'coll/e')
+        .afterBackfillIndexes()
+        .afterExecutingQuery(query_)
+        .toHaveRead({ documentsByKey: 0, documentsByCollection: 2 })
+        .toReturnChanged('coll/a', 'coll/e')
+        .finish()
+    );
+  });
 }

packages/firestore/test/unit/model/target_index_matcher.test.ts

@@ -25,7 +25,7 @@ import {
   newQueryForCollectionGroup
 } from '../../../src/core/query';
 import { targetGetSegmentCount } from '../../../src/core/target';
-import { IndexKind } from '../../../src/model/field_index';
+import { FieldIndex, IndexKind } from '../../../src/model/field_index';
 import { TargetIndexMatcher } from '../../../src/model/target_index_matcher';
 import { fieldIndex, filter, orderBy, query } from '../../util/helpers';
 
@@ -956,12 +956,32 @@ describe('Target Bounds', () => {
         ));
     });
 
+    describe('query with multiple inequality', () => {
+      it('returns null', () => {
+        const q = queryWithAddedFilter(
+          queryWithAddedFilter(query('collId'), filter('a', '>=', 1)),
+          filter('b', '<=', 10)
+        );
+        const target = queryToTarget(q);
+        const targetIndexMatcher = new TargetIndexMatcher(target);
+        expect(targetIndexMatcher.hasMultipleInequality()).is.true;
+        const expectedIndex = targetIndexMatcher.buildTargetIndex();
+        expect(expectedIndex).is.null;
+      });
+    });
+
     function validateBuildTargetIndexCreateFullMatchIndex(q: Query): void {
       const target = queryToTarget(q);
       const targetIndexMatcher = new TargetIndexMatcher(target);
+      expect(targetIndexMatcher.hasMultipleInequality()).is.false;
       const expectedIndex = targetIndexMatcher.buildTargetIndex();
-      expect(targetIndexMatcher.servedByIndex(expectedIndex)).is.true;
-      expect(expectedIndex.fields.length >= targetGetSegmentCount(target));
+      expect(expectedIndex).is.not.null;
+      expect(targetIndexMatcher.servedByIndex(expectedIndex as FieldIndex)).is
+        .true;
+      expect(
+        (expectedIndex as FieldIndex).fields.length >=
+          targetGetSegmentCount(target)
+      );
     }
   });