Reuse existing code for finding least recent index offset.

Author: ehsannas

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

@@ -26,7 +26,6 @@
 import com.google.firebase.firestore.util.Logger;
 import java.util.Collection;
 import java.util.HashSet;
-import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.TimeUnit;
@@ -133,7 +132,8 @@ private int writeEntriesForCollectionGroup(
       String collectionGroup, int documentsRemainingUnderCap) {
     // Use the earliest offset of all field indexes to query the local cache.
     Collection<FieldIndex> fieldIndexes = indexManager.getFieldIndexes(collectionGroup);
-    IndexOffset existingOffset = getExistingOffset(fieldIndexes);
+    hardAssert(!fieldIndexes.isEmpty(), "Updating collection without indexes");
+    IndexOffset existingOffset = indexManager.getLeastRecentIndexOffset(fieldIndexes);
 
     LocalDocumentsResult nextBatch =
         localDocumentsView.getNextDocuments(
@@ -161,24 +161,6 @@ private IndexOffset getNewOffset(IndexOffset existingOffset, LocalDocumentsResul
         Math.max(lookupResult.getBatchId(), existingOffset.getLargestBatchId()));
   }
 
-  /** Returns the lowest offset for the provided index group. */
-  private IndexOffset getExistingOffset(Collection<FieldIndex> fieldIndexes) {
-    hardAssert(!fieldIndexes.isEmpty(), "Updating collection without indexes");
-
-    Iterator<FieldIndex> it = fieldIndexes.iterator();
-    IndexOffset minOffset = it.next().getIndexState().getOffset();
-    int minBatchId = minOffset.getLargestBatchId();
-    while (it.hasNext()) {
-      IndexOffset newOffset = it.next().getIndexState().getOffset();
-      if (newOffset.compareTo(minOffset) < 0) {
-        minOffset = newOffset;
-      }
-      minBatchId = Math.max(newOffset.getLargestBatchId(), minBatchId);
-    }
-
-    return IndexOffset.create(minOffset.getReadTime(), minOffset.getDocumentKey(), minBatchId);
-  }
-
   @VisibleForTesting
   void setMaxDocumentsToProcess(int newMax) {
     maxDocumentsToProcess = newMax;

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

@@ -79,10 +79,13 @@ public interface IndexManager {
 
   /**
    * Iterates over all field indexes that are used to serve the given target, and returns the least
-   * recent offset of them all.
+   * recent offset of them all. Asserts that the target can be served from index.
    */
   FieldIndex.IndexOffset getLeastRecentIndexOffset(Target target);
 
+  /** Returns the lowest offset for the provided index group. */
+  FieldIndex.IndexOffset getLeastRecentIndexOffset(Collection<FieldIndex> fieldIndexes);
+
   /**
    * Returns an index that can be used to serve the provided target. Returns {@code null} if no
    * index is configured.

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

@@ -23,6 +23,7 @@
 import com.google.firebase.firestore.core.Target;
 import com.google.firebase.firestore.model.Document;
 import com.google.firebase.firestore.model.DocumentKey;
+import com.google.firebase.firestore.model.FieldIndex;
 import com.google.firebase.firestore.model.FieldIndex.IndexOffset;
 import com.google.firebase.firestore.model.SnapshotVersion;
 import com.google.firebase.firestore.util.Logger;

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

@@ -296,22 +296,37 @@ public boolean canServeFromIndex(Target target) {
     return true;
   }
 
-  // TODO(orquery): This looks awfully like `getExistingOffset` in IndexBackfillter. Refactor.
+  @Override
+  public FieldIndex.IndexOffset getLeastRecentIndexOffset(Collection<FieldIndex> fieldIndexes) {
+    hardAssert(
+        !fieldIndexes.isEmpty(),
+        "Found empty index group when looking for least recent index offset.");
+
+    Iterator<FieldIndex> it = fieldIndexes.iterator();
+    FieldIndex.IndexOffset minOffset = it.next().getIndexState().getOffset();
+    int minBatchId = minOffset.getLargestBatchId();
+    while (it.hasNext()) {
+      FieldIndex.IndexOffset newOffset = it.next().getIndexState().getOffset();
+      if (newOffset.compareTo(minOffset) < 0) {
+        minOffset = newOffset;
+      }
+      minBatchId = Math.max(newOffset.getLargestBatchId(), minBatchId);
+    }
+
+    return FieldIndex.IndexOffset.create(
+        minOffset.getReadTime(), minOffset.getDocumentKey(), minBatchId);
+  }
+
   @Override
   public FieldIndex.IndexOffset getLeastRecentIndexOffset(Target target) {
-    FieldIndex.IndexOffset min = null;
+    hardAssert(
+        canServeFromIndex(target),
+        "Cannot find least recent index offset if target cannot be served from index.");
+    List<FieldIndex> fieldIndexes = new ArrayList<>();
     for (Target subTarget : getSubTargets(target)) {
-      FieldIndex index = getFieldIndex(subTarget);
-      if (index == null) {
-        // If any of this target's sub-queries does not have a field index, return NONE.
-        return FieldIndex.IndexOffset.NONE;
-      }
-      FieldIndex.IndexOffset candidate = index.getIndexState().getOffset();
-      if (min == null || candidate.compareTo(min) < 0) {
-        min = candidate;
-      }
+      fieldIndexes.add(getFieldIndex(subTarget));
     }
-    return min == null ? FieldIndex.IndexOffset.NONE : min;
+    return getLeastRecentIndexOffset(fieldIndexes);
   }
 
   private List<Target> getSubTargets(Target target) {

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

@@ -527,7 +527,7 @@ private void verifyQueryResults(Query query, String... expectedKeys) {
     if (indexManager.canServeFromIndex(target)) {
       Set<DocumentKey> actualKeys = indexManager.getDocumentsMatchingTarget(target);
       assertThat(actualKeys)
-              .containsExactlyElementsIn(Arrays.stream(expectedKeys).map(TestUtil::key).toArray());
+          .containsExactlyElementsIn(Arrays.stream(expectedKeys).map(TestUtil::key).toArray());
     } else {
       assertEquals(0, expectedKeys.length);
     }