Add Index Bounds to Queries (#2926)

Author: schmidt-sebastian

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

@@ -17,7 +17,11 @@
 import androidx.annotation.Nullable;
 import com.google.firebase.firestore.core.OrderBy.Direction;
 import com.google.firebase.firestore.model.DocumentKey;
+import com.google.firebase.firestore.model.FieldIndex;
 import com.google.firebase.firestore.model.ResourcePath;
+import com.google.firebase.firestore.model.Values;
+import com.google.firestore.v1.Value;
+import java.util.ArrayList;
 import java.util.List;
 
 /**
@@ -31,7 +35,7 @@ public final class Target {
 
   private @Nullable String memoizedCannonicalId;
 
-  private final List<OrderBy> orderBy;
+  private final List<OrderBy> orderBys;
   private final List<Filter> filters;
 
   private final ResourcePath path;
@@ -55,13 +59,13 @@ public Target(
       ResourcePath path,
       @Nullable String collectionGroup,
       List<Filter> filters,
-      List<OrderBy> orderBy,
+      List<OrderBy> orderBys,
       long limit,
       @Nullable Bound startAt,
       @Nullable Bound endAt) {
     this.path = path;
     this.collectionGroup = collectionGroup;
-    this.orderBy = orderBy;
+    this.orderBys = orderBys;
     this.filters = filters;
     this.limit = limit;
     this.startAt = startAt;
@@ -107,8 +111,143 @@ public boolean hasLimit() {
     return endAt;
   }
 
+  /**
+   * Returns a lower bound of field values that can be used as a starting point to scan the index
+   * defined by {@code fieldIndex}.
+   *
+   * <p>Unlike {@link #getUpperBound}, lower bounds always exist as the SDK can use {@code null} as
+   * a starting point for missing boundary values.
+   */
+  public Bound getLowerBound(FieldIndex fieldIndex) {
+    List<Value> values = new ArrayList<>();
+    boolean before = true;
+
+    // Go through all filters to find a value for the current field segment
+    for (FieldIndex.Segment segment : fieldIndex) {
+      Value lowestValue = Values.NULL_VALUE;
+      for (Filter filter : filters) {
+        if (filter.getField().equals(segment.getFieldPath())) {
+          FieldFilter fieldFilter = (FieldFilter) filter;
+          switch (fieldFilter.getOperator()) {
+            case LESS_THAN:
+            case NOT_IN:
+            case NOT_EQUAL:
+            case LESS_THAN_OR_EQUAL:
+              // These filters cannot be used as a lower bound. Skip.
+              break;
+            case EQUAL:
+            case IN:
+            case ARRAY_CONTAINS_ANY:
+            case ARRAY_CONTAINS:
+            case GREATER_THAN_OR_EQUAL:
+              lowestValue = fieldFilter.getValue();
+              break;
+            case GREATER_THAN:
+              lowestValue = fieldFilter.getValue();
+              before = false;
+              break;
+          }
+        }
+      }
+
+      // If there is a startAt bound, compare the values against the existing boundary to see
+      // if we can narrow the scope.
+      if (startAt != null) {
+        for (int i = 0; i < orderBys.size(); ++i) {
+          OrderBy orderBy = this.orderBys.get(i);
+          if (orderBy.getField().equals(segment.getFieldPath())) {
+            Value cursorValue = startAt.getPosition().get(i);
+            if (Values.compare(lowestValue, cursorValue) <= 0) {
+              lowestValue = cursorValue;
+              // `before` is shared by all cursor values. If any cursor value is used, we set before
+              // to the cursor's value.
+              before = startAt.isBefore();
+            }
+            break;
+          }
+        }
+      }
+      values.add(lowestValue);
+    }
+
+    return new Bound(values, before);
+  }
+
+  /**
+   * Returns an upper bound of field values that can be used as an ending point when scanning the
+   * index defined by {@code fieldIndex}.
+   *
+   * <p>Unlike {@link #getLowerBound}, upper bounds do not always exist since the Firestore does not
+   * define a maximum field value. The index scan should not use an upper bound if {@code null} is
+   * returned.
+   */
+  public @Nullable Bound getUpperBound(FieldIndex fieldIndex) {
+    List<Value> values = new ArrayList<>();
+    boolean before = false;
+
+    for (FieldIndex.Segment segment : fieldIndex) {
+      @Nullable Value largestValue = null;
+
+      // Go through all filters to find a value for the current field segment
+      for (Filter filter : filters) {
+        if (filter.getField().equals(segment.getFieldPath())) {
+          FieldFilter fieldFilter = (FieldFilter) filter;
+          switch (fieldFilter.getOperator()) {
+            case GREATER_THAN:
+            case NOT_IN:
+            case NOT_EQUAL:
+            case GREATER_THAN_OR_EQUAL:
+              // These filters cannot be used as an upper bound. Skip.
+              break;
+            case EQUAL:
+            case IN:
+            case ARRAY_CONTAINS_ANY:
+            case ARRAY_CONTAINS:
+            case LESS_THAN_OR_EQUAL:
+              largestValue = fieldFilter.getValue();
+              before = true;
+              break;
+            case LESS_THAN:
+              largestValue = fieldFilter.getValue();
+              before = false;
+              break;
+          }
+        }
+      }
+
+      // If there is an endAt bound, compare the values against the existing boundary to see
+      // if we can narrow the scope.
+      if (endAt != null) {
+        for (int i = 0; i < orderBys.size(); ++i) {
+          OrderBy orderBy = this.orderBys.get(i);
+          if (orderBy.getField().equals(segment.getFieldPath())) {
+            Value cursorValue = endAt.getPosition().get(i);
+            if (largestValue == null || Values.compare(largestValue, cursorValue) > 0) {
+              largestValue = cursorValue;
+              before = endAt.isBefore();
+            }
+            break;
+          }
+        }
+      }
+
+      if (largestValue == null) {
+        // No upper bound exists
+        return null;
+      }
+
+      values.add(largestValue);
+    }
+
+    if (values.isEmpty()) {
+      return null;
+    }
+
+    return new Bound(values, before);
+  }
+
   public List<OrderBy> getOrderBy() {
-    return this.orderBy;
+    return this.orderBys;
   }
 
   /** Returns a canonical string representing this target. */
@@ -177,7 +316,7 @@ public boolean equals(Object o) {
     if (limit != target.limit) {
       return false;
     }
-    if (!orderBy.equals(target.orderBy)) {
+    if (!orderBys.equals(target.orderBys)) {
       return false;
     }
     if (!filters.equals(target.filters)) {
@@ -194,7 +333,7 @@ public boolean equals(Object o) {
 
   @Override
   public int hashCode() {
-    int result = orderBy.hashCode();
+    int result = orderBys.hashCode();
     result = 31 * result + (collectionGroup != null ? collectionGroup.hashCode() : 0);
     result = 31 * result + filters.hashCode();
     result = 31 * result + path.hashCode();
@@ -223,13 +362,13 @@ public String toString() {
       }
     }
 
-    if (!orderBy.isEmpty()) {
+    if (!orderBys.isEmpty()) {
       builder.append(" order by ");
-      for (int i = 0; i < orderBy.size(); i++) {
+      for (int i = 0; i < orderBys.size(); i++) {
         if (i > 0) {
           builder.append(", ");
         }
-        builder.append(orderBy.get(i));
+        builder.append(orderBys.get(i));
       }
     }