Merge branch 'tomandersen/pipelines' into tomandersen/pipelines-evaluate

# Conflicts:
#	firebase-firestore/api.txt
#	firebase-firestore/src/main/java/com/google/firebase/firestore/Pipeline.kt
#	firebase-firestore/src/main/java/com/google/firebase/firestore/model/Values.kt
#	firebase-firestore/src/main/java/com/google/firebase/firestore/pipeline/expressions.kt
#	firebase-firestore/src/main/java/com/google/firebase/firestore/pipeline/stage.kt

Author: tom-andersen

firebase-firestore/api.txt

@@ -47,7 +47,7 @@
 import com.google.firebase.firestore.pipeline.AggregateFunction;
 import com.google.firebase.firestore.pipeline.AggregateStage;
 import com.google.firebase.firestore.pipeline.Expr;
-import com.google.firebase.firestore.pipeline.GenericStage;
+import com.google.firebase.firestore.pipeline.Stage;
 import com.google.firebase.firestore.testutil.IntegrationTestUtil;
 import java.util.Collections;
 import java.util.LinkedHashMap;
@@ -279,15 +279,15 @@ public void groupAndAccumulateResultsGeneric() {
         firestore
             .pipeline()
             .collection(randomCol)
-            .genericStage(GenericStage.ofName("where").withArguments(lt(field("published"), 1984)))
-            .genericStage(
-                GenericStage.ofName("aggregate")
+            .addStage(Stage.ofName("where").withArguments(lt(field("published"), 1984)))
+            .addStage(
+                Stage.ofName("aggregate")
                     .withArguments(
                         ImmutableMap.of("avgRating", AggregateFunction.avg("rating")),
                         ImmutableMap.of("genre", field("genre"))))
-            .genericStage(GenericStage.ofName("where").withArguments(gt("avgRating", 4.3)))
-            .genericStage(
-                GenericStage.ofName("sort").withArguments(field("avgRating").descending()))
+            .addStage(Stage.ofName("where").withArguments(gt("avgRating", 4.3)))
+            .addStage(
+                Stage.ofName("sort").withArguments(field("avgRating").descending()))
             .execute();
     assertThat(waitFor(execute).getResults())
         .comparingElementsUsing(DATA_CORRESPONDENCE)

firebase-firestore/src/androidTest/java/com/google/firebase/firestore/PipelineTest.java

@@ -356,7 +356,7 @@ public void testQueriesCanUseNotEqualFilters() {
     expectedDocsMap.remove("i");
     expectedDocsMap.remove("j");
     snapshot =
-        waitFor(db.pipeline().convertFrom(collection.whereEqualTo("zip", Double.NaN)).execute());
+        waitFor(db.pipeline().convertFrom(collection.whereNotEqualTo("zip", Double.NaN)).execute());
     assertEquals(Lists.newArrayList(expectedDocsMap.values()), pipelineSnapshotToValues(snapshot));
   }
 
@@ -613,53 +613,41 @@ public void testQueriesCanUseArrayContainsAnyFilters() {
     FirebaseFirestore db = collection.firestore;
 
     // Search for "array" to contain [42, 43].
-    PipelineSnapshot snapshot =
-        waitFor(
-            db.pipeline()
-                .convertFrom(collection.whereArrayContainsAny("array", asList(42L, 43L)))
-                .execute());
+    Pipeline pipeline = db.pipeline()
+        .convertFrom(collection.whereArrayContainsAny("array", asList(42L, 43L)));
+    PipelineSnapshot snapshot = waitFor(pipeline.execute());
     assertEquals(asList(docA, docB, docD, docE), pipelineSnapshotToValues(snapshot));
 
     // With objects.
-    snapshot =
-        waitFor(
-            db.pipeline()
-                .convertFrom(collection.whereArrayContainsAny("array", asList(map("a", 42L))))
-                .execute());
+    pipeline = db.pipeline()
+        .convertFrom(collection.whereArrayContainsAny("array", asList(map("a", 42L))));
+    snapshot = waitFor(pipeline.execute());
     assertEquals(asList(docF), pipelineSnapshotToValues(snapshot));
 
     // With null.
-    snapshot =
-        waitFor(
-            db.pipeline()
-                .convertFrom(collection.whereArrayContainsAny("array", nullList()))
-                .execute());
+    pipeline = db.pipeline()
+        .convertFrom(collection.whereArrayContainsAny("array", nullList()));
+    snapshot = waitFor(pipeline.execute());
     assertEquals(new ArrayList<>(), pipelineSnapshotToValues(snapshot));
 
     // With null and a value.
     List<Object> inputList = nullList();
     inputList.add(43L);
-    snapshot =
-        waitFor(
-            db.pipeline()
-                .convertFrom(collection.whereArrayContainsAny("array", inputList))
-                .execute());
+    pipeline = db.pipeline()
+        .convertFrom(collection.whereArrayContainsAny("array", inputList));
+    snapshot = waitFor(pipeline.execute());
     assertEquals(asList(docE), pipelineSnapshotToValues(snapshot));
 
     // With NaN.
-    snapshot =
-        waitFor(
-            db.pipeline()
-                .convertFrom(collection.whereArrayContainsAny("array", asList(Double.NaN)))
-                .execute());
+    pipeline = db.pipeline()
+        .convertFrom(collection.whereArrayContainsAny("array", asList(Double.NaN)));
+    snapshot = waitFor(pipeline.execute());
     assertEquals(new ArrayList<>(), pipelineSnapshotToValues(snapshot));
 
     // With NaN and a value.
-    snapshot =
-        waitFor(
-            db.pipeline()
-                .convertFrom(collection.whereArrayContainsAny("array", asList(Double.NaN, 43L)))
-                .execute());
+    pipeline = db.pipeline()
+        .convertFrom(collection.whereArrayContainsAny("array", asList(Double.NaN, 43L)));
+    snapshot = waitFor(pipeline.execute());
     assertEquals(asList(docE), pipelineSnapshotToValues(snapshot));
   }
 

firebase-firestore/src/androidTest/java/com/google/firebase/firestore/QueryToPipelineTest.java

@@ -567,9 +567,18 @@ public static void checkOnlineAndOfflineResultsMatch(Query query, String... expe
    * @param expectedDocs Ordered list of document keys that are expected to match the query
    */
   public static void checkQueryAndPipelineResultsMatch(Query query, String... expectedDocs) {
-    QuerySnapshot docsFromQuery = waitFor(query.get(Source.SERVER));
-    PipelineSnapshot docsFromPipeline =
-        waitFor(query.getFirestore().pipeline().convertFrom(query).execute());
+    QuerySnapshot docsFromQuery;
+    try {
+      docsFromQuery = waitFor(query.get(Source.SERVER));
+    } catch (Exception e) {
+      throw new RuntimeException("Classic Query FAILED", e);
+    }
+    PipelineSnapshot docsFromPipeline;
+    try {
+        docsFromPipeline = waitFor(query.getFirestore().pipeline().convertFrom(query).execute());
+    } catch (Exception e) {
+      throw new RuntimeException("Pipeline FAILED", e);
+    }
 
     assertEquals(querySnapshotToIds(docsFromQuery), pipelineSnapshotToIds(docsFromPipeline));
     List<String> expected = asList(expectedDocs);

firebase-firestore/src/androidTest/java/com/google/firebase/firestore/testutil/IntegrationTestUtil.java

@@ -37,8 +37,8 @@ import com.google.firebase.firestore.pipeline.ExprWithAlias
 import com.google.firebase.firestore.pipeline.Field
 import com.google.firebase.firestore.pipeline.FindNearestStage
 import com.google.firebase.firestore.pipeline.FunctionExpr
-import com.google.firebase.firestore.pipeline.GenericStage
 import com.google.firebase.firestore.pipeline.InternalOptions
+import com.google.firebase.firestore.pipeline.Stage
 import com.google.firebase.firestore.pipeline.LimitStage
 import com.google.firebase.firestore.pipeline.OffsetStage
 import com.google.firebase.firestore.pipeline.Ordering
@@ -50,7 +50,7 @@ import com.google.firebase.firestore.pipeline.SampleStage
 import com.google.firebase.firestore.pipeline.SelectStage
 import com.google.firebase.firestore.pipeline.Selectable
 import com.google.firebase.firestore.pipeline.SortStage
-import com.google.firebase.firestore.pipeline.Stage
+import com.google.firebase.firestore.pipeline.BaseStage
 import com.google.firebase.firestore.pipeline.UnionStage
 import com.google.firebase.firestore.pipeline.UnnestStage
 import com.google.firebase.firestore.pipeline.WhereStage
@@ -62,7 +62,7 @@ open class AbstractPipeline
 internal constructor(
   internal val firestore: FirebaseFirestore,
   internal val userDataReader: UserDataReader,
-  internal val stages: FluentIterable<Stage<*>>
+  internal val stages: FluentIterable<BaseStage<*>>
 ) {
   private fun toStructuredPipelineProto(options: InternalOptions?): StructuredPipeline {
     val builder = StructuredPipeline.newBuilder()
@@ -136,10 +136,10 @@ private constructor(
   internal constructor(
     firestore: FirebaseFirestore,
     userDataReader: UserDataReader,
-    stage: Stage<*>
+    stage: BaseStage<*>
   ) : this(firestore, userDataReader, FluentIterable.of(stage))
 
-  private fun append(stage: Stage<*>): Pipeline {
+  private fun append(stage: BaseStage<*>): Pipeline {
     return Pipeline(firestore, userDataReader, stages.append(stage))
   }
 
@@ -159,10 +159,10 @@ private constructor(
    * This method provides a way to call stages that are supported by the Firestore backend but that
    * are not implemented in the SDK version being used.
    *
-   * @param stage An [GenericStage] object that specifies stage name and parameters.
+   * @param stage An [Stage] object that specifies stage name and parameters.
    * @return A new [Pipeline] object with this stage appended to the stage list.
    */
-  fun genericStage(stage: GenericStage): Pipeline = append(stage)
+  fun addStage(stage: Stage): Pipeline = append(stage)
 
   /**
    * Adds new fields to outputs from previous stages.

firebase-firestore/src/main/java/com/google/firebase/firestore/Pipeline.kt

@@ -14,17 +14,23 @@
 
 package com.google.firebase.firestore.core;
 
+import static com.google.firebase.firestore.model.Values.isNanValue;
 import static com.google.firebase.firestore.pipeline.Expr.and;
+import static com.google.firebase.firestore.pipeline.Expr.ifError;
 import static com.google.firebase.firestore.util.Assert.hardAssert;
-import static java.lang.Double.isNaN;
+
+import androidx.annotation.NonNull;
 
 import com.google.firebase.firestore.model.Document;
 import com.google.firebase.firestore.model.FieldPath;
 import com.google.firebase.firestore.model.Values;
 import com.google.firebase.firestore.pipeline.BooleanExpr;
+import com.google.firebase.firestore.pipeline.Expr;
 import com.google.firebase.firestore.pipeline.Field;
 import com.google.firebase.firestore.util.Assert;
 import com.google.firestore.v1.Value;
+
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
@@ -188,16 +194,18 @@ BooleanExpr toPipelineExpr() {
       case EQUAL:
         if (value.hasNullValue()) {
           return and(exists, x.isNull());
-        } else if (value.hasDoubleValue() && isNaN(value.getDoubleValue())) {
-          return and(exists, x.isNan());
+        } else if (isNanValue(value)) {
+          // The isNan will error on non-numeric values.
+          return and(exists, ifError(x.isNan(), Expr.constant(false)));
         } else {
           return and(exists, x.eq(value));
         }
       case NOT_EQUAL:
         if (value.hasNullValue()) {
           return and(exists, x.isNotNull());
-        } else if (value.hasDoubleValue() && isNaN(value.getDoubleValue())) {
-          return and(exists, x.isNotNan());
+        } else if (isNanValue(value)) {
+          // The isNotNan will error on non-numeric values.
+          return and(exists, ifError(x.isNotNan(), Expr.constant(true)));
         } else {
           return and(exists, x.neq(value));
         }
@@ -211,14 +219,39 @@ BooleanExpr toPipelineExpr() {
         return and(exists, x.arrayContainsAny(value.getArrayValue().getValuesList()));
       case IN:
         return and(exists, x.eqAny(value.getArrayValue().getValuesList()));
-      case NOT_IN:
-        return and(exists, x.notEqAny(value.getArrayValue().getValuesList()));
+      case NOT_IN: {
+        List<Value> list = value.getArrayValue().getValuesList();
+        if (hasNaN(list)) {
+          return and(exists, x.notEqAny(filterNaN(list)), ifError(x.isNotNan(), Expr.constant(true)));
+        } else {
+          return and(exists, x.notEqAny(list));
+        }
+      }
       default:
         // Handle OPERATOR_UNSPECIFIED and UNRECOGNIZED cases as needed
         throw new IllegalArgumentException("Unsupported operator: " + operator);
     }
   }
 
+  private static boolean hasNaN(List<Value> list) {
+    for (Value v : list) {
+      if (isNanValue(v)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  @NonNull
+  private static List<Value> filterNaN(List<Value> list) {
+    List<Value> listWithoutNan = new ArrayList<>(list.size() - 1);
+    for (Value v : list) {
+      if (isNanValue(v)) continue;
+      listWithoutNan.add(v);
+    }
+    return listWithoutNan;
+  }
+
   @Override
   public String toString() {
     return getCanonicalId();

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

@@ -37,7 +37,10 @@
 import com.google.firebase.firestore.pipeline.FunctionExpr;
 import com.google.firebase.firestore.pipeline.InternalOptions;
 import com.google.firebase.firestore.pipeline.Ordering;
-import com.google.firebase.firestore.pipeline.Stage;
+import com.google.firebase.firestore.pipeline.BaseStage;
+import com.google.firebase.firestore.util.BiFunction;
+import com.google.firebase.firestore.util.Function;
+import com.google.firebase.firestore.util.IntFunction;
 import com.google.firestore.v1.Value;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -46,7 +49,6 @@
 import java.util.List;
 import java.util.SortedSet;
 import java.util.TreeSet;
-import java.util.function.BiFunction;
 
 /**
  * Encapsulates all the query attributes we support in the SDK. It can be run against the
@@ -547,8 +549,7 @@ public Pipeline toPipeline(FirebaseFirestore firestore, UserDataReader userDataR
     if (fields.size() == 1) {
       p = p.where(fields.get(0).exists());
     } else {
-      BooleanExpr[] conditions =
-          fields.stream().skip(1).map(Expr.Companion::exists).toArray(BooleanExpr[]::new);
+      BooleanExpr[] conditions = skipFirstToArray(fields, BooleanExpr[]::new, Expr.Companion::exists);
       p = p.where(and(fields.get(0).exists(), conditions));
     }
 
@@ -564,23 +565,43 @@ public Pipeline toPipeline(FirebaseFirestore firestore, UserDataReader userDataR
     if (hasLimit()) {
       // TODO: Handle situation where user enters limit larger than integer.
       if (limitType == LimitType.LIMIT_TO_FIRST) {
-        p = p.sort(orderings.get(0), orderings.stream().skip(1).toArray(Ordering[]::new));
+        p = p.sort(orderings.get(0), skipFirstToArray(orderings, Ordering[]::new));
         p = p.limit((int) limit);
       } else {
         p =
             p.sort(
                 orderings.get(0).reverse(),
-                orderings.stream().skip(1).map(Ordering::reverse).toArray(Ordering[]::new));
+                skipFirstToArray(orderings, Ordering[]::new, Ordering::reverse));
         p = p.limit((int) limit);
-        p = p.sort(orderings.get(0), orderings.stream().skip(1).toArray(Ordering[]::new));
+        p = p.sort(orderings.get(0), skipFirstToArray(orderings, Ordering[]::new));
       }
     } else {
-      p = p.sort(orderings.get(0), orderings.stream().skip(1).toArray(Ordering[]::new));
+      p = p.sort(orderings.get(0), skipFirstToArray(orderings, Ordering[]::new));
     }
 
     return p;
   }
 
+  // Many Pipelines require first parameter to be separated out from rest.
+  private static <T> T[] skipFirstToArray(List<T> list, IntFunction<T[]> generator) {
+    int size = list.size();
+    T[] result = generator.apply(size - 1);
+    for (int i = 1; i < size; i++) {
+      result[i-1] = list.get(i);
+    }
+    return result;
+  }
+
+  // Many Pipelines require first parameter to be separated out from rest.
+  private static <T, R> R[] skipFirstToArray(List<T> list, IntFunction<R[]> generator, Function<T, R> map) {
+    int size = list.size();
+    R[] result = generator.apply(size - 1);
+    for (int i = 1; i < size; i++) {
+      result[i-1] = map.apply(list.get(i));
+    }
+    return result;
+  }
+
   private static BooleanExpr whereConditionsFromCursor(
       Bound bound, List<Field> fields, BiFunction<Expr, Object, BooleanExpr> cmp) {
     List<Value> boundPosition = bound.getPosition();
@@ -600,7 +621,7 @@ private static BooleanExpr whereConditionsFromCursor(
   }
 
   @NonNull
-  private Stage<?> pipelineSource(FirebaseFirestore firestore) {
+  private BaseStage<?> pipelineSource(FirebaseFirestore firestore) {
     if (isDocumentQuery()) {
       return new DocumentsSource(path.canonicalString());
     } else if (isCollectionGroupQuery()) {

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

@@ -663,14 +663,14 @@ internal object Values {
     )
   }
 
-  @JvmStatic
-  fun encodeValue(value: Timestamp): Value = Value.newBuilder().setTimestampValue(value).build()
-
-  @JvmField val TRUE_VALUE: Value = Value.newBuilder().setBooleanValue(true).build()
+  @JvmField
+  val TRUE: Value = Value.newBuilder().setBooleanValue(true).build()
 
-  @JvmField val FALSE_VALUE: Value = Value.newBuilder().setBooleanValue(false).build()
+  @JvmField
+  val FALSE: Value = Value.newBuilder().setBooleanValue(false).build()
 
-  @JvmStatic fun encodeValue(value: Boolean): Value = if (value) TRUE_VALUE else FALSE_VALUE
+  @JvmStatic
+  fun encodeValue(value: Boolean): Value = if (value) TRUE else FALSE
 
   @JvmStatic
   fun encodeValue(geoPoint: GeoPoint): Value =