Implement and test realtime array functions

Author: tom-andersen

firebase-firestore/src/main/java/com/google/firebase/firestore/pipeline/evaluation.kt

@@ -243,15 +243,63 @@ internal val evaluateSubtract = arithmeticPrimitive(Math::subtractExact, Double:
 
 internal val evaluateArray = variadicNullableValueFunction(EvaluateResult.Companion::list)
 
-internal val evaluateEqAny = notImplemented
+internal val evaluateEqAny = binaryFunction { list: List<Value>, value: Value ->
+  eqAny(value, list)
+}
 
 internal val evaluateNotEqAny = notImplemented
 
-internal val evaluateArrayContains = notImplemented
+internal val evaluateArrayContains = binaryFunction { array: Value, value: Value ->
+  if (array.hasArrayValue()) eqAny(value, array.arrayValue.valuesList) else EvaluateResultError
+}
 
-internal val evaluateArrayContainsAny = notImplemented
+internal val evaluateArrayContainsAny =
+  binaryFunction { array: List<Value>, searchValues: List<Value> ->
+    var foundNull = false
+    for (value in array) for (search in searchValues) when (strictEquals(value, search)) {
+      true -> return@binaryFunction EvaluateResult.TRUE
+      false -> {}
+      null -> foundNull = true
+    }
+    return@binaryFunction if (foundNull) EvaluateResult.NULL else EvaluateResult.FALSE
+  }
 
-internal val evaluateArrayLength = notImplemented
+internal val evaluateArrayContainsAll =
+  binaryFunction { array: List<Value>, searchValues: List<Value> ->
+    var foundNullAtLeastOnce = false
+    for (search in searchValues) {
+      var found = false
+      var foundNull = false
+      for (value in array) when (strictEquals(value, search)) {
+        true -> {
+          found = true
+          break
+        }
+        false -> {}
+        null -> foundNull = true
+      }
+      if (foundNull) {
+        foundNullAtLeastOnce = true
+      } else if (!found) {
+        return@binaryFunction EvaluateResult.FALSE
+      }
+    }
+    return@binaryFunction if (foundNullAtLeastOnce) EvaluateResult.NULL else EvaluateResult.TRUE
+  }
+
+internal val evaluateArrayLength = unaryFunction { array: List<Value> ->
+  EvaluateResult.long(array.size)
+}
+
+private fun eqAny(value: Value, list: List<Value>): EvaluateResult {
+  var foundNull = false
+  for (element in list) when (strictEquals(value, element)) {
+    true -> return EvaluateResult.TRUE
+    false -> {}
+    null -> foundNull = true
+  }
+  return if (foundNull) EvaluateResult.NULL else EvaluateResult.FALSE
+}
 
 // === String Functions ===
 
@@ -490,6 +538,14 @@ private inline fun unaryFunction(crossinline timestampOp: (Timestamp) -> Evaluat
     timestampOp,
   )
 
+@JvmName("unaryArrayFunction")
+private inline fun unaryFunction(crossinline longOp: (List<Value>) -> EvaluateResult) =
+  unaryFunctionType(
+    Value.ValueTypeCase.ARRAY_VALUE,
+    { it.arrayValue.valuesList },
+    longOp,
+  )
+
 private inline fun unaryFunction(
   crossinline byteOp: (ByteString) -> EvaluateResult,
   crossinline stringOp: (String) -> EvaluateResult
@@ -559,6 +615,20 @@ private inline fun binaryFunction(
   }
 }
 
+@JvmName("binaryValueArrayFunction")
+private inline fun binaryFunction(
+  crossinline function: (Value, List<Value>) -> EvaluateResult
+): EvaluateFunction = binaryFunction { v1: Value, v2: Value ->
+  if (v2.hasArrayValue()) function(v1, v2.arrayValue.valuesList) else EvaluateResultError
+}
+
+@JvmName("binaryArrayValueFunction")
+private inline fun binaryFunction(
+  crossinline function: (List<Value>, Value) -> EvaluateResult
+): EvaluateFunction = binaryFunction { v1: Value, v2: Value ->
+  if (v1.hasArrayValue()) function(v1.arrayValue.valuesList, v2) else EvaluateResultError
+}
+
 @JvmName("binaryStringStringFunction")
 private inline fun binaryFunction(crossinline function: (String, String) -> EvaluateResult) =
   binaryFunctionType(
@@ -569,6 +639,18 @@ private inline fun binaryFunction(crossinline function: (String, String) -> Eval
     function
   )
 
+@JvmName("binaryArrayArrayFunction")
+private inline fun binaryFunction(
+  crossinline function: (List<Value>, List<Value>) -> EvaluateResult
+) =
+  binaryFunctionType(
+    Value.ValueTypeCase.ARRAY_VALUE,
+    { it.arrayValue.valuesList },
+    Value.ValueTypeCase.ARRAY_VALUE,
+    { it.arrayValue.valuesList },
+    function
+  )
+
 private inline fun ternaryTimestampFunction(
   crossinline function: (Timestamp, String, Long) -> EvaluateResult
 ): EvaluateFunction = ternaryNullableValueFunction { timestamp: Value, unit: Value, number: Value ->

firebase-firestore/src/main/java/com/google/firebase/firestore/pipeline/expressions.kt

@@ -2610,7 +2610,8 @@ abstract class Expr internal constructor() {
      * @return A new [Expr] representing the array function.
      */
     @JvmStatic
-    fun array(vararg elements: Expr): Expr = FunctionExpr("array", evaluateArray, elements)
+    fun array(vararg elements: Any?): Expr =
+      FunctionExpr("array", evaluateArray, elements.map(::toExprOrConstant).toTypedArray<Expr>())
 
     /**
      * Creates an expression that creates a Firestore array value from an input array.
@@ -2619,8 +2620,8 @@ abstract class Expr internal constructor() {
      * @return A new [Expr] representing the array function.
      */
     @JvmStatic
-    fun array(elements: List<Expr>): Expr =
-      FunctionExpr("array", evaluateArray, elements.toTypedArray())
+    fun array(elements: List<Any?>): Expr =
+      FunctionExpr("array", evaluateArray, elements.map(::toExprOrConstant).toTypedArray())
 
     /**
      * Creates an expression that concatenates an array with other arrays.
@@ -2753,7 +2754,7 @@ abstract class Expr internal constructor() {
      */
     @JvmStatic
     fun arrayContainsAll(array: Expr, arrayExpression: Expr) =
-      BooleanExpr("array_contains_all", notImplemented, array, arrayExpression)
+      BooleanExpr("array_contains_all", evaluateArrayContainsAll, array, arrayExpression)
 
     /**
      * Creates an expression that checks if array field contains all the specified [values].
@@ -2766,7 +2767,7 @@ abstract class Expr internal constructor() {
     fun arrayContainsAll(arrayFieldName: String, values: List<Any>) =
       BooleanExpr(
         "array_contains_all",
-        notImplemented,
+        evaluateArrayContainsAll,
         arrayFieldName,
         ListOfExprs(toArrayOfExprOrConstant(values))
       )
@@ -2780,7 +2781,7 @@ abstract class Expr internal constructor() {
      */
     @JvmStatic
     fun arrayContainsAll(arrayFieldName: String, arrayExpression: Expr) =
-      BooleanExpr("array_contains_all", notImplemented, arrayFieldName, arrayExpression)
+      BooleanExpr("array_contains_all", evaluateArrayContainsAll, arrayFieldName, arrayExpression)
 
     /**
      * Creates an expression that checks if [array] contains any of the specified [values].