[c++] port ARRAY_CONTAINS_ANY and IN queries

Googler · a-maurice · commit 8978ba52b674 · 2020-02-24T18:26:21.000-08:00
waiting on cl/292025113 to go in first to allow tests to pass

TESTED=
linux: http://sponge2/ce3c91a9-a3f9-42d5-b76f-daff37935288
iOS: http://sponge2/45798482-0370-41a4-8470-655dd07eb8fe
Android: http://sponge2/aed789cf-a62b-403e-9b50-65201d69719b
PiperOrigin-RevId: 292227077
diff --git a/firestore/src/android/query_android.cc b/firestore/src/android/query_android.cc
@@ -106,6 +106,36 @@ Query QueryInternal::Where(const FieldPath& field, query::Method method,
   return Query{internal};
 }
 
+Query QueryInternal::Where(const FieldPath& field, query::Method method,
+                           const std::vector<FieldValue>& values) {
+  JNIEnv* env = firestore_->app()->GetJNIEnv();
+
+  // Convert std::vector into java.util.List object.
+  // TODO(chenbrian): Refactor this into a helper function.
+  jobject converted_values = env->NewObject(
+      util::array_list::GetClass(),
+      util::array_list::GetMethodId(util::array_list::kConstructor));
+  jmethodID add_method = util::array_list::GetMethodId(util::array_list::kAdd);
+  jsize size = static_cast<jsize>(values.size());
+  for (jsize i = 0; i < size; ++i) {
+    // ArrayList.Add() always returns true, which we have no use for.
+    env->CallBooleanMethod(converted_values, add_method,
+                           values[i].internal_->java_object());
+    CheckAndClearJniExceptions(env);
+  }
+
+  jobject path = FieldPathConverter::ToJavaObject(env, field);
+  jobject query = env->CallObjectMethod(obj_, query::GetMethodId(method), path,
+                                        converted_values);
+  CheckAndClearJniExceptions(env);
+  QueryInternal* internal = new QueryInternal{firestore_, query};
+  env->DeleteLocalRef(path);
+  env->DeleteLocalRef(query);
+  env->DeleteLocalRef(converted_values);
+
+  return Query{internal};
+}
+
 Query QueryInternal::WithBound(query::Method method,
                                const DocumentSnapshot& snapshot) {
   JNIEnv* env = firestore_->app()->GetJNIEnv();
diff --git a/firestore/src/android/query_android.h b/firestore/src/android/query_android.h
@@ -50,11 +50,17 @@ enum class QueryFn {
   X(ArrayContains, "whereArrayContains",                            \
     "(Lcom/google/firebase/firestore/FieldPath;Ljava/lang/Object;)" \
     "Lcom/google/firebase/firestore/Query;"),                       \
+  X(ArrayContainsAny, "whereArrayContainsAny",                      \
+    "(Lcom/google/firebase/firestore/FieldPath;Ljava/util/List;)"   \
+    "Lcom/google/firebase/firestore/Query;"),                       \
+  X(In, "whereIn",                                                  \
+    "(Lcom/google/firebase/firestore/FieldPath;Ljava/util/List;)"   \
+    "Lcom/google/firebase/firestore/Query;"),                       \
   X(OrderBy, "orderBy",                                             \
     "(Lcom/google/firebase/firestore/FieldPath;"                    \
     "Lcom/google/firebase/firestore/Query$Direction;)"              \
     "Lcom/google/firebase/firestore/Query;"),                       \
-  X(Limit, "limit", "(J)Lcom/google/firebase/firestore/Query;"),  \
+  X(Limit, "limit", "(J)Lcom/google/firebase/firestore/Query;"),    \
   X(StartAtSnapshot, "startAt",                                     \
     "(Lcom/google/firebase/firestore/DocumentSnapshot;)"            \
     "Lcom/google/firebase/firestore/Query;"),                       \
@@ -171,7 +177,7 @@ class QueryInternal : public WrapperFuture<QueryFn, QueryFn::kCount> {
    * documents must contain the specified field, the value must be an array, and
    * that the array must contain the provided value.
    *
-   * A Query can have only one WhereArrayContains() filter.
+   * A Query can have only one `WhereArrayContains()` filter.
    *
    * @param[in] field The path of the field containing an array to search
    * @param[in] value The value that must be contained in the array
@@ -182,6 +188,41 @@ class QueryInternal : public WrapperFuture<QueryFn, QueryFn::kCount> {
     return Where(field, query::kArrayContains, value);
   }
 
+  /**
+   * @brief Creates and returns a new Query with the additional filter that
+   * documents must contain the specified field, the value must be an array, and
+   * that the array must contain at least one value from the provided list.
+   *
+   * A Query can have only one `WhereArrayContainsAny()` filter and it cannot be
+   * combined with `WhereArrayContains()` or `WhereIn()`.
+   *
+   * @param[in] field The path of the field containing an array to search.
+   * @param[in] values The list that contains the values to match.
+   *
+   * @return The created Query.
+   */
+  Query WhereArrayContainsAny(const FieldPath& field,
+                              const std::vector<FieldValue>& values) {
+    return Where(field, query::kArrayContainsAny, values);
+  }
+
+  /**
+   * @brief Creates and returns a new Query with the additional filter that
+   * documents must contain the specified field and the value must equal one of
+   * the values from the provided list.
+   *
+   * A Query can have only one `WhereIn()` filter and it cannot be
+   * combined with `WhereArrayContainsAny()`.
+   *
+   * @param[in] field The path of the field containing an array to search.
+   * @param[in] values The list that contains the values to match.
+   *
+   * @return The created Query.
+   */
+  Query WhereIn(const FieldPath& field, const std::vector<FieldValue>& values) {
+    return Where(field, query::kIn, values);
+  }
+
   /**
    * @brief Creates and returns a new Query that's additionally sorted by the
    * specified field.
@@ -387,6 +428,8 @@ class QueryInternal : public WrapperFuture<QueryFn, QueryFn::kCount> {
   // A generalized function for all WhereFoo calls.
   Query Where(const FieldPath& field, query::Method method,
               const FieldValue& value);
+  Query Where(const FieldPath& field, query::Method method,
+              const std::vector<FieldValue>& values);
 
   // A generalized function for all {Start|End}{Before|After|At} calls.
   Query WithBound(query::Method method, const DocumentSnapshot& snapshot);
diff --git a/firestore/src/common/query.cc b/firestore/src/common/query.cc
@@ -155,6 +155,29 @@ Query Query::WhereArrayContains(const FieldPath& field,
   return internal_->WhereArrayContains(field, value);
 }
 
+Query Query::WhereArrayContainsAny(const std::string& field,
+                                   const std::vector<FieldValue>& values) {
+  return WhereArrayContainsAny(FieldPath::FromDotSeparatedString(field),
+                               values);
+}
+
+Query Query::WhereArrayContainsAny(const FieldPath& field,
+                                   const std::vector<FieldValue>& values) {
+  if (!internal_) return {};
+  return internal_->WhereArrayContainsAny(field, values);
+}
+
+Query Query::WhereIn(const std::string& field,
+                     const std::vector<FieldValue>& values) {
+  return WhereIn(FieldPath::FromDotSeparatedString(field), values);
+}
+
+Query Query::WhereIn(const FieldPath& field,
+                     const std::vector<FieldValue>& values) {
+  if (!internal_) return {};
+  return internal_->WhereIn(field, values);
+}
+
 Query Query::OrderBy(const std::string& field, Direction direction) {
   return OrderBy(FieldPath::FromDotSeparatedString(field), direction);
 }
diff --git a/firestore/src/include/firebase/firestore/query.h b/firestore/src/include/firebase/firestore/query.h
@@ -275,7 +275,8 @@ class Query {
    * documents must contain the specified field, the value must be an array, and
    * that the array must contain the provided value.
    *
-   * A Query can have only one WhereArrayContains() filter.
+   * A Query can have only one `WhereArrayContains()` filter and it cannot be
+   * combined with `WhereArrayContainsAny()` or `WhereIn()`.
    *
    * @param[in] field The name of the field containing an array to search.
    * @param[in] value The value that must be contained in the array.
@@ -290,7 +291,8 @@ class Query {
    * documents must contain the specified field, the value must be an array, and
    * that the array must contain the provided value.
    *
-   * A Query can have only one WhereArrayContains() filter.
+   * A Query can have only one `WhereArrayContains()` filter and it cannot be
+   * combined with `WhereArrayContainsAny()` or `WhereIn()`.
    *
    * @param[in] field The path of the field containing an array to search.
    * @param[in] value The value that must be contained in the array.
@@ -300,6 +302,70 @@ class Query {
   virtual Query WhereArrayContains(const FieldPath& field,
                                    const FieldValue& value);
 
+  /**
+   * @brief Creates and returns a new Query with the additional filter that
+   * documents must contain the specified field, the value must be an array, and
+   * that the array must contain at least one value from the provided list.
+   *
+   * A Query can have only one `WhereArrayContainsAny()` filter and it cannot be
+   * combined with `WhereArrayContains()` or `WhereIn()`.
+   *
+   * @param[in] field The name of the field containing an array to search.
+   * @param[in] values The list that contains the values to match.
+   *
+   * @return The created Query.
+   */
+  virtual Query WhereArrayContainsAny(const std::string& field,
+                                      const std::vector<FieldValue>& values);
+
+  /**
+   * @brief Creates and returns a new Query with the additional filter that
+   * documents must contain the specified field, the value must be an array, and
+   * that the array must contain at least one value from the provided list.
+   *
+   * A Query can have only one `WhereArrayContainsAny()` filter and it cannot be
+   * combined with` WhereArrayContains()` or `WhereIn()`.
+   *
+   * @param[in] field The path of the field containing an array to search.
+   * @param[in] values The list that contains the values to match.
+   *
+   * @return The created Query.
+   */
+  virtual Query WhereArrayContainsAny(const FieldPath& field,
+                                      const std::vector<FieldValue>& values);
+
+  /**
+   * @brief Creates and returns a new Query with the additional filter that
+   * documents must contain the specified field and the value must equal one of
+   * the values from the provided list.
+   *
+   * A Query can have only one `WhereIn()` filter and it cannot be
+   * combined with `WhereArrayContainsAny()`.
+   *
+   * @param[in] field The name of the field containing an array to search.
+   * @param[in] values The list that contains the values to match.
+   *
+   * @return The created Query.
+   */
+  virtual Query WhereIn(const std::string& field,
+                        const std::vector<FieldValue>& values);
+
+  /**
+   * @brief Creates and returns a new Query with the additional filter that
+   * documents must contain the specified field and the value must equal one of
+   * the values from the provided list.
+   *
+   * A Query can have only one `WhereIn()` filter and it cannot be
+   * combined with `WhereArrayContainsAny()`.
+   *
+   * @param[in] field The path of the field containing an array to search.
+   * @param[in] values The list that contains the values to match.
+   *
+   * @return The created Query.
+   */
+  virtual Query WhereIn(const FieldPath& field,
+                        const std::vector<FieldValue>& values);
+
   /**
    * @brief Creates and returns a new Query that's additionally sorted by the
    * specified field.
diff --git a/firestore/src/ios/query_ios.cc b/firestore/src/ios/query_ios.cc
@@ -74,6 +74,18 @@ Query QueryInternal::Where(const FieldPath& field_path, Operator op,
   return MakePublic(std::move(decorated));
 }
 
+Query QueryInternal::Where(const FieldPath& field_path, Operator op,
+                           const std::vector<FieldValue>& values) const {
+  const model::FieldPath& path = GetInternal(field_path);
+  auto array_value = FieldValue::FromArray(values);
+  model::FieldValue parsed =
+      user_data_converter_.ParseQueryValue(array_value, true);
+  auto describer = [&array_value] { return Describe(array_value.type()); };
+
+  api::Query decorated = query_.Filter(path, op, std::move(parsed), describer);
+  return MakePublic(std::move(decorated));
+}
+
 Query QueryInternal::WithBound(BoundPosition bound_pos,
                                const DocumentSnapshot& snapshot) const {
   core::Bound bound = ToBound(bound_pos, snapshot);
diff --git a/firestore/src/ios/query_ios.h b/firestore/src/ios/query_ios.h
@@ -69,6 +69,15 @@ class QueryInternal {
     return Where(field, Operator::ArrayContains, value);
   }
 
+  Query WhereArrayContainsAny(const FieldPath& field,
+                              const std::vector<FieldValue>& values) {
+    return Where(field, Operator::ArrayContainsAny, values);
+  }
+
+  Query WhereIn(const FieldPath& field, const std::vector<FieldValue>& values) {
+    return Where(field, Operator::In, values);
+  }
+
   Query StartAt(const DocumentSnapshot& snapshot) {
     return WithBound(BoundPosition::kStartAt, snapshot);
   }
@@ -140,6 +149,8 @@ class QueryInternal {
 
   Query Where(const FieldPath& field, Operator op,
               const FieldValue& value) const;
+  Query Where(const FieldPath& field, Operator op,
+              const std::vector<FieldValue>& values) const;
 
   Query WithBound(BoundPosition bound_pos,
                   const DocumentSnapshot& snapshot) const;
diff --git a/firestore/src/ios/user_data_converter_ios.cc b/firestore/src/ios/user_data_converter_ios.cc
@@ -220,9 +220,10 @@ ParsedSetData UserDataConverter::ParseMergeData(
                  CreateFieldMask(accumulator, maybe_field_mask.value()));
 }
 
-model::FieldValue UserDataConverter::ParseQueryValue(
-    const FieldValue& input) const {
-  ParseAccumulator accumulator{UserDataSource::Argument};
+model::FieldValue UserDataConverter::ParseQueryValue(const FieldValue& input,
+                                                     bool allow_arrays) const {
+  ParseAccumulator accumulator{allow_arrays ? UserDataSource::ArrayArgument
+                                           : UserDataSource::Argument};
 
   absl::optional<model::FieldValue> parsed =
       ParseData(input, accumulator.RootContext());
@@ -266,7 +267,12 @@ absl::optional<model::FieldValue> UserDataConverter::ParseData(
 
 model::FieldValue::Array UserDataConverter::ParseArray(
     const std::vector<FieldValue>& input, ParseContext&& context) const {
-  if (context.array_element()) {
+  // In the case of IN queries, the parsed data is an array (representing the
+  // set of values to be included for the IN query) that may directly contain
+  // additional arrays (each representing an individual field value), so we
+  // disable this validation.
+  if (context.array_element() &&
+      context.data_source() != core::UserDataSource::ArrayArgument) {
     ThrowInvalidArgument("Nested arrays are not supported");
   }
 
diff --git a/firestore/src/ios/user_data_converter_ios.h b/firestore/src/ios/user_data_converter_ios.h
@@ -47,7 +47,8 @@ class UserDataConverter {
    * Parse a "query value" (e.g. value in a where filter or a value in a cursor
    * bound).
    */
-  model::FieldValue ParseQueryValue(const FieldValue& input) const;
+  model::FieldValue ParseQueryValue(const FieldValue& input,
+                                    bool allow_arrays = false) const;
 
  private:
   using UpdateDataInput =
