Realtime pipeline public preview

Firestore/core/src/api/expressions.h

@@ -43,7 +43,7 @@ class Expr {
 
 class Selectable : public Expr {
  public:
-  virtual ~Selectable() override = default;
+  ~Selectable() override = default;
   virtual const std::string& alias() const = 0;
 };
 

Firestore/core/src/api/pipeline_result.h

@@ -51,7 +51,7 @@ class PipelineResult {
 
   PipelineResult() = default;
 
-  PipelineResult(model::Document document)
+  explicit PipelineResult(model::Document document)
       : internal_key_{document->key()},
         value_{document->shared_data()},
         // TODO(pipeline): add create time support

Firestore/core/src/api/query_snapshot.cc

@@ -17,6 +17,7 @@
 #include "Firestore/core/src/api/query_snapshot.h"
 
 #include <utility>
+#include <vector>
 
 #include "Firestore/core/src/api/document_change.h"
 #include "Firestore/core/src/api/document_snapshot.h"

Firestore/core/src/api/query_snapshot.h

@@ -20,6 +20,7 @@
 #include <functional>
 #include <memory>
 #include <utility>
+#include <vector>
 
 #include "Firestore/core/src/api/api_fwd.h"
 #include "Firestore/core/src/api/document_change.h"

Firestore/core/src/api/realtime_pipeline_snapshot.h

@@ -68,4 +68,4 @@ class RealtimePipelineSnapshot {
 }  // namespace firestore
 }  // namespace firebase
 
-#endif  // FIRESTORE_CORE_SRC_API_REAL_TIME_PIPELINE_SNAPSHOT_H_
+#endif  // FIRESTORE_CORE_SRC_API_REALTIME_PIPELINE_SNAPSHOT_H_

Firestore/core/src/core/expressions_eval.cc

@@ -201,8 +201,8 @@ EvaluateResult EvaluateResult::NewValue(
 
 std::unique_ptr<EvaluableExpr> FunctionToEvaluable(
     const api::FunctionExpr& function) {
-  if (function.name() == "eq") {
-    return std::make_unique<CoreEq>(function);
+  if (function.name() == "equal") {
+    return std::make_unique<CoreEqual>(function);
   } else if (function.name() == "add") {
     return std::make_unique<CoreAdd>(function);
   } else if (function.name() == "subtract") {
@@ -213,16 +213,16 @@ std::unique_ptr<EvaluableExpr> FunctionToEvaluable(
     return std::make_unique<CoreDivide>(function);
   } else if (function.name() == "mod") {
     return std::make_unique<CoreMod>(function);
-  } else if (function.name() == "neq") {
-    return std::make_unique<CoreNeq>(function);
-  } else if (function.name() == "lt") {
-    return std::make_unique<CoreLt>(function);
-  } else if (function.name() == "lte") {
-    return std::make_unique<CoreLte>(function);
-  } else if (function.name() == "gt") {
-    return std::make_unique<CoreGt>(function);
-  } else if (function.name() == "gte") {
-    return std::make_unique<CoreGte>(function);
+  } else if (function.name() == "not_equal") {
+    return std::make_unique<CoreNotEqual>(function);
+  } else if (function.name() == "less_than") {
+    return std::make_unique<CoreLessThan>(function);
+  } else if (function.name() == "less_than_or_equal") {
+    return std::make_unique<CoreLessThanOrEqual>(function);
+  } else if (function.name() == "greater_than") {
+    return std::make_unique<CoreGreaterThan>(function);
+  } else if (function.name() == "greater_than_or_equal") {
+    return std::make_unique<CoreGreaterThanOrEqual>(function);
   } else if (function.name() == "array_reverse") {  // Removed array_concat
     return std::make_unique<CoreArrayReverse>(function);
   } else if (function.name() == "array_contains") {
@@ -245,9 +245,9 @@ std::unique_ptr<EvaluableExpr> FunctionToEvaluable(
     return std::make_unique<CoreXor>(function);
   } else if (function.name() == "cond") {
     return std::make_unique<CoreCond>(function);
-  } else if (function.name() == "eq_any") {
+  } else if (function.name() == "equal_any") {
     return std::make_unique<CoreEqAny>(function);
-  } else if (function.name() == "not_eq_any") {
+  } else if (function.name() == "not_equal_any") {
     return std::make_unique<CoreNotEqAny>(function);
   } else if (function.name() == "is_nan") {
     return std::make_unique<CoreIsNan>(function);
@@ -259,33 +259,32 @@ std::unique_ptr<EvaluableExpr> FunctionToEvaluable(
     return std::make_unique<CoreIsNotNull>(function);
   } else if (function.name() == "is_error") {
     return std::make_unique<CoreIsError>(function);
-  } else if (function.name() == "logical_maximum") {
-    return std::make_unique<CoreLogicalMaximum>(function);
-  } else if (function.name() == "logical_minimum") {
-    return std::make_unique<CoreLogicalMinimum>(function);
+  } else if (function.name() == "maximum") {
+    return std::make_unique<CoreMaximum>(function);
+  } else if (function.name() == "minimum") {
+    return std::make_unique<CoreMinimum>(function);
   } else if (function.name() == "map_get") {
     return std::make_unique<CoreMapGet>(function);
   } else if (function.name() == "byte_length") {
     return std::make_unique<CoreByteLength>(function);
   } else if (function.name() == "char_length") {
     return std::make_unique<CoreCharLength>(function);
-  } else if (function.name() == "str_concat") {
-    return std::make_unique<CoreStrConcat>(function);
+  } else if (function.name() == "string_concat") {
+    return std::make_unique<CoreStringConcat>(function);
   } else if (function.name() == "ends_with") {
     return std::make_unique<CoreEndsWith>(function);
   } else if (function.name() == "starts_with") {
     return std::make_unique<CoreStartsWith>(function);
-  } else if (function.name() == "str_contains") {
-    return std::make_unique<CoreStrContains>(function);
+  } else if (function.name() == "string_contains") {
+    return std::make_unique<CoreStringContains>(function);
   } else if (function.name() == "to_lower") {
     return std::make_unique<CoreToLower>(function);
   } else if (function.name() == "to_upper") {
     return std::make_unique<CoreToUpper>(function);
   } else if (function.name() == "trim") {
     return std::make_unique<CoreTrim>(function);
-  } else if (function.name() == "reverse") {
-    // Note: This handles string reverse. Array reverse is separate.
-    return std::make_unique<CoreReverse>(function);
+  } else if (function.name() == "string_reverse") {
+    return std::make_unique<CoreStringReverse>(function);
   } else if (function.name() == "regex_contains") {
     return std::make_unique<CoreRegexContains>(function);
   } else if (function.name() == "regex_match") {
@@ -427,8 +426,8 @@ EvaluateResult ComparisonBase::Evaluate(
   return CompareToResult(left, right);
 }
 
-EvaluateResult CoreEq::CompareToResult(const EvaluateResult& left,
-                                       const EvaluateResult& right) const {
+EvaluateResult CoreEqual::CompareToResult(const EvaluateResult& left,
+                                          const EvaluateResult& right) const {
   // Type mismatch always results in false for Eq
   if (model::GetTypeOrder(*left.value()) !=
       model::GetTypeOrder(*right.value())) {
@@ -447,10 +446,11 @@ EvaluateResult CoreEq::CompareToResult(const EvaluateResult& left,
     case model::StrictEqualsResult::kNull:
       return EvaluateResult::NewNull();
   }
+  HARD_FAIL("Unhandled case in switch statement");
 }
 
-EvaluateResult CoreNeq::CompareToResult(const EvaluateResult& left,
-                                        const EvaluateResult& right) const {
+EvaluateResult CoreNotEqual::CompareToResult(
+    const EvaluateResult& left, const EvaluateResult& right) const {
   // NaN != anything (including NaN) is true
   if (model::IsNaNValue(*left.value()) || model::IsNaNValue(*right.value())) {
     return EvaluateResult::NewValue(nanopb::MakeMessage(model::TrueValue()));
@@ -469,10 +469,11 @@ EvaluateResult CoreNeq::CompareToResult(const EvaluateResult& left,
     case model::StrictEqualsResult::kNull:
       return EvaluateResult::NewNull();
   }
+  HARD_FAIL("Unhandled case in switch statement");
 }
 
-EvaluateResult CoreLt::CompareToResult(const EvaluateResult& left,
-                                       const EvaluateResult& right) const {
+EvaluateResult CoreLessThan::CompareToResult(
+    const EvaluateResult& left, const EvaluateResult& right) const {
   // Type mismatch always results in false
   if (model::GetTypeOrder(*left.value()) !=
       model::GetTypeOrder(*right.value())) {
@@ -489,8 +490,8 @@ EvaluateResult CoreLt::CompareToResult(const EvaluateResult& left,
       nanopb::MakeMessage(result ? model::TrueValue() : model::FalseValue()));
 }
 
-EvaluateResult CoreLte::CompareToResult(const EvaluateResult& left,
-                                        const EvaluateResult& right) const {
+EvaluateResult CoreLessThanOrEqual::CompareToResult(
+    const EvaluateResult& left, const EvaluateResult& right) const {
   // Type mismatch always results in false
   if (model::GetTypeOrder(*left.value()) !=
       model::GetTypeOrder(*right.value())) {
@@ -514,8 +515,8 @@ EvaluateResult CoreLte::CompareToResult(const EvaluateResult& left,
       nanopb::MakeMessage(result ? model::TrueValue() : model::FalseValue()));
 }
 
-EvaluateResult CoreGt::CompareToResult(const EvaluateResult& left,
-                                       const EvaluateResult& right) const {
+EvaluateResult CoreGreaterThan::CompareToResult(
+    const EvaluateResult& left, const EvaluateResult& right) const {
   // Type mismatch always results in false
   if (model::GetTypeOrder(*left.value()) !=
       model::GetTypeOrder(*right.value())) {
@@ -532,8 +533,8 @@ EvaluateResult CoreGt::CompareToResult(const EvaluateResult& left,
       nanopb::MakeMessage(result ? model::TrueValue() : model::FalseValue()));
 }
 
-EvaluateResult CoreGte::CompareToResult(const EvaluateResult& left,
-                                        const EvaluateResult& right) const {
+EvaluateResult CoreGreaterThanOrEqual::CompareToResult(
+    const EvaluateResult& left, const EvaluateResult& right) const {
   // Type mismatch always results in false
   if (model::GetTypeOrder(*left.value()) !=
       model::GetTypeOrder(*right.value())) {
@@ -584,8 +585,8 @@ template <typename T>
 bool ProcessUtf8(const std::string& s,
                  T* result,
                  std::function<void(T*, uint32_t, absl::string_view)> func) {
-  int i = 0;
-  const int len = s.size();
+  size_t i = 0;
+  const size_t len = s.size();
   const unsigned char* data = reinterpret_cast<const unsigned char*>(s.data());
 
   while (i < len) {
@@ -879,7 +880,7 @@ EvaluateResult CoreCharLength::Evaluate(
   }
 }
 
-EvaluateResult CoreStrConcat::Evaluate(
+EvaluateResult CoreStringConcat::Evaluate(
     const api::EvaluateContext& context,
     const model::PipelineInputOutput& document) const {
   std::string result_string;
@@ -926,8 +927,8 @@ EvaluateResult CoreStartsWith::PerformSearch(const std::string& value,
       nanopb::MakeMessage(result ? model::TrueValue() : model::FalseValue()));
 }
 
-EvaluateResult CoreStrContains::PerformSearch(const std::string& value,
-                                              const std::string& search) const {
+EvaluateResult CoreStringContains::PerformSearch(
+    const std::string& value, const std::string& search) const {
   // Use absl::StrContains
   bool result = absl::StrContains(value, search);
   return EvaluateResult::NewValue(
@@ -988,10 +989,9 @@ EvaluateResult CoreTrim::Evaluate(
 
   switch (evaluated.type()) {
     case EvaluateResult::ResultType::kString: {
-      absl::string_view trimmed_view = absl::StripAsciiWhitespace(
-          nanopb::MakeString(evaluated.value()->string_value));
-      return EvaluateResult::NewValue(
-          model::StringValue(std::move(trimmed_view)));
+      std::string str = nanopb::MakeString(evaluated.value()->string_value);
+      absl::string_view trimmed_view = absl::StripAsciiWhitespace(str);
+      return EvaluateResult::NewValue(model::StringValue(trimmed_view));
     }
     case EvaluateResult::ResultType::kNull:
       return EvaluateResult::NewNull();
@@ -1000,7 +1000,7 @@ EvaluateResult CoreTrim::Evaluate(
   }
 }
 
-EvaluateResult CoreReverse::Evaluate(
+EvaluateResult CoreStringReverse::Evaluate(
     const api::EvaluateContext& context,
     const model::PipelineInputOutput& document) const {
   HARD_ASSERT(expr_->params().size() == 1,
@@ -1292,9 +1292,9 @@ EvaluateResult CoreArrayContains::Evaluate(
 
   std::vector<std::shared_ptr<api::Expr>> reversed_params(
       expr_->params().rbegin(), expr_->params().rend());
-  auto const eq_any =
-      CoreEqAny(api::FunctionExpr("eq_any", std::move(reversed_params)));
-  return eq_any.Evaluate(context, document);
+  auto const equal_any =
+      CoreEqAny(api::FunctionExpr("equal_any", std::move(reversed_params)));
+  return equal_any.Evaluate(context, document);
 }
 
 EvaluateResult CoreArrayContainsAll::Evaluate(
@@ -1689,9 +1689,10 @@ EvaluateResult CoreCond::Evaluate(
 EvaluateResult CoreEqAny::Evaluate(
     const api::EvaluateContext& context,
     const model::PipelineInputOutput& document) const {
-  HARD_ASSERT(expr_->params().size() == 2,
-              "eq_any() function requires exactly 2 params (search value and "
-              "array value)");
+  HARD_ASSERT(
+      expr_->params().size() == 2,
+      "equal_any() function requires exactly 2 params (search value and "
+      "array value)");
 
   bool found_null = false;
 
@@ -1762,7 +1763,8 @@ EvaluateResult CoreNotEqAny::Evaluate(
       "array value)");
 
   CoreNot equivalent(api::FunctionExpr(
-      "not", {std::make_shared<api::FunctionExpr>("eq_any", expr_->params())}));
+      "not",
+      {std::make_shared<api::FunctionExpr>("equal_any", expr_->params())}));
   return equivalent.Evaluate(context, document);
 }
 
@@ -1852,7 +1854,7 @@ EvaluateResult CoreIsError::Evaluate(
   }
 }
 
-EvaluateResult CoreLogicalMaximum::Evaluate(
+EvaluateResult CoreMaximum::Evaluate(
     const api::EvaluateContext& context,
     const model::PipelineInputOutput& document) const {
   // Store the underlying Value proto in the optional, not EvaluateResult
@@ -1886,7 +1888,7 @@ EvaluateResult CoreLogicalMaximum::Evaluate(
   return EvaluateResult::NewNull();
 }
 
-EvaluateResult CoreLogicalMinimum::Evaluate(
+EvaluateResult CoreMinimum::Evaluate(
     const api::EvaluateContext& context,
     const model::PipelineInputOutput& document) const {
   // Store the underlying Value proto in the optional, not EvaluateResult