Add ordering to Index implementation

Author: schmidt-sebastian

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

@@ -24,18 +24,25 @@
 public class OrderBy {
   /** The direction of the ordering */
   public enum Direction {
-    ASCENDING(1),
-    DESCENDING(-1);
+    ASCENDING(1, "asc"),
+    DESCENDING(-1, "desc");
 
     private final int comparisonModifier;
+    private final String shorthand;
 
-    Direction(int comparisonModifier) {
+    Direction(int comparisonModifier, String canonicalString) {
       this.comparisonModifier = comparisonModifier;
+      this.shorthand = canonicalString;
     }
 
     int getComparisonModifier() {
       return comparisonModifier;
     }
+
+    /** Returns "asc" for ascending or "desc" for descending. */
+    public String canonicalString() {
+      return shorthand;
+    }
   }
 
   public static OrderBy getInstance(Direction direction, FieldPath path) {

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

@@ -16,16 +16,16 @@
 
 import static com.google.firebase.firestore.model.Values.max;
 import static com.google.firebase.firestore.model.Values.min;
+import static com.google.firebase.firestore.util.Assert.fail;
 
 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.ArrayValue;
 import com.google.firestore.v1.Value;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
 /**
@@ -115,6 +115,27 @@ public boolean hasLimit() {
     return endAt;
   }
 
+  /** Returns the list of values that are used in ARRAY_CONTAINS and ARRAY_CONTAINS_ANY filter. */
+  public List<Value> getArrayValues(FieldIndex fieldIndex) {
+    for (FieldIndex.Segment segment : fieldIndex.getArraySegments()) {
+      for (Filter filter : filters) {
+        if (filter.getField().equals(segment.getFieldPath())) {
+          FieldFilter fieldFilter = (FieldFilter) filter;
+          switch (fieldFilter.getOperator()) {
+            case ARRAY_CONTAINS_ANY:
+              return fieldFilter.getValue().getArrayValue().getValuesList();
+            case ARRAY_CONTAINS:
+              return Collections.singletonList(fieldFilter.getValue());
+            default:
+              fail("Unexpected operator: " + fieldFilter.getOperator());
+          }
+        }
+      }
+    }
+
+    return Collections.emptyList();
+  }
+
   /**
    * Returns a lower bound of field values that can be used as a starting point to scan the index
    * defined by {@code fieldIndex}.
@@ -127,7 +148,7 @@ public Bound getLowerBound(FieldIndex fieldIndex) {
     boolean inclusive = true;
 
     // Go through all filters to find a value for the current field segment
-    for (FieldIndex.Segment segment : fieldIndex) {
+    for (FieldIndex.Segment segment : fieldIndex.getDirectionalSegments()) {
       Value segmentValue = Values.NULL_VALUE;
       boolean segmentInclusive = true;
 
@@ -143,25 +164,19 @@ public Bound getLowerBound(FieldIndex fieldIndex) {
               filterValue = Values.getLowerBound(fieldFilter.getValue().getValueTypeCase());
               break;
             case NOT_EQUAL:
-              filterValue = Values.NULL_VALUE;
-              break;
             case NOT_IN:
-              filterValue =
-                  Value.newBuilder()
-                      .setArrayValue(ArrayValue.newBuilder().addValues(Values.NULL_VALUE))
-                      .build();
               break;
             case EQUAL:
             case IN:
-            case ARRAY_CONTAINS_ANY:
-            case ARRAY_CONTAINS:
             case GREATER_THAN_OR_EQUAL:
               filterValue = fieldFilter.getValue();
               break;
             case GREATER_THAN:
               filterValue = fieldFilter.getValue();
               filterInclusive = false;
               break;
+            default:
+              fail("Unexpected operator: " + fieldFilter.getOperator());
           }
 
           if (max(segmentValue, filterValue) == filterValue) {
@@ -206,7 +221,7 @@ public Bound getLowerBound(FieldIndex fieldIndex) {
     List<Value> values = new ArrayList<>();
     boolean inclusive = true;
 
-    for (FieldIndex.Segment segment : fieldIndex) {
+    for (FieldIndex.Segment segment : fieldIndex.getDirectionalSegments()) {
       @Nullable Value segmentValue = null;
       boolean segmentInclusive = true;
 
@@ -229,15 +244,15 @@ public Bound getLowerBound(FieldIndex fieldIndex) {
               break;
             case EQUAL:
             case IN:
-            case ARRAY_CONTAINS_ANY:
-            case ARRAY_CONTAINS:
             case LESS_THAN_OR_EQUAL:
               filterValue = fieldFilter.getValue();
               break;
             case LESS_THAN:
               filterValue = fieldFilter.getValue();
               filterInclusive = false;
               break;
+            default:
+              fail("Unexpected operator: " + fieldFilter.getOperator());
           }
 
           if (min(segmentValue, filterValue) == filterValue) {
@@ -283,6 +298,11 @@ public List<OrderBy> getOrderBy() {
     return this.orderBys;
   }
 
+  /** Returns the first order by (which always exists). */
+  public OrderBy getFirstOrderBy() {
+    return this.orderBys.get(0);
+  }
+
   /** Returns a canonical string representing this target. */
   public String getCanonicalId() {
     if (memoizedCannonicalId != null) {
@@ -307,7 +327,7 @@ public String getCanonicalId() {
     builder.append("|ob:");
     for (OrderBy orderBy : getOrderBy()) {
       builder.append(orderBy.getField().canonicalString());
-      builder.append(orderBy.getDirection().equals(Direction.ASCENDING) ? "asc" : "desc");
+      builder.append(orderBy.getDirection().canonicalString());
     }
 
     // Add limit.

firebase-firestore/src/main/java/com/google/firebase/firestore/index/IndexEntry.java

@@ -21,13 +21,16 @@
 // TODO(indexing)
 public class IndexEntry {
   private final int indexId;
-  private final byte[] indexValue;
+  private final byte[] arrayValue;
+  private final byte[] directionalValue;
   private final String uid;
   private final String documentName;
 
-  public IndexEntry(int indexId, byte[] indexValue, String uid, String documentName) {
+  public IndexEntry(
+      int indexId, byte[] arrayValue, byte[] directionalValue, String uid, String documentName) {
     this.indexId = indexId;
-    this.indexValue = indexValue;
+    this.arrayValue = arrayValue;
+    this.directionalValue = directionalValue;
     this.uid = uid;
     this.documentName = documentName;
   }
@@ -36,8 +39,12 @@ public int getIndexId() {
     return indexId;
   }
 
-  public byte[] getIndexValue() {
-    return indexValue;
+  public byte[] getArrayValue() {
+    return arrayValue;
+  }
+
+  public byte[] getDirectionalValue() {
+    return directionalValue;
   }
 
   public String getUid() {

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

@@ -115,11 +115,13 @@ void addIndexEntry(IndexEntry entry) {
     persistence.execute(
         "INSERT OR IGNORE INTO index_entries ("
             + "index_id, "
-            + "index_value, "
+            + "array_index, "
+            + "directional_index, "
             + "uid, "
             + "document_name) VALUES(?, ?, ?, ?)",
         entry.getIndexId(),
-        entry.getIndexValue(),
+        entry.getArrayValue(),
+        entry.getDirectionalValue(),
         entry.getUid(),
         entry.getDocumentName());
   }
@@ -141,12 +143,18 @@ void removeIndexEntry(int indexId, String uid, String documentName) {
   @VisibleForTesting
   IndexEntry getIndexEntry(int indexId) {
     return persistence
-        .query("SELECT index_value, uid, document_name FROM index_entries WHERE index_id = ?")
+        .query(
+            "SELECT array_index, directional_index, uid, document_name FROM index_entries WHERE index_id = ?")
         .binding(indexId)
         .firstValue(
             row ->
                 row == null
                     ? null
-                    : new IndexEntry(indexId, row.getBlob(0), row.getString(1), row.getString(2)));
+                    : new IndexEntry(
+                        indexId,
+                        row.getBlob(0),
+                        row.getBlob(1),
+                        row.getString(2),
+                        row.getString(3)));
   }
 }