diff --git a/Firestore/core/src/api/expressions.h b/Firestore/core/src/api/expressions.h
index 3cd5d5cfc68..c90dcce2eb7 100644
--- a/Firestore/core/src/api/expressions.h
+++ b/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;
 };
 
diff --git a/Firestore/core/src/api/pipeline_result.h b/Firestore/core/src/api/pipeline_result.h
index c8db550178a..093500dcd1e 100644
--- a/Firestore/core/src/api/pipeline_result.h
+++ b/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
diff --git a/Firestore/core/src/api/query_snapshot.cc b/Firestore/core/src/api/query_snapshot.cc
index 4e94d6f11e3..e2a10034a27 100644
--- a/Firestore/core/src/api/query_snapshot.cc
+++ b/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"
diff --git a/Firestore/core/src/api/query_snapshot.h b/Firestore/core/src/api/query_snapshot.h
index 58d7c65bf03..5a48ab37793 100644
--- a/Firestore/core/src/api/query_snapshot.h
+++ b/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"
diff --git a/Firestore/core/src/api/realtime_pipeline_snapshot.h b/Firestore/core/src/api/realtime_pipeline_snapshot.h
index 0b326376287..6a2fd958f32 100644
--- a/Firestore/core/src/api/realtime_pipeline_snapshot.h
+++ b/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_
diff --git a/Firestore/core/src/core/expressions_eval.cc b/Firestore/core/src/core/expressions_eval.cc
index 4ae269cec62..757172c274c 100644
--- a/Firestore/core/src/core/expressions_eval.cc
+++ b/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
diff --git a/Firestore/core/src/core/expressions_eval.h b/Firestore/core/src/core/expressions_eval.h
index c82060a7cb7..298d3e8b617 100644
--- a/Firestore/core/src/core/expressions_eval.h
+++ b/Firestore/core/src/core/expressions_eval.h
@@ -163,9 +163,9 @@ class ComparisonBase : public EvaluableExpr {
   std::unique_ptr<api::FunctionExpr> expr_;
 };
 
-class CoreEq : public ComparisonBase {
+class CoreEqual : public ComparisonBase {
  public:
-  explicit CoreEq(const api::FunctionExpr& expr) : ComparisonBase(expr) {
+  explicit CoreEqual(const api::FunctionExpr& expr) : ComparisonBase(expr) {
   }
 
  protected:
@@ -173,9 +173,9 @@ class CoreEq : public ComparisonBase {
                                  const EvaluateResult& right) const override;
 };
 
-class CoreNeq : public ComparisonBase {
+class CoreNotEqual : public ComparisonBase {
  public:
-  explicit CoreNeq(const api::FunctionExpr& expr) : ComparisonBase(expr) {
+  explicit CoreNotEqual(const api::FunctionExpr& expr) : ComparisonBase(expr) {
   }
 
  protected:
@@ -183,9 +183,9 @@ class CoreNeq : public ComparisonBase {
                                  const EvaluateResult& right) const override;
 };
 
-class CoreLt : public ComparisonBase {
+class CoreLessThan : public ComparisonBase {
  public:
-  explicit CoreLt(const api::FunctionExpr& expr) : ComparisonBase(expr) {
+  explicit CoreLessThan(const api::FunctionExpr& expr) : ComparisonBase(expr) {
   }
 
  protected:
@@ -193,9 +193,10 @@ class CoreLt : public ComparisonBase {
                                  const EvaluateResult& right) const override;
 };
 
-class CoreLte : public ComparisonBase {
+class CoreLessThanOrEqual : public ComparisonBase {
  public:
-  explicit CoreLte(const api::FunctionExpr& expr) : ComparisonBase(expr) {
+  explicit CoreLessThanOrEqual(const api::FunctionExpr& expr)
+      : ComparisonBase(expr) {
   }
 
  protected:
@@ -203,9 +204,10 @@ class CoreLte : public ComparisonBase {
                                  const EvaluateResult& right) const override;
 };
 
-class CoreGt : public ComparisonBase {
+class CoreGreaterThan : public ComparisonBase {
  public:
-  explicit CoreGt(const api::FunctionExpr& expr) : ComparisonBase(expr) {
+  explicit CoreGreaterThan(const api::FunctionExpr& expr)
+      : ComparisonBase(expr) {
   }
 
  protected:
@@ -213,9 +215,10 @@ class CoreGt : public ComparisonBase {
                                  const EvaluateResult& right) const override;
 };
 
-class CoreGte : public ComparisonBase {
+class CoreGreaterThanOrEqual : public ComparisonBase {
  public:
-  explicit CoreGte(const api::FunctionExpr& expr) : ComparisonBase(expr) {
+  explicit CoreGreaterThanOrEqual(const api::FunctionExpr& expr)
+      : ComparisonBase(expr) {
   }
 
  protected:
@@ -431,9 +434,9 @@ class CoreCharLength : public EvaluableExpr {
   std::unique_ptr<api::FunctionExpr> expr_;
 };
 
-class CoreStrConcat : public EvaluableExpr {
+class CoreStringConcat : public EvaluableExpr {
  public:
-  explicit CoreStrConcat(const api::FunctionExpr& expr)
+  explicit CoreStringConcat(const api::FunctionExpr& expr)
       : expr_(std::make_unique<api::FunctionExpr>(expr)) {
   }
   EvaluateResult Evaluate(
@@ -466,9 +469,9 @@ class CoreStartsWith : public StringSearchBase {
                                const std::string& search) const override;
 };
 
-class CoreStrContains : public StringSearchBase {
+class CoreStringContains : public StringSearchBase {
  public:
-  explicit CoreStrContains(const api::FunctionExpr& expr)
+  explicit CoreStringContains(const api::FunctionExpr& expr)
       : StringSearchBase(expr) {
   }
 
@@ -516,9 +519,9 @@ class CoreTrim : public EvaluableExpr {
   std::unique_ptr<api::FunctionExpr> expr_;
 };
 
-class CoreReverse : public EvaluableExpr {
+class CoreStringReverse : public EvaluableExpr {
  public:
-  explicit CoreReverse(const api::FunctionExpr& expr)
+  explicit CoreStringReverse(const api::FunctionExpr& expr)
       : expr_(std::make_unique<api::FunctionExpr>(expr)) {
   }
   EvaluateResult Evaluate(
@@ -721,9 +724,9 @@ class CoreIsError : public EvaluableExpr {
   std::unique_ptr<api::FunctionExpr> expr_;
 };
 
-class CoreLogicalMaximum : public EvaluableExpr {
+class CoreMaximum : public EvaluableExpr {
  public:
-  explicit CoreLogicalMaximum(const api::FunctionExpr& expr)
+  explicit CoreMaximum(const api::FunctionExpr& expr)
       : expr_(std::make_unique<api::FunctionExpr>(expr)) {
   }
   EvaluateResult Evaluate(
@@ -734,9 +737,9 @@ class CoreLogicalMaximum : public EvaluableExpr {
   std::unique_ptr<api::FunctionExpr> expr_;
 };
 
-class CoreLogicalMinimum : public EvaluableExpr {
+class CoreMinimum : public EvaluableExpr {
  public:
-  explicit CoreLogicalMinimum(const api::FunctionExpr& expr)
+  explicit CoreMinimum(const api::FunctionExpr& expr)
       : expr_(std::make_unique<api::FunctionExpr>(expr)) {
   }
   EvaluateResult Evaluate(
diff --git a/Firestore/core/src/core/pipeline_util.cc b/Firestore/core/src/core/pipeline_util.cc
index 11531845d32..212a801f1bc 100644
--- a/Firestore/core/src/core/pipeline_util.cc
+++ b/Firestore/core/src/core/pipeline_util.cc
@@ -561,22 +561,22 @@ std::shared_ptr<api::Expr> ToPipelineBooleanExpr(const Filter& filter) {
 
     switch (op) {
       case FieldFilter::Operator::LessThan:
-        func_name = "lt";
+        func_name = "less_than";
         break;
       case FieldFilter::Operator::LessThanOrEqual:
-        func_name = "lte";
+        func_name = "less_than_or_equal";
         break;
       case FieldFilter::Operator::GreaterThan:
-        func_name = "gt";
+        func_name = "greater_than";
         break;
       case FieldFilter::Operator::GreaterThanOrEqual:
-        func_name = "gte";
+        func_name = "greater_than_or_equal";
         break;
       case FieldFilter::Operator::Equal:
-        func_name = "eq";
+        func_name = "equal";
         break;
       case FieldFilter::Operator::NotEqual:
-        func_name = "neq";
+        func_name = "not_equal";
         break;
       case FieldFilter::Operator::ArrayContains:
         func_name = "array_contains";
@@ -589,9 +589,9 @@ std::shared_ptr<api::Expr> ToPipelineBooleanExpr(const Filter& filter) {
             "Value for IN, NOT_IN, ARRAY_CONTAINS_ANY must be an array.");
 
         if (op == FieldFilter::Operator::In)
-          func_name = "eq_any";
+          func_name = "equal_any";
         else if (op == FieldFilter::Operator::NotIn)
-          func_name = "not_eq_any";
+          func_name = "not_equal_any";
         else if (op == FieldFilter::Operator::ArrayContainsAny)
           func_name = "array_contains_any";
         break;
@@ -635,8 +635,9 @@ std::shared_ptr<api::Expr> WhereConditionsFromCursor(
         std::make_shared<api::Constant>(model::DeepClone(pos->values[i])));
   }
 
-  std::string func_name = is_before ? "lt" : "gt";
-  std::string func_inclusive_name = is_before ? "lte" : "gte";
+  std::string func_name = is_before ? "less_than" : "greater_than";
+  std::string func_inclusive_name =
+      is_before ? "less_than_or_equal" : "greater_than_or_equal";
 
   std::vector<std::shared_ptr<api::Expr>> or_conditions;
   for (size_t sub_end = 1; sub_end <= cursors.size(); ++sub_end) {
diff --git a/Firestore/core/src/core/view.cc b/Firestore/core/src/core/view.cc
index 6bd612491d6..e1ccb6b838b 100644
--- a/Firestore/core/src/core/view.cc
+++ b/Firestore/core/src/core/view.cc
@@ -20,10 +20,10 @@
 #include <utility>
 #include <valarray>
 
+#include "Firestore/core/src/core/pipeline_run.h"
 #include "Firestore/core/src/core/target.h"
 #include "Firestore/core/src/model/document_set.h"
 #include "Firestore/core/src/util/hard_assert.h"  // For HARD_ASSERT and HARD_FAIL
-#include "pipeline_run.h"
 
 namespace firebase {
 namespace firestore {
diff --git a/Firestore/core/test/unit/core/expressions/arithmetic_test.cc b/Firestore/core/test/unit/core/expressions/arithmetic_test.cc
index 1364fd6c38a..9e9d6c8f606 100644
--- a/Firestore/core/test/unit/core/expressions/arithmetic_test.cc
+++ b/Firestore/core/test/unit/core/expressions/arithmetic_test.cc
@@ -67,13 +67,15 @@ class ModFunctionTest : public ArithmeticExpressionsTest {};
 
 TEST_F(AddFunctionTest, BasicNumerics) {
   EXPECT_THAT(
-      EvaluateExpr(*AddExpr({SharedConstant(1LL), SharedConstant(2LL)})),
+      EvaluateExpr(*AddExpr({SharedConstant(static_cast<int64_t>(1LL)),
+                             SharedConstant(static_cast<int64_t>(2LL))})),
       Returns(Value(3LL)));
+  EXPECT_THAT(EvaluateExpr(*AddExpr({SharedConstant(static_cast<int64_t>(1LL)),
+                                     SharedConstant(2.5)})),
+              Returns(Value(3.5)));
   EXPECT_THAT(
-      EvaluateExpr(*AddExpr({SharedConstant(1LL), SharedConstant(2.5)})),
-      Returns(Value(3.5)));
-  EXPECT_THAT(
-      EvaluateExpr(*AddExpr({SharedConstant(1.0), SharedConstant(2LL)})),
+      EvaluateExpr(*AddExpr(
+          {SharedConstant(1.0), SharedConstant(static_cast<int64_t>(2LL))})),
       Returns(Value(3.0)));
   EXPECT_THAT(
       EvaluateExpr(*AddExpr({SharedConstant(1.0), SharedConstant(2.0)})),
@@ -81,9 +83,9 @@ TEST_F(AddFunctionTest, BasicNumerics) {
 }
 
 TEST_F(AddFunctionTest, BasicNonNumerics) {
-  EXPECT_THAT(
-      EvaluateExpr(*AddExpr({SharedConstant(1LL), SharedConstant("1")})),
-      ReturnsError());
+  EXPECT_THAT(EvaluateExpr(*AddExpr({SharedConstant(static_cast<int64_t>(1LL)),
+                                     SharedConstant("1")})),
+              ReturnsError());
   EXPECT_THAT(
       EvaluateExpr(*AddExpr({SharedConstant("1"), SharedConstant(1.0)})),
       ReturnsError());
@@ -95,12 +97,14 @@ TEST_F(AddFunctionTest, BasicNonNumerics) {
 TEST_F(AddFunctionTest, DoubleLongAdditionOverflow) {
   // Note: C++ double can represent Long.MAX_VALUE + 1.0 exactly, unlike some JS
   // representations.
-  EXPECT_THAT(EvaluateExpr(*AddExpr({SharedConstant(9223372036854775807LL),
-                                     SharedConstant(1.0)})),
+  EXPECT_THAT(EvaluateExpr(*AddExpr(
+                  {SharedConstant(static_cast<int64_t>(9223372036854775807LL)),
+                   SharedConstant(1.0)})),
               Returns(Value(9.223372036854776e+18)));
-  EXPECT_THAT(EvaluateExpr(*AddExpr({SharedConstant(9.223372036854776e+18),
-                                     SharedConstant(100LL)})),
-              Returns(Value(9.223372036854776e+18 + 100.0)));
+  EXPECT_THAT(
+      EvaluateExpr(*AddExpr({SharedConstant(9.223372036854776e+18),
+                             SharedConstant(static_cast<int64_t>(100LL))})),
+      Returns(Value(9.223372036854776e+18 + 100.0)));
 }
 
 TEST_F(AddFunctionTest, DoubleAdditionOverflow) {
@@ -124,31 +128,33 @@ TEST_F(AddFunctionTest, SumPosAndNegInfinityReturnNaN) {
 TEST_F(AddFunctionTest, LongAdditionOverflow) {
   EXPECT_THAT(EvaluateExpr(
                   *AddExpr({SharedConstant(std::numeric_limits<int64_t>::max()),
-                            SharedConstant(1LL)})),
+                            SharedConstant(static_cast<int64_t>(1LL))})),
               ReturnsError());  // Expect error due to overflow
   EXPECT_THAT(EvaluateExpr(
                   *AddExpr({SharedConstant(std::numeric_limits<int64_t>::min()),
-                            SharedConstant(-1LL)})),
+                            SharedConstant(static_cast<int64_t>(-1LL))})),
               ReturnsError());  // Expect error due to overflow
   EXPECT_THAT(EvaluateExpr(*AddExpr(
-                  {SharedConstant(1LL),
+                  {SharedConstant(static_cast<int64_t>(1LL)),
                    SharedConstant(std::numeric_limits<int64_t>::max())})),
               ReturnsError());  // Expect error due to overflow
 }
 
 TEST_F(AddFunctionTest, NanNumberReturnNaN) {
   double nan_val = std::numeric_limits<double>::quiet_NaN();
-  EXPECT_THAT(
-      EvaluateExpr(*AddExpr({SharedConstant(1LL), SharedConstant(nan_val)})),
-      Returns(Value(nan_val)));
+  EXPECT_THAT(EvaluateExpr(*AddExpr({SharedConstant(static_cast<int64_t>(1LL)),
+                                     SharedConstant(nan_val)})),
+              Returns(Value(nan_val)));
   EXPECT_THAT(
       EvaluateExpr(*AddExpr({SharedConstant(1.0), SharedConstant(nan_val)})),
       Returns(Value(nan_val)));
-  EXPECT_THAT(EvaluateExpr(*AddExpr({SharedConstant(9007199254740991LL),
-                                     SharedConstant(nan_val)})),
+  EXPECT_THAT(EvaluateExpr(*AddExpr(
+                  {SharedConstant(static_cast<int64_t>(9007199254740991LL)),
+                   SharedConstant(nan_val)})),
               Returns(Value(nan_val)));
-  EXPECT_THAT(EvaluateExpr(*AddExpr({SharedConstant(-9007199254740991LL),
-                                     SharedConstant(nan_val)})),
+  EXPECT_THAT(EvaluateExpr(*AddExpr(
+                  {SharedConstant(static_cast<int64_t>(-9007199254740991LL)),
+                   SharedConstant(nan_val)})),
               Returns(Value(nan_val)));
   EXPECT_THAT(
       EvaluateExpr(*AddExpr({SharedConstant(std::numeric_limits<double>::max()),
@@ -177,12 +183,16 @@ TEST_F(AddFunctionTest, NanNotNumberTypeReturnError) {
 
 TEST_F(AddFunctionTest, MultiArgument) {
   // EvaluateExpr handles single expression, so nest calls for multi-arg
-  auto add12 = AddExpr({SharedConstant(1LL), SharedConstant(2LL)});
-  EXPECT_THAT(EvaluateExpr(*AddExpr({add12, SharedConstant(3LL)})),
+  auto add12 = AddExpr({SharedConstant(static_cast<int64_t>(1LL)),
+                        SharedConstant(static_cast<int64_t>(2LL))});
+  EXPECT_THAT(EvaluateExpr(
+                  *AddExpr({add12, SharedConstant(static_cast<int64_t>(3LL))})),
               Returns(Value(6LL)));
 
-  auto add10_2 = AddExpr({SharedConstant(1.0), SharedConstant(2LL)});
-  EXPECT_THAT(EvaluateExpr(*AddExpr({add10_2, SharedConstant(3LL)})),
+  auto add10_2 =
+      AddExpr({SharedConstant(1.0), SharedConstant(static_cast<int64_t>(2LL))});
+  EXPECT_THAT(EvaluateExpr(*AddExpr(
+                  {add10_2, SharedConstant(static_cast<int64_t>(3LL))})),
               Returns(Value(6.0)));
 }
 
@@ -190,13 +200,16 @@ TEST_F(AddFunctionTest, MultiArgument) {
 
 TEST_F(SubtractFunctionTest, BasicNumerics) {
   EXPECT_THAT(
-      EvaluateExpr(*SubtractExpr({SharedConstant(1LL), SharedConstant(2LL)})),
+      EvaluateExpr(*SubtractExpr({SharedConstant(static_cast<int64_t>(1LL)),
+                                  SharedConstant(static_cast<int64_t>(2LL))})),
       Returns(Value(-1LL)));
   EXPECT_THAT(
-      EvaluateExpr(*SubtractExpr({SharedConstant(1LL), SharedConstant(2.5)})),
+      EvaluateExpr(*SubtractExpr(
+          {SharedConstant(static_cast<int64_t>(1LL)), SharedConstant(2.5)})),
       Returns(Value(-1.5)));
   EXPECT_THAT(
-      EvaluateExpr(*SubtractExpr({SharedConstant(1.0), SharedConstant(2LL)})),
+      EvaluateExpr(*SubtractExpr(
+          {SharedConstant(1.0), SharedConstant(static_cast<int64_t>(2LL))})),
       Returns(Value(-1.0)));
   EXPECT_THAT(
       EvaluateExpr(*SubtractExpr({SharedConstant(1.0), SharedConstant(2.0)})),
@@ -205,7 +218,8 @@ TEST_F(SubtractFunctionTest, BasicNumerics) {
 
 TEST_F(SubtractFunctionTest, BasicNonNumerics) {
   EXPECT_THAT(
-      EvaluateExpr(*SubtractExpr({SharedConstant(1LL), SharedConstant("1")})),
+      EvaluateExpr(*SubtractExpr(
+          {SharedConstant(static_cast<int64_t>(1LL)), SharedConstant("1")})),
       ReturnsError());
   EXPECT_THAT(
       EvaluateExpr(*SubtractExpr({SharedConstant("1"), SharedConstant(1.0)})),
@@ -229,27 +243,30 @@ TEST_F(SubtractFunctionTest, DoubleSubtractionOverflow) {
 TEST_F(SubtractFunctionTest, LongSubtractionOverflow) {
   EXPECT_THAT(EvaluateExpr(*SubtractExpr(
                   {SharedConstant(std::numeric_limits<int64_t>::min()),
-                   SharedConstant(1LL)})),
+                   SharedConstant(static_cast<int64_t>(1LL))})),
               ReturnsError());
   EXPECT_THAT(EvaluateExpr(*SubtractExpr(
                   {SharedConstant(std::numeric_limits<int64_t>::max()),
-                   SharedConstant(-1LL)})),
+                   SharedConstant(static_cast<int64_t>(-1LL))})),
               ReturnsError());
 }
 
 TEST_F(SubtractFunctionTest, NanNumberReturnNaN) {
   double nan_val = std::numeric_limits<double>::quiet_NaN();
-  EXPECT_THAT(EvaluateExpr(*SubtractExpr(
-                  {SharedConstant(1LL), SharedConstant(nan_val)})),
-              Returns(Value(nan_val)));
+  EXPECT_THAT(
+      EvaluateExpr(*SubtractExpr({SharedConstant(static_cast<int64_t>(1LL)),
+                                  SharedConstant(nan_val)})),
+      Returns(Value(nan_val)));
   EXPECT_THAT(EvaluateExpr(*SubtractExpr(
                   {SharedConstant(1.0), SharedConstant(nan_val)})),
               Returns(Value(nan_val)));
-  EXPECT_THAT(EvaluateExpr(*SubtractExpr({SharedConstant(9007199254740991LL),
-                                          SharedConstant(nan_val)})),
+  EXPECT_THAT(EvaluateExpr(*SubtractExpr(
+                  {SharedConstant(static_cast<int64_t>(9007199254740991LL)),
+                   SharedConstant(nan_val)})),
               Returns(Value(nan_val)));
-  EXPECT_THAT(EvaluateExpr(*SubtractExpr({SharedConstant(-9007199254740991LL),
-                                          SharedConstant(nan_val)})),
+  EXPECT_THAT(EvaluateExpr(*SubtractExpr(
+                  {SharedConstant(static_cast<int64_t>(-9007199254740991LL)),
+                   SharedConstant(nan_val)})),
               Returns(Value(nan_val)));
   EXPECT_THAT(EvaluateExpr(*SubtractExpr(
                   {SharedConstant(std::numeric_limits<double>::max()),
@@ -279,10 +296,10 @@ TEST_F(SubtractFunctionTest, NanNotNumberTypeReturnError) {
 TEST_F(SubtractFunctionTest, PositiveInfinity) {
   EXPECT_THAT(EvaluateExpr(*SubtractExpr(
                   {SharedConstant(std::numeric_limits<double>::infinity()),
-                   SharedConstant(1LL)})),
+                   SharedConstant(static_cast<int64_t>(1LL))})),
               Returns(Value(std::numeric_limits<double>::infinity())));
   EXPECT_THAT(EvaluateExpr(*SubtractExpr(
-                  {SharedConstant(1LL),
+                  {SharedConstant(static_cast<int64_t>(1LL)),
                    SharedConstant(std::numeric_limits<double>::infinity())})),
               Returns(Value(-std::numeric_limits<double>::infinity())));
 }
@@ -290,10 +307,10 @@ TEST_F(SubtractFunctionTest, PositiveInfinity) {
 TEST_F(SubtractFunctionTest, NegativeInfinity) {
   EXPECT_THAT(EvaluateExpr(*SubtractExpr(
                   {SharedConstant(-std::numeric_limits<double>::infinity()),
-                   SharedConstant(1LL)})),
+                   SharedConstant(static_cast<int64_t>(1LL))})),
               Returns(Value(-std::numeric_limits<double>::infinity())));
   EXPECT_THAT(EvaluateExpr(*SubtractExpr(
-                  {SharedConstant(1LL),
+                  {SharedConstant(static_cast<int64_t>(1LL)),
                    SharedConstant(-std::numeric_limits<double>::infinity())})),
               Returns(Value(std::numeric_limits<double>::infinity())));
 }
@@ -313,13 +330,16 @@ TEST_F(SubtractFunctionTest, PositiveInfinityNegativeInfinity) {
 
 TEST_F(MultiplyFunctionTest, BasicNumerics) {
   EXPECT_THAT(
-      EvaluateExpr(*MultiplyExpr({SharedConstant(1LL), SharedConstant(2LL)})),
+      EvaluateExpr(*MultiplyExpr({SharedConstant(static_cast<int64_t>(1LL)),
+                                  SharedConstant(static_cast<int64_t>(2LL))})),
       Returns(Value(2LL)));
   EXPECT_THAT(
-      EvaluateExpr(*MultiplyExpr({SharedConstant(3LL), SharedConstant(2.5)})),
+      EvaluateExpr(*MultiplyExpr(
+          {SharedConstant(static_cast<int64_t>(3LL)), SharedConstant(2.5)})),
       Returns(Value(7.5)));
   EXPECT_THAT(
-      EvaluateExpr(*MultiplyExpr({SharedConstant(1.0), SharedConstant(2LL)})),
+      EvaluateExpr(*MultiplyExpr(
+          {SharedConstant(1.0), SharedConstant(static_cast<int64_t>(2LL))})),
       Returns(Value(2.0)));
   EXPECT_THAT(
       EvaluateExpr(*MultiplyExpr({SharedConstant(1.32), SharedConstant(2.0)})),
@@ -328,7 +348,8 @@ TEST_F(MultiplyFunctionTest, BasicNumerics) {
 
 TEST_F(MultiplyFunctionTest, BasicNonNumerics) {
   EXPECT_THAT(
-      EvaluateExpr(*MultiplyExpr({SharedConstant(1LL), SharedConstant("1")})),
+      EvaluateExpr(*MultiplyExpr(
+          {SharedConstant(static_cast<int64_t>(1LL)), SharedConstant("1")})),
       ReturnsError());
   EXPECT_THAT(
       EvaluateExpr(*MultiplyExpr({SharedConstant("1"), SharedConstant(1.0)})),
@@ -340,11 +361,13 @@ TEST_F(MultiplyFunctionTest, BasicNonNumerics) {
 
 TEST_F(MultiplyFunctionTest, DoubleLongMultiplicationOverflow) {
   // C++ double handles this fine
-  EXPECT_THAT(EvaluateExpr(*MultiplyExpr({SharedConstant(9223372036854775807LL),
-                                          SharedConstant(100.0)})),
+  EXPECT_THAT(EvaluateExpr(*MultiplyExpr(
+                  {SharedConstant(static_cast<int64_t>(9223372036854775807LL)),
+                   SharedConstant(100.0)})),
               Returns(Value(9.223372036854776e+20)));  // Approx
-  EXPECT_THAT(EvaluateExpr(*MultiplyExpr({SharedConstant(9223372036854775807LL),
-                                          SharedConstant(100LL)})),
+  EXPECT_THAT(EvaluateExpr(*MultiplyExpr(
+                  {SharedConstant(static_cast<int64_t>(9223372036854775807LL)),
+                   SharedConstant(static_cast<int64_t>(100LL))})),
               ReturnsError());  // Integer overflow
 }
 
@@ -362,36 +385,39 @@ TEST_F(MultiplyFunctionTest, DoubleMultiplicationOverflow) {
 TEST_F(MultiplyFunctionTest, LongMultiplicationOverflow) {
   EXPECT_THAT(EvaluateExpr(*MultiplyExpr(
                   {SharedConstant(std::numeric_limits<int64_t>::max()),
-                   SharedConstant(10LL)})),
+                   SharedConstant(static_cast<int64_t>(10LL))})),
               ReturnsError());
   EXPECT_THAT(EvaluateExpr(*MultiplyExpr(
                   {SharedConstant(std::numeric_limits<int64_t>::min()),
-                   SharedConstant(10LL)})),
+                   SharedConstant(static_cast<int64_t>(10LL))})),
               ReturnsError());
   EXPECT_THAT(EvaluateExpr(*MultiplyExpr(
-                  {SharedConstant(-10LL),
+                  {SharedConstant(static_cast<int64_t>(-10LL)),
                    SharedConstant(std::numeric_limits<int64_t>::max())})),
               ReturnsError());
   // Note: min * -10 overflows
   EXPECT_THAT(EvaluateExpr(*MultiplyExpr(
-                  {SharedConstant(-10LL),
+                  {SharedConstant(static_cast<int64_t>(-10LL)),
                    SharedConstant(std::numeric_limits<int64_t>::min())})),
               ReturnsError());
 }
 
 TEST_F(MultiplyFunctionTest, NanNumberReturnNaN) {
   double nan_val = std::numeric_limits<double>::quiet_NaN();
-  EXPECT_THAT(EvaluateExpr(*MultiplyExpr(
-                  {SharedConstant(1LL), SharedConstant(nan_val)})),
-              Returns(Value(nan_val)));
+  EXPECT_THAT(
+      EvaluateExpr(*MultiplyExpr({SharedConstant(static_cast<int64_t>(1LL)),
+                                  SharedConstant(nan_val)})),
+      Returns(Value(nan_val)));
   EXPECT_THAT(EvaluateExpr(*MultiplyExpr(
                   {SharedConstant(1.0), SharedConstant(nan_val)})),
               Returns(Value(nan_val)));
-  EXPECT_THAT(EvaluateExpr(*MultiplyExpr({SharedConstant(9007199254740991LL),
-                                          SharedConstant(nan_val)})),
+  EXPECT_THAT(EvaluateExpr(*MultiplyExpr(
+                  {SharedConstant(static_cast<int64_t>(9007199254740991LL)),
+                   SharedConstant(nan_val)})),
               Returns(Value(nan_val)));
-  EXPECT_THAT(EvaluateExpr(*MultiplyExpr({SharedConstant(-9007199254740991LL),
-                                          SharedConstant(nan_val)})),
+  EXPECT_THAT(EvaluateExpr(*MultiplyExpr(
+                  {SharedConstant(static_cast<int64_t>(-9007199254740991LL)),
+                   SharedConstant(nan_val)})),
               Returns(Value(nan_val)));
   EXPECT_THAT(EvaluateExpr(*MultiplyExpr(
                   {SharedConstant(std::numeric_limits<double>::max()),
@@ -421,10 +447,10 @@ TEST_F(MultiplyFunctionTest, NanNotNumberTypeReturnError) {
 TEST_F(MultiplyFunctionTest, PositiveInfinity) {
   EXPECT_THAT(EvaluateExpr(*MultiplyExpr(
                   {SharedConstant(std::numeric_limits<double>::infinity()),
-                   SharedConstant(1LL)})),
+                   SharedConstant(static_cast<int64_t>(1LL))})),
               Returns(Value(std::numeric_limits<double>::infinity())));
   EXPECT_THAT(EvaluateExpr(*MultiplyExpr(
-                  {SharedConstant(1LL),
+                  {SharedConstant(static_cast<int64_t>(1LL)),
                    SharedConstant(std::numeric_limits<double>::infinity())})),
               Returns(Value(std::numeric_limits<double>::infinity())));
 }
@@ -432,10 +458,10 @@ TEST_F(MultiplyFunctionTest, PositiveInfinity) {
 TEST_F(MultiplyFunctionTest, NegativeInfinity) {
   EXPECT_THAT(EvaluateExpr(*MultiplyExpr(
                   {SharedConstant(-std::numeric_limits<double>::infinity()),
-                   SharedConstant(1LL)})),
+                   SharedConstant(static_cast<int64_t>(1LL))})),
               Returns(Value(-std::numeric_limits<double>::infinity())));
   EXPECT_THAT(EvaluateExpr(*MultiplyExpr(
-                  {SharedConstant(1LL),
+                  {SharedConstant(static_cast<int64_t>(1LL)),
                    SharedConstant(-std::numeric_limits<double>::infinity())})),
               Returns(Value(-std::numeric_limits<double>::infinity())));
 }
@@ -453,11 +479,14 @@ TEST_F(MultiplyFunctionTest,
 }
 
 TEST_F(MultiplyFunctionTest, MultiArgument) {
-  auto mult12 = MultiplyExpr({SharedConstant(1LL), SharedConstant(2LL)});
-  EXPECT_THAT(EvaluateExpr(*MultiplyExpr({mult12, SharedConstant(3LL)})),
+  auto mult12 = MultiplyExpr({SharedConstant(static_cast<int64_t>(1LL)),
+                              SharedConstant(static_cast<int64_t>(2LL))});
+  EXPECT_THAT(EvaluateExpr(*MultiplyExpr(
+                  {mult12, SharedConstant(static_cast<int64_t>(3LL))})),
               Returns(Value(6LL)));
 
-  auto mult23 = MultiplyExpr({SharedConstant(2LL), SharedConstant(3LL)});
+  auto mult23 = MultiplyExpr({SharedConstant(static_cast<int64_t>(2LL)),
+                              SharedConstant(static_cast<int64_t>(3LL))});
   EXPECT_THAT(EvaluateExpr(*MultiplyExpr({SharedConstant(1.0), mult23})),
               Returns(Value(6.0)));
 }
@@ -466,13 +495,16 @@ TEST_F(MultiplyFunctionTest, MultiArgument) {
 
 TEST_F(DivideFunctionTest, BasicNumerics) {
   EXPECT_THAT(
-      EvaluateExpr(*DivideExpr({SharedConstant(10LL), SharedConstant(2LL)})),
+      EvaluateExpr(*DivideExpr({SharedConstant(static_cast<int64_t>(10LL)),
+                                SharedConstant(static_cast<int64_t>(2LL))})),
       Returns(Value(5LL)));
   EXPECT_THAT(
-      EvaluateExpr(*DivideExpr({SharedConstant(10LL), SharedConstant(2.0)})),
+      EvaluateExpr(*DivideExpr(
+          {SharedConstant(static_cast<int64_t>(10LL)), SharedConstant(2.0)})),
       Returns(Value(5.0)));
   EXPECT_THAT(
-      EvaluateExpr(*DivideExpr({SharedConstant(10.0), SharedConstant(3LL)})),
+      EvaluateExpr(*DivideExpr(
+          {SharedConstant(10.0), SharedConstant(static_cast<int64_t>(3LL))})),
       Returns(Value(10.0 / 3.0)));
   EXPECT_THAT(
       EvaluateExpr(*DivideExpr({SharedConstant(10.0), SharedConstant(7.0)})),
@@ -481,7 +513,8 @@ TEST_F(DivideFunctionTest, BasicNumerics) {
 
 TEST_F(DivideFunctionTest, BasicNonNumerics) {
   EXPECT_THAT(
-      EvaluateExpr(*DivideExpr({SharedConstant(1LL), SharedConstant("1")})),
+      EvaluateExpr(*DivideExpr(
+          {SharedConstant(static_cast<int64_t>(1LL)), SharedConstant("1")})),
       ReturnsError());
   EXPECT_THAT(
       EvaluateExpr(*DivideExpr({SharedConstant("1"), SharedConstant(1.0)})),
@@ -493,16 +526,20 @@ TEST_F(DivideFunctionTest, BasicNonNumerics) {
 
 TEST_F(DivideFunctionTest, LongDivision) {
   EXPECT_THAT(
-      EvaluateExpr(*DivideExpr({SharedConstant(10LL), SharedConstant(3LL)})),
+      EvaluateExpr(*DivideExpr({SharedConstant(static_cast<int64_t>(10LL)),
+                                SharedConstant(static_cast<int64_t>(3LL))})),
       Returns(Value(3LL)));  // Integer division
   EXPECT_THAT(
-      EvaluateExpr(*DivideExpr({SharedConstant(-10LL), SharedConstant(3LL)})),
+      EvaluateExpr(*DivideExpr({SharedConstant(static_cast<int64_t>(-10LL)),
+                                SharedConstant(static_cast<int64_t>(3LL))})),
       Returns(Value(-3LL)));  // Integer division
   EXPECT_THAT(
-      EvaluateExpr(*DivideExpr({SharedConstant(10LL), SharedConstant(-3LL)})),
+      EvaluateExpr(*DivideExpr({SharedConstant(static_cast<int64_t>(10LL)),
+                                SharedConstant(static_cast<int64_t>(-3LL))})),
       Returns(Value(-3LL)));  // Integer division
   EXPECT_THAT(
-      EvaluateExpr(*DivideExpr({SharedConstant(-10LL), SharedConstant(-3LL)})),
+      EvaluateExpr(*DivideExpr({SharedConstant(static_cast<int64_t>(-10LL)),
+                                SharedConstant(static_cast<int64_t>(-3LL))})),
       Returns(Value(3LL)));  // Integer division
 }
 
@@ -519,7 +556,8 @@ TEST_F(DivideFunctionTest, DoubleDivisionOverflow) {
 
 TEST_F(DivideFunctionTest, ByZero) {
   EXPECT_THAT(
-      EvaluateExpr(*DivideExpr({SharedConstant(1LL), SharedConstant(0LL)})),
+      EvaluateExpr(*DivideExpr({SharedConstant(static_cast<int64_t>(1LL)),
+                                SharedConstant(static_cast<int64_t>(0LL))})),
       ReturnsError());  // Integer division by zero is error
   EXPECT_THAT(
       EvaluateExpr(*DivideExpr({SharedConstant(1.1), SharedConstant(0.0)})),
@@ -535,10 +573,12 @@ TEST_F(DivideFunctionTest, ByZero) {
 TEST_F(DivideFunctionTest, NanNumberReturnNaN) {
   double nan_val = std::numeric_limits<double>::quiet_NaN();
   EXPECT_THAT(
-      EvaluateExpr(*DivideExpr({SharedConstant(1LL), SharedConstant(nan_val)})),
+      EvaluateExpr(*DivideExpr({SharedConstant(static_cast<int64_t>(1LL)),
+                                SharedConstant(nan_val)})),
       Returns(Value(nan_val)));
   EXPECT_THAT(
-      EvaluateExpr(*DivideExpr({SharedConstant(nan_val), SharedConstant(1LL)})),
+      EvaluateExpr(*DivideExpr({SharedConstant(nan_val),
+                                SharedConstant(static_cast<int64_t>(1LL))})),
       Returns(Value(nan_val)));
   EXPECT_THAT(
       EvaluateExpr(*DivideExpr({SharedConstant(1.0), SharedConstant(nan_val)})),
@@ -573,10 +613,10 @@ TEST_F(DivideFunctionTest, NanNotNumberTypeReturnError) {
 TEST_F(DivideFunctionTest, PositiveInfinity) {
   EXPECT_THAT(EvaluateExpr(*DivideExpr(
                   {SharedConstant(std::numeric_limits<double>::infinity()),
-                   SharedConstant(1LL)})),
+                   SharedConstant(static_cast<int64_t>(1LL))})),
               Returns(Value(std::numeric_limits<double>::infinity())));
   EXPECT_THAT(EvaluateExpr(*DivideExpr(
-                  {SharedConstant(1LL),
+                  {SharedConstant(static_cast<int64_t>(1LL)),
                    SharedConstant(std::numeric_limits<double>::infinity())})),
               Returns(Value(0.0)));
 }
@@ -584,10 +624,10 @@ TEST_F(DivideFunctionTest, PositiveInfinity) {
 TEST_F(DivideFunctionTest, NegativeInfinity) {
   EXPECT_THAT(EvaluateExpr(*DivideExpr(
                   {SharedConstant(-std::numeric_limits<double>::infinity()),
-                   SharedConstant(1LL)})),
+                   SharedConstant(static_cast<int64_t>(1LL))})),
               Returns(Value(-std::numeric_limits<double>::infinity())));
   EXPECT_THAT(EvaluateExpr(*DivideExpr(
-                  {SharedConstant(1LL),
+                  {SharedConstant(static_cast<int64_t>(1LL)),
                    SharedConstant(-std::numeric_limits<double>::infinity())})),
               Returns(Value(-0.0)));  // Note: -0.0
 }
@@ -607,7 +647,8 @@ TEST_F(DivideFunctionTest, PositiveInfinityNegativeInfinityReturnsNan) {
 
 TEST_F(ModFunctionTest, DivisorZeroThrowsError) {
   EXPECT_THAT(
-      EvaluateExpr(*ModExpr({SharedConstant(42LL), SharedConstant(0LL)})),
+      EvaluateExpr(*ModExpr({SharedConstant(static_cast<int64_t>(42LL)),
+                             SharedConstant(static_cast<int64_t>(0LL))})),
       ReturnsError());
   // Note: C++ doesn't distinguish -0LL from 0LL
   // EXPECT_TRUE(AssertResultEquals(
@@ -625,7 +666,8 @@ TEST_F(ModFunctionTest, DivisorZeroThrowsError) {
 
 TEST_F(ModFunctionTest, DividendZeroReturnsZero) {
   EXPECT_THAT(
-      EvaluateExpr(*ModExpr({SharedConstant(0LL), SharedConstant(42LL)})),
+      EvaluateExpr(*ModExpr({SharedConstant(static_cast<int64_t>(0LL)),
+                             SharedConstant(static_cast<int64_t>(42LL))})),
       Returns(Value(0LL)));
   // Note: C++ doesn't distinguish -0LL from 0LL
   // EXPECT_THAT(
@@ -642,25 +684,29 @@ TEST_F(ModFunctionTest, DividendZeroReturnsZero) {
 
 TEST_F(ModFunctionTest, LongPositivePositive) {
   EXPECT_THAT(
-      EvaluateExpr(*ModExpr({SharedConstant(10LL), SharedConstant(3LL)})),
+      EvaluateExpr(*ModExpr({SharedConstant(static_cast<int64_t>(10LL)),
+                             SharedConstant(static_cast<int64_t>(3LL))})),
       Returns(Value(1LL)));
 }
 
 TEST_F(ModFunctionTest, LongNegativeNegative) {
   EXPECT_THAT(
-      EvaluateExpr(*ModExpr({SharedConstant(-10LL), SharedConstant(-3LL)})),
+      EvaluateExpr(*ModExpr({SharedConstant(static_cast<int64_t>(-10LL)),
+                             SharedConstant(static_cast<int64_t>(-3LL))})),
       Returns(Value(-1LL)));  // C++ % behavior
 }
 
 TEST_F(ModFunctionTest, LongPositiveNegative) {
   EXPECT_THAT(
-      EvaluateExpr(*ModExpr({SharedConstant(10LL), SharedConstant(-3LL)})),
+      EvaluateExpr(*ModExpr({SharedConstant(static_cast<int64_t>(10LL)),
+                             SharedConstant(static_cast<int64_t>(-3LL))})),
       Returns(Value(1LL)));  // C++ % behavior
 }
 
 TEST_F(ModFunctionTest, LongNegativePositive) {
   EXPECT_THAT(
-      EvaluateExpr(*ModExpr({SharedConstant(-10LL), SharedConstant(3LL)})),
+      EvaluateExpr(*ModExpr({SharedConstant(static_cast<int64_t>(-10LL)),
+                             SharedConstant(static_cast<int64_t>(3LL))})),
       Returns(Value(-1LL)));  // C++ % behavior
 }
 
@@ -694,16 +740,20 @@ TEST_F(ModFunctionTest, DoubleNegativePositive) {
 
 TEST_F(ModFunctionTest, LongPerfectlyDivisible) {
   EXPECT_THAT(
-      EvaluateExpr(*ModExpr({SharedConstant(10LL), SharedConstant(5LL)})),
+      EvaluateExpr(*ModExpr({SharedConstant(static_cast<int64_t>(10LL)),
+                             SharedConstant(static_cast<int64_t>(5LL))})),
       Returns(Value(0LL)));
   EXPECT_THAT(
-      EvaluateExpr(*ModExpr({SharedConstant(-10LL), SharedConstant(5LL)})),
+      EvaluateExpr(*ModExpr({SharedConstant(static_cast<int64_t>(-10LL)),
+                             SharedConstant(static_cast<int64_t>(5LL))})),
       Returns(Value(0LL)));
   EXPECT_THAT(
-      EvaluateExpr(*ModExpr({SharedConstant(10LL), SharedConstant(-5LL)})),
+      EvaluateExpr(*ModExpr({SharedConstant(static_cast<int64_t>(10LL)),
+                             SharedConstant(static_cast<int64_t>(-5LL))})),
       Returns(Value(0LL)));
   EXPECT_THAT(
-      EvaluateExpr(*ModExpr({SharedConstant(-10LL), SharedConstant(-5LL)})),
+      EvaluateExpr(*ModExpr({SharedConstant(static_cast<int64_t>(-10LL)),
+                             SharedConstant(static_cast<int64_t>(-5LL))})),
       Returns(Value(0LL)));
 }
 
@@ -723,11 +773,12 @@ TEST_F(ModFunctionTest, DoublePerfectlyDivisible) {
 }
 
 TEST_F(ModFunctionTest, NonNumericsReturnError) {
+  EXPECT_THAT(EvaluateExpr(*ModExpr({SharedConstant(static_cast<int64_t>(10LL)),
+                                     SharedConstant("1")})),
+              ReturnsError());
   EXPECT_THAT(
-      EvaluateExpr(*ModExpr({SharedConstant(10LL), SharedConstant("1")})),
-      ReturnsError());
-  EXPECT_THAT(
-      EvaluateExpr(*ModExpr({SharedConstant("1"), SharedConstant(10LL)})),
+      EvaluateExpr(*ModExpr(
+          {SharedConstant("1"), SharedConstant(static_cast<int64_t>(10LL))})),
       ReturnsError());
   EXPECT_THAT(
       EvaluateExpr(*ModExpr({SharedConstant("1"), SharedConstant("1")})),
@@ -736,9 +787,9 @@ TEST_F(ModFunctionTest, NonNumericsReturnError) {
 
 TEST_F(ModFunctionTest, NanNumberReturnNaN) {
   double nan_val = std::numeric_limits<double>::quiet_NaN();
-  EXPECT_THAT(
-      EvaluateExpr(*ModExpr({SharedConstant(1LL), SharedConstant(nan_val)})),
-      Returns(Value(nan_val)));
+  EXPECT_THAT(EvaluateExpr(*ModExpr({SharedConstant(static_cast<int64_t>(1LL)),
+                                     SharedConstant(nan_val)})),
+              Returns(Value(nan_val)));
   EXPECT_THAT(
       EvaluateExpr(*ModExpr({SharedConstant(1.0), SharedConstant(nan_val)})),
       Returns(Value(nan_val)));
@@ -761,7 +812,7 @@ TEST_F(ModFunctionTest, NanNotNumberTypeReturnError) {
 
 TEST_F(ModFunctionTest, NumberPosInfinityReturnSelf) {
   EXPECT_THAT(EvaluateExpr(*ModExpr(
-                  {SharedConstant(1LL),
+                  {SharedConstant(static_cast<int64_t>(1LL)),
                    SharedConstant(std::numeric_limits<double>::infinity())})),
               Returns(Value(1.0)));  // fmod(1, inf) -> 1
   EXPECT_THAT(EvaluateExpr(*ModExpr(
@@ -777,7 +828,7 @@ TEST_F(ModFunctionTest, NumberPosInfinityReturnSelf) {
 TEST_F(ModFunctionTest, PosInfinityNumberReturnNaN) {
   EXPECT_THAT(EvaluateExpr(*ModExpr(
                   {SharedConstant(std::numeric_limits<double>::infinity()),
-                   SharedConstant(1LL)})),
+                   SharedConstant(static_cast<int64_t>(1LL))})),
               Returns(Value(std::numeric_limits<double>::quiet_NaN())));
   EXPECT_THAT(EvaluateExpr(*ModExpr(
                   {SharedConstant(std::numeric_limits<double>::infinity()),
@@ -791,7 +842,7 @@ TEST_F(ModFunctionTest, PosInfinityNumberReturnNaN) {
 
 TEST_F(ModFunctionTest, NumberNegInfinityReturnSelf) {
   EXPECT_THAT(EvaluateExpr(*ModExpr(
-                  {SharedConstant(1LL),
+                  {SharedConstant(static_cast<int64_t>(1LL)),
                    SharedConstant(-std::numeric_limits<double>::infinity())})),
               Returns(Value(1.0)));  // fmod(1, -inf) -> 1
   EXPECT_THAT(EvaluateExpr(*ModExpr(
@@ -807,7 +858,7 @@ TEST_F(ModFunctionTest, NumberNegInfinityReturnSelf) {
 TEST_F(ModFunctionTest, NegInfinityNumberReturnNaN) {
   EXPECT_THAT(EvaluateExpr(*ModExpr(
                   {SharedConstant(-std::numeric_limits<double>::infinity()),
-                   SharedConstant(1LL)})),
+                   SharedConstant(static_cast<int64_t>(1LL))})),
               Returns(Value(std::numeric_limits<double>::quiet_NaN())));
   EXPECT_THAT(EvaluateExpr(*ModExpr(
                   {SharedConstant(-std::numeric_limits<double>::infinity()),
diff --git a/Firestore/core/test/unit/core/expressions/array_test.cc b/Firestore/core/test/unit/core/expressions/array_test.cc
index dd77d14c2bb..80e6e1ee892 100644
--- a/Firestore/core/test/unit/core/expressions/array_test.cc
+++ b/Firestore/core/test/unit/core/expressions/array_test.cc
@@ -250,7 +250,8 @@ TEST_F(ArrayContainsTest, ValueNotFoundInArray) {
   auto array_to_search =
       SharedConstant(Array(Value(42LL), Value("matang"), Value(true)));
   EXPECT_THAT(
-      EvaluateExpr(*ArrayContainsExpr({array_to_search, SharedConstant(4LL)})),
+      EvaluateExpr(*ArrayContainsExpr(
+          {array_to_search, SharedConstant(static_cast<int64_t>(4LL))})),
       Returns(Value(false)));
 }
 
@@ -362,7 +363,8 @@ TEST_F(ArrayLengthTest, NotArrayTypeReturnsError) {
   // Test with other non-array types.
   EXPECT_THAT(EvaluateExpr(*ArrayLengthExpr({SharedConstant("notAnArray")})),
               ReturnsError());
-  EXPECT_THAT(EvaluateExpr(*ArrayLengthExpr({SharedConstant(123LL)})),
+  EXPECT_THAT(EvaluateExpr(*ArrayLengthExpr(
+                  {SharedConstant(static_cast<int64_t>(123LL))})),
               ReturnsError());
   EXPECT_THAT(EvaluateExpr(*ArrayLengthExpr({SharedConstant(true)})),
               ReturnsError());
diff --git a/Firestore/core/test/unit/core/expressions/comparison_test.cc b/Firestore/core/test/unit/core/expressions/comparison_test.cc
index c3d4de483fe..141b803941c 100644
--- a/Firestore/core/test/unit/core/expressions/comparison_test.cc
+++ b/Firestore/core/test/unit/core/expressions/comparison_test.cc
@@ -26,7 +26,7 @@
 #include "Firestore/core/src/model/database_id.h"   // For DatabaseId
 #include "Firestore/core/src/model/document_key.h"  // For DocumentKey
 #include "Firestore/core/src/model/value_util.h"  // For value constants like NaNValue, TypeOrder, NullValue, CanonicalId, Equals
-#include "Firestore/core/test/unit/testutil/expression_test_util.h"  // For EvaluateExpr, EqExpr, ComparisonValueTestData, RefConstant etc.
+#include "Firestore/core/test/unit/testutil/expression_test_util.h"  // For EvaluateExpr, EqualExpr, ComparisonValueTestData, RefConstant etc.
 #include "Firestore/core/test/unit/testutil/testutil.h"  // For test helpers like Value, Array, Map, BlobValue, Doc
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
@@ -42,13 +42,13 @@ using model::MutableDocument;  // Used as PipelineInputOutput alias
 using testing::_;
 // Explicitly qualify testutil helpers to avoid ambiguity
 using testutil::ComparisonValueTestData;
-using testutil::EqExpr;
+using testutil::EqualExpr;
 using testutil::EvaluateExpr;
-using testutil::GteExpr;
-using testutil::GtExpr;
-using testutil::LteExpr;
-using testutil::LtExpr;
-using testutil::NeqExpr;
+using testutil::GreaterThanExpr;
+using testutil::GreaterThanOrEqualExpr;
+using testutil::LessThanExpr;
+using testutil::LessThanOrEqualExpr;
+using testutil::NotEqualExpr;
 using testutil::RefConstant;
 using testutil::Returns;
 using testutil::ReturnsError;
@@ -61,8 +61,8 @@ class ComparisonExpressionsTest : public ::testing::Test {
   // Helper moved to expression_test_util.h
 };
 
-// Fixture for Eq function tests
-class EqFunctionTest : public ComparisonExpressionsTest {};
+// Fixture for Equal function tests
+class EqualFunctionTest : public ComparisonExpressionsTest {};
 
 // Helper to get canonical ID for logging, handling potential non-constant exprs
 std::string ExprId(const std::shared_ptr<Expr>& expr) {
@@ -75,95 +75,95 @@ std::string ExprId(const std::shared_ptr<Expr>& expr) {
   return "<unknown_expr_type>";
 }
 
-TEST_F(EqFunctionTest, EquivalentValuesReturnTrue) {
+TEST_F(EqualFunctionTest, EquivalentValuesReturnTrue) {
   for (const auto& pair : ComparisonValueTestData::EquivalentValues()) {
-    EXPECT_THAT(EvaluateExpr(*EqExpr({pair.first, pair.second})),
+    EXPECT_THAT(EvaluateExpr(*EqualExpr({pair.first, pair.second})),
                 Returns(testutil::Value(true)))
-        << "eq(" << ExprId(pair.first) << ", " << ExprId(pair.second) << ")";
+        << "equal(" << ExprId(pair.first) << ", " << ExprId(pair.second) << ")";
   }
 }
 
-TEST_F(EqFunctionTest, LessThanValuesReturnFalse) {
+TEST_F(EqualFunctionTest, LessThanValuesReturnFalse) {
   for (const auto& pair : ComparisonValueTestData::LessThanValues()) {
-    EXPECT_THAT(EvaluateExpr(*EqExpr({pair.first, pair.second})),
+    EXPECT_THAT(EvaluateExpr(*EqualExpr({pair.first, pair.second})),
                 Returns(testutil::Value(false)))
-        << "eq(" << ExprId(pair.first) << ", " << ExprId(pair.second) << ")";
+        << "equal(" << ExprId(pair.first) << ", " << ExprId(pair.second) << ")";
   }
 }
 
-TEST_F(EqFunctionTest, GreaterThanValuesReturnFalse) {
+TEST_F(EqualFunctionTest, GreaterThanValuesReturnFalse) {
   for (const auto& pair : ComparisonValueTestData::GreaterThanValues()) {
-    EXPECT_THAT(EvaluateExpr(*EqExpr({pair.first, pair.second})),
+    EXPECT_THAT(EvaluateExpr(*EqualExpr({pair.first, pair.second})),
                 Returns(testutil::Value(false)))
-        << "eq(" << ExprId(pair.first) << ", " << ExprId(pair.second) << ")";
+        << "equal(" << ExprId(pair.first) << ", " << ExprId(pair.second) << ")";
   }
 }
 
-TEST_F(EqFunctionTest, MixedTypeValuesReturnFalse) {
+TEST_F(EqualFunctionTest, MixedTypeValuesReturnFalse) {
   for (const auto& pair : ComparisonValueTestData::MixedTypeValues()) {
-    EXPECT_THAT(EvaluateExpr(*EqExpr({pair.first, pair.second})),
+    EXPECT_THAT(EvaluateExpr(*EqualExpr({pair.first, pair.second})),
                 Returns(testutil::Value(false)))
-        << "eq(" << ExprId(pair.first) << ", " << ExprId(pair.second) << ")";
+        << "equal(" << ExprId(pair.first) << ", " << ExprId(pair.second) << ")";
   }
 }
 
-// --- Specific Eq Tests (Null, NaN, Missing, Error) ---
+// --- Specific Equal Tests (Null, NaN, Missing, Error) ---
 
-// Fixture for Neq function tests
-class NeqFunctionTest : public ComparisonExpressionsTest {};
+// Fixture for NotEqual function tests
+class NotEqualFunctionTest : public ComparisonExpressionsTest {};
 
-// Fixture for Lt function tests
-class LtFunctionTest : public ComparisonExpressionsTest {};
+// Fixture for LessThan function tests
+class LessThanFunctionTest : public ComparisonExpressionsTest {};
 
-// Fixture for Lte function tests
-class LteFunctionTest : public ComparisonExpressionsTest {};
+// Fixture for LessThanOrEqual function tests
+class LessThanOrEqualFunctionTest : public ComparisonExpressionsTest {};
 
-// Fixture for Gt function tests
-class GtFunctionTest : public ComparisonExpressionsTest {};
+// Fixture for GreaterThan function tests
+class GreaterThanFunctionTest : public ComparisonExpressionsTest {};
 
-// Fixture for Gte function tests
-class GteFunctionTest : public ComparisonExpressionsTest {};
+// Fixture for GreaterThanOrEqual function tests
+class GreaterThanOrEqualFunctionTest : public ComparisonExpressionsTest {};
 
-// --- Eq (==) Tests ---
+// --- Equal (==) Tests ---
 
-TEST_F(EqFunctionTest, NullEqualsNullReturnsNull) {
-  EXPECT_THAT(EvaluateExpr(*EqExpr({SharedConstant(model::NullValue()),
-                                    SharedConstant(model::NullValue())})),
+TEST_F(EqualFunctionTest, NullEqualsNullReturnsNull) {
+  EXPECT_THAT(EvaluateExpr(*EqualExpr({SharedConstant(model::NullValue()),
+                                       SharedConstant(model::NullValue())})),
               ReturnsNull());
 }
 
 // Corresponds to eq.null_any_returnsNull in typescript
-TEST_F(EqFunctionTest, NullOperandReturnsNull) {
+TEST_F(EqualFunctionTest, NullOperandReturnsNull) {
   for (const auto& val :
        ComparisonValueTestData::AllSupportedComparableValues()) {
     EXPECT_THAT(
-        EvaluateExpr(*EqExpr({SharedConstant(model::NullValue()), val})),
+        EvaluateExpr(*EqualExpr({SharedConstant(model::NullValue()), val})),
         ReturnsNull())
-        << "eq(null, " << ExprId(val) << ")";
+        << "equal(null, " << ExprId(val) << ")";
     EXPECT_THAT(
-        EvaluateExpr(*EqExpr({val, SharedConstant(model::NullValue())})),
+        EvaluateExpr(*EqualExpr({val, SharedConstant(model::NullValue())})),
         ReturnsNull())
-        << "eq(" << ExprId(val) << ", null)";
+        << "equal(" << ExprId(val) << ", null)";
   }
   EXPECT_THAT(
-      EvaluateExpr(*EqExpr({SharedConstant(model::NullValue()),
-                            std::make_shared<api::Field>("nonexistent")})),
+      EvaluateExpr(*EqualExpr({SharedConstant(model::NullValue()),
+                               std::make_shared<api::Field>("nonexistent")})),
       ReturnsError());
 }
 
 // Corresponds to eq.nan tests in typescript
-TEST_F(EqFunctionTest, NaNComparisonsReturnFalse) {
+TEST_F(EqualFunctionTest, NaNComparisonsReturnFalse) {
   auto nan_expr = SharedConstant(std::numeric_limits<double>::quiet_NaN());
-  EXPECT_THAT(EvaluateExpr(*EqExpr({nan_expr, nan_expr})),
+  EXPECT_THAT(EvaluateExpr(*EqualExpr({nan_expr, nan_expr})),
               Returns(testutil::Value(false)));  // NaN == NaN is false
 
   for (const auto& num_val : ComparisonValueTestData::NumericValues()) {
-    EXPECT_THAT(EvaluateExpr(*EqExpr({nan_expr, num_val})),
+    EXPECT_THAT(EvaluateExpr(*EqualExpr({nan_expr, num_val})),
                 Returns(testutil::Value(false)))
-        << "eq(NaN, " << ExprId(num_val) << ")";
-    EXPECT_THAT(EvaluateExpr(*EqExpr({num_val, nan_expr})),
+        << "equal(NaN, " << ExprId(num_val) << ")";
+    EXPECT_THAT(EvaluateExpr(*EqualExpr({num_val, nan_expr})),
                 Returns(testutil::Value(false)))
-        << "eq(" << ExprId(num_val) << ", NaN)";
+        << "equal(" << ExprId(num_val) << ", NaN)";
   }
 
   for (const auto& other_val :
@@ -176,23 +176,23 @@ TEST_F(EqFunctionTest, NaNComparisonsReturnFalse) {
       }
     }
     if (!is_numeric) {
-      EXPECT_THAT(EvaluateExpr(*EqExpr({nan_expr, other_val})),
+      EXPECT_THAT(EvaluateExpr(*EqualExpr({nan_expr, other_val})),
                   Returns(testutil::Value(false)))
-          << "eq(NaN, " << ExprId(other_val) << ")";
-      EXPECT_THAT(EvaluateExpr(*EqExpr({other_val, nan_expr})),
+          << "equal(NaN, " << ExprId(other_val) << ")";
+      EXPECT_THAT(EvaluateExpr(*EqualExpr({other_val, nan_expr})),
                   Returns(testutil::Value(false)))
-          << "eq(" << ExprId(other_val) << ", NaN)";
+          << "equal(" << ExprId(other_val) << ", NaN)";
     }
   }
 
+  EXPECT_THAT(EvaluateExpr(*EqualExpr(
+                  {SharedConstant(testutil::Array(testutil::Value(
+                       std::numeric_limits<double>::quiet_NaN()))),
+                   SharedConstant(testutil::Array(testutil::Value(
+                       std::numeric_limits<double>::quiet_NaN())))})),
+              Returns(testutil::Value(false)));
   EXPECT_THAT(
-      EvaluateExpr(*EqExpr({SharedConstant(testutil::Array(testutil::Value(
-                                std::numeric_limits<double>::quiet_NaN()))),
-                            SharedConstant(testutil::Array(testutil::Value(
-                                std::numeric_limits<double>::quiet_NaN())))})),
-      Returns(testutil::Value(false)));
-  EXPECT_THAT(
-      EvaluateExpr(*EqExpr(
+      EvaluateExpr(*EqualExpr(
           {SharedConstant(testutil::Map(
                "foo",
                testutil::Value(std::numeric_limits<double>::quiet_NaN()))),
@@ -204,147 +204,153 @@ TEST_F(EqFunctionTest, NaNComparisonsReturnFalse) {
 
 // Corresponds to eq.nullInArray_equality / eq.nullInMap_equality /
 // eq.null_missingInMap_equality
-TEST_F(EqFunctionTest, NullContainerEquality) {
+TEST_F(EqualFunctionTest, NullContainerEquality) {
   auto null_array = SharedConstant(testutil::Array(testutil::Value(nullptr)));
-  EXPECT_THAT(EvaluateExpr(*EqExpr({null_array, SharedConstant(1LL)})),
+  EXPECT_THAT(EvaluateExpr(*EqualExpr(
+                  {null_array, SharedConstant(static_cast<int64_t>(1LL))})),
               Returns(testutil::Value(false)));
-  EXPECT_THAT(EvaluateExpr(*EqExpr({null_array, SharedConstant("1")})),
+  EXPECT_THAT(EvaluateExpr(*EqualExpr({null_array, SharedConstant("1")})),
               Returns(testutil::Value(false)));
-  EXPECT_THAT(
-      EvaluateExpr(*EqExpr({null_array, SharedConstant(model::NullValue())})),
-      ReturnsNull());
-  EXPECT_THAT(EvaluateExpr(*EqExpr(
+  EXPECT_THAT(EvaluateExpr(
+                  *EqualExpr({null_array, SharedConstant(model::NullValue())})),
+              ReturnsNull());
+  EXPECT_THAT(EvaluateExpr(*EqualExpr(
                   {null_array,
                    SharedConstant(std::numeric_limits<double>::quiet_NaN())})),
               Returns(testutil::Value(false)));
   EXPECT_THAT(
-      EvaluateExpr(*EqExpr({null_array, SharedConstant(testutil::Array())})),
+      EvaluateExpr(*EqualExpr({null_array, SharedConstant(testutil::Array())})),
       Returns(testutil::Value(false)));
   EXPECT_THAT(
-      EvaluateExpr(*EqExpr(
+      EvaluateExpr(*EqualExpr(
           {null_array, SharedConstant(testutil::Array(testutil::Value(
                            std::numeric_limits<double>::quiet_NaN())))})),
       ReturnsNull());
   EXPECT_THAT(
-      EvaluateExpr(*EqExpr({null_array, SharedConstant(testutil::Array(
-                                            testutil::Value(nullptr)))})),
+      EvaluateExpr(*EqualExpr({null_array, SharedConstant(testutil::Array(
+                                               testutil::Value(nullptr)))})),
       ReturnsNull());
 
   auto null_map =
       SharedConstant(testutil::Map("foo", testutil::Value(nullptr)));
+  EXPECT_THAT(EvaluateExpr(*EqualExpr(
+                  {null_map, SharedConstant(testutil::Map(
+                                 "foo", testutil::Value(nullptr)))})),
+              ReturnsNull());
   EXPECT_THAT(
-      EvaluateExpr(*EqExpr({null_map, SharedConstant(testutil::Map(
-                                          "foo", testutil::Value(nullptr)))})),
-      ReturnsNull());
-  EXPECT_THAT(
-      EvaluateExpr(*EqExpr({null_map, SharedConstant(testutil::Map())})),
+      EvaluateExpr(*EqualExpr({null_map, SharedConstant(testutil::Map())})),
       Returns(testutil::Value(false)));
 }
 
 // Corresponds to eq.error_ tests
-TEST_F(EqFunctionTest, ErrorHandling) {
+TEST_F(EqualFunctionTest, ErrorHandling) {
   auto error_expr = std::make_shared<api::Field>("a.b");
   auto non_map_input = testutil::Doc("coll/doc", 1, testutil::Map("a", 123));
 
   for (const auto& val :
        ComparisonValueTestData::AllSupportedComparableValues()) {
-    EXPECT_THAT(EvaluateExpr(*EqExpr({error_expr, val}), non_map_input),
+    EXPECT_THAT(EvaluateExpr(*EqualExpr({error_expr, val}), non_map_input),
                 ReturnsError());
-    EXPECT_THAT(EvaluateExpr(*EqExpr({val, error_expr}), non_map_input),
+    EXPECT_THAT(EvaluateExpr(*EqualExpr({val, error_expr}), non_map_input),
                 ReturnsError());
   }
-  EXPECT_THAT(EvaluateExpr(*EqExpr({error_expr, error_expr}), non_map_input),
+  EXPECT_THAT(EvaluateExpr(*EqualExpr({error_expr, error_expr}), non_map_input),
               ReturnsError());
   EXPECT_THAT(
-      EvaluateExpr(*EqExpr({error_expr, SharedConstant(model::NullValue())}),
+      EvaluateExpr(*EqualExpr({error_expr, SharedConstant(model::NullValue())}),
                    non_map_input),
       ReturnsError());
 }
 
-TEST_F(EqFunctionTest, MissingFieldReturnsError) {
-  EXPECT_THAT(EvaluateExpr(*EqExpr({std::make_shared<api::Field>("nonexistent"),
-                                    SharedConstant(testutil::Value(1LL))})),
-              ReturnsError());
+TEST_F(EqualFunctionTest, MissingFieldReturnsError) {
   EXPECT_THAT(
-      EvaluateExpr(*EqExpr({SharedConstant(testutil::Value(1LL)),
-                            std::make_shared<api::Field>("nonexistent")})),
+      EvaluateExpr(*EqualExpr({std::make_shared<api::Field>("nonexistent"),
+                               SharedConstant(testutil::Value(1LL))})),
+      ReturnsError());
+  EXPECT_THAT(
+      EvaluateExpr(*EqualExpr({SharedConstant(testutil::Value(1LL)),
+                               std::make_shared<api::Field>("nonexistent")})),
       ReturnsError());
 }
 
-// --- Neq (!=) Tests ---
+// --- NotEqual (!=) Tests ---
 
-TEST_F(NeqFunctionTest, EquivalentValuesReturnFalse) {
+TEST_F(NotEqualFunctionTest, EquivalentValuesReturnFalse) {
   for (const auto& pair : ComparisonValueTestData::EquivalentValues()) {
-    EXPECT_THAT(EvaluateExpr(*NeqExpr({pair.first, pair.second})),
+    EXPECT_THAT(EvaluateExpr(*NotEqualExpr({pair.first, pair.second})),
                 Returns(testutil::Value(false)))
-        << "neq(" << ExprId(pair.first) << ", " << ExprId(pair.second) << ")";
+        << "not_equal(" << ExprId(pair.first) << ", " << ExprId(pair.second)
+        << ")";
   }
 }
 
-TEST_F(NeqFunctionTest, LessThanValuesReturnTrue) {
+TEST_F(NotEqualFunctionTest, LessThanValuesReturnTrue) {
   for (const auto& pair : ComparisonValueTestData::LessThanValues()) {
-    EXPECT_THAT(EvaluateExpr(*NeqExpr({pair.first, pair.second})),
+    EXPECT_THAT(EvaluateExpr(*NotEqualExpr({pair.first, pair.second})),
                 Returns(testutil::Value(true)))
-        << "neq(" << ExprId(pair.first) << ", " << ExprId(pair.second) << ")";
+        << "not_equal(" << ExprId(pair.first) << ", " << ExprId(pair.second)
+        << ")";
   }
 }
 
-TEST_F(NeqFunctionTest, GreaterThanValuesReturnTrue) {
+TEST_F(NotEqualFunctionTest, GreaterThanValuesReturnTrue) {
   for (const auto& pair : ComparisonValueTestData::GreaterThanValues()) {
-    EXPECT_THAT(EvaluateExpr(*NeqExpr({pair.first, pair.second})),
+    EXPECT_THAT(EvaluateExpr(*NotEqualExpr({pair.first, pair.second})),
                 Returns(testutil::Value(true)))
-        << "neq(" << ExprId(pair.first) << ", " << ExprId(pair.second) << ")";
+        << "not_equal(" << ExprId(pair.first) << ", " << ExprId(pair.second)
+        << ")";
   }
 }
 
-TEST_F(NeqFunctionTest, MixedTypeValuesReturnTrue) {
+TEST_F(NotEqualFunctionTest, MixedTypeValuesReturnTrue) {
   for (const auto& pair : ComparisonValueTestData::MixedTypeValues()) {
-    EXPECT_THAT(EvaluateExpr(*NeqExpr({pair.first, pair.second})),
+    EXPECT_THAT(EvaluateExpr(*NotEqualExpr({pair.first, pair.second})),
                 Returns(testutil::Value(true)))
-        << "neq(" << ExprId(pair.first) << ", " << ExprId(pair.second) << ")";
+        << "not_equal(" << ExprId(pair.first) << ", " << ExprId(pair.second)
+        << ")";
   }
 }
 
-// --- Specific Neq Tests ---
+// --- Specific NotEqual Tests ---
 
-TEST_F(NeqFunctionTest, NullNotEqualsNullReturnsNull) {
-  EXPECT_THAT(EvaluateExpr(*NeqExpr({SharedConstant(model::NullValue()),
-                                     SharedConstant(model::NullValue())})),
+TEST_F(NotEqualFunctionTest, NullNotEqualsNullReturnsNull) {
+  EXPECT_THAT(EvaluateExpr(*NotEqualExpr({SharedConstant(model::NullValue()),
+                                          SharedConstant(model::NullValue())})),
               ReturnsNull());
 }
 
 // Corresponds to neq.null_any_returnsNull
-TEST_F(NeqFunctionTest, NullOperandReturnsNull) {
+TEST_F(NotEqualFunctionTest, NullOperandReturnsNull) {
   for (const auto& val :
        ComparisonValueTestData::AllSupportedComparableValues()) {
     EXPECT_THAT(
-        EvaluateExpr(*NeqExpr({SharedConstant(model::NullValue()), val})),
+        EvaluateExpr(*NotEqualExpr({SharedConstant(model::NullValue()), val})),
         ReturnsNull())
-        << "neq(null, " << ExprId(val) << ")";
+        << "not_equal(null, " << ExprId(val) << ")";
     EXPECT_THAT(
-        EvaluateExpr(*NeqExpr({val, SharedConstant(model::NullValue())})),
+        EvaluateExpr(*NotEqualExpr({val, SharedConstant(model::NullValue())})),
         ReturnsNull())
-        << "neq(" << ExprId(val) << ", null)";
+        << "not_equal(" << ExprId(val) << ", null)";
   }
-  EXPECT_THAT(
-      EvaluateExpr(*NeqExpr({SharedConstant(model::NullValue()),
-                             std::make_shared<api::Field>("nonexistent")})),
-      ReturnsError());
+  EXPECT_THAT(EvaluateExpr(
+                  *NotEqualExpr({SharedConstant(model::NullValue()),
+                                 std::make_shared<api::Field>("nonexistent")})),
+              ReturnsError());
 }
 
 // Corresponds to neq.nan tests
-TEST_F(NeqFunctionTest, NaNComparisonsReturnTrue) {
+TEST_F(NotEqualFunctionTest, NaNComparisonsReturnTrue) {
   auto nan_expr = SharedConstant(std::numeric_limits<double>::quiet_NaN());
-  EXPECT_THAT(EvaluateExpr(*NeqExpr({nan_expr, nan_expr})),
+  EXPECT_THAT(EvaluateExpr(*NotEqualExpr({nan_expr, nan_expr})),
               Returns(testutil::Value(true)));  // NaN != NaN is true
 
   for (const auto& num_val : ComparisonValueTestData::NumericValues()) {
-    EXPECT_THAT(EvaluateExpr(*NeqExpr({nan_expr, num_val})),
+    EXPECT_THAT(EvaluateExpr(*NotEqualExpr({nan_expr, num_val})),
                 Returns(testutil::Value(true)))
-        << "neq(NaN, " << ExprId(num_val) << ")";
-    EXPECT_THAT(EvaluateExpr(*NeqExpr({num_val, nan_expr})),
+        << "not_equal(NaN, " << ExprId(num_val) << ")";
+    EXPECT_THAT(EvaluateExpr(*NotEqualExpr({num_val, nan_expr})),
                 Returns(testutil::Value(true)))
-        << "neq(" << ExprId(num_val) << ", NaN)";
+        << "not_equal(" << ExprId(num_val) << ", NaN)";
   }
 
   for (const auto& other_val :
@@ -357,23 +363,23 @@ TEST_F(NeqFunctionTest, NaNComparisonsReturnTrue) {
       }
     }
     if (!is_numeric) {
-      EXPECT_THAT(EvaluateExpr(*NeqExpr({nan_expr, other_val})),
+      EXPECT_THAT(EvaluateExpr(*NotEqualExpr({nan_expr, other_val})),
                   Returns(testutil::Value(true)))
-          << "neq(NaN, " << ExprId(other_val) << ")";
-      EXPECT_THAT(EvaluateExpr(*NeqExpr({other_val, nan_expr})),
+          << "not_equal(NaN, " << ExprId(other_val) << ")";
+      EXPECT_THAT(EvaluateExpr(*NotEqualExpr({other_val, nan_expr})),
                   Returns(testutil::Value(true)))
-          << "neq(" << ExprId(other_val) << ", NaN)";
+          << "not_equal(" << ExprId(other_val) << ", NaN)";
     }
   }
 
+  EXPECT_THAT(EvaluateExpr(*NotEqualExpr(
+                  {SharedConstant(testutil::Array(testutil::Value(
+                       std::numeric_limits<double>::quiet_NaN()))),
+                   SharedConstant(testutil::Array(testutil::Value(
+                       std::numeric_limits<double>::quiet_NaN())))})),
+              Returns(testutil::Value(true)));
   EXPECT_THAT(
-      EvaluateExpr(*NeqExpr({SharedConstant(testutil::Array(testutil::Value(
-                                 std::numeric_limits<double>::quiet_NaN()))),
-                             SharedConstant(testutil::Array(testutil::Value(
-                                 std::numeric_limits<double>::quiet_NaN())))})),
-      Returns(testutil::Value(true)));
-  EXPECT_THAT(
-      EvaluateExpr(*NeqExpr(
+      EvaluateExpr(*NotEqualExpr(
           {SharedConstant(testutil::Map(
                "foo",
                testutil::Value(std::numeric_limits<double>::quiet_NaN()))),
@@ -384,110 +390,115 @@ TEST_F(NeqFunctionTest, NaNComparisonsReturnTrue) {
 }
 
 // Corresponds to neq.error_ tests
-TEST_F(NeqFunctionTest, ErrorHandling) {
+TEST_F(NotEqualFunctionTest, ErrorHandling) {
   auto error_expr = std::make_shared<api::Field>("a.b");
   auto non_map_input = testutil::Doc("coll/doc", 1, testutil::Map("a", 123));
 
   for (const auto& val :
        ComparisonValueTestData::AllSupportedComparableValues()) {
-    EXPECT_THAT(EvaluateExpr(*NeqExpr({error_expr, val}), non_map_input),
+    EXPECT_THAT(EvaluateExpr(*NotEqualExpr({error_expr, val}), non_map_input),
                 ReturnsError());
-    EXPECT_THAT(EvaluateExpr(*NeqExpr({val, error_expr}), non_map_input),
+    EXPECT_THAT(EvaluateExpr(*NotEqualExpr({val, error_expr}), non_map_input),
                 ReturnsError());
   }
-  EXPECT_THAT(EvaluateExpr(*NeqExpr({error_expr, error_expr}), non_map_input),
-              ReturnsError());
   EXPECT_THAT(
-      EvaluateExpr(*NeqExpr({error_expr, SharedConstant(model::NullValue())}),
-                   non_map_input),
+      EvaluateExpr(*NotEqualExpr({error_expr, error_expr}), non_map_input),
       ReturnsError());
+  EXPECT_THAT(EvaluateExpr(*NotEqualExpr({error_expr,
+                                          SharedConstant(model::NullValue())}),
+                           non_map_input),
+              ReturnsError());
 }
 
-TEST_F(NeqFunctionTest, MissingFieldReturnsError) {
+TEST_F(NotEqualFunctionTest, MissingFieldReturnsError) {
   EXPECT_THAT(
-      EvaluateExpr(*NeqExpr({std::make_shared<api::Field>("nonexistent"),
-                             SharedConstant(testutil::Value(1LL))})),
-      ReturnsError());
-  EXPECT_THAT(
-      EvaluateExpr(*NeqExpr({SharedConstant(testutil::Value(1LL)),
-                             std::make_shared<api::Field>("nonexistent")})),
+      EvaluateExpr(*NotEqualExpr({std::make_shared<api::Field>("nonexistent"),
+                                  SharedConstant(testutil::Value(1LL))})),
       ReturnsError());
+  EXPECT_THAT(EvaluateExpr(
+                  *NotEqualExpr({SharedConstant(testutil::Value(1LL)),
+                                 std::make_shared<api::Field>("nonexistent")})),
+              ReturnsError());
 }
 
-// --- Lt (<) Tests ---
+// --- LessThan (<) Tests ---
 
-TEST_F(LtFunctionTest, EquivalentValuesReturnFalse) {
+TEST_F(LessThanFunctionTest, EquivalentValuesReturnFalse) {
   for (const auto& pair : ComparisonValueTestData::EquivalentValues()) {
-    EXPECT_THAT(EvaluateExpr(*LtExpr({pair.first, pair.second})),
+    EXPECT_THAT(EvaluateExpr(*LessThanExpr({pair.first, pair.second})),
                 Returns(testutil::Value(false)))
-        << "lt(" << ExprId(pair.first) << ", " << ExprId(pair.second) << ")";
+        << "less_than(" << ExprId(pair.first) << ", " << ExprId(pair.second)
+        << ")";
   }
 }
 
-TEST_F(LtFunctionTest, LessThanValuesReturnTrue) {
+TEST_F(LessThanFunctionTest, LessThanValuesReturnTrue) {
   for (const auto& pair : ComparisonValueTestData::LessThanValues()) {
     auto left_const =
         std::dynamic_pointer_cast<const api::Constant>(pair.first);
     auto right_const =
         std::dynamic_pointer_cast<const api::Constant>(pair.second);
     // Use model::Equals to check for non-equal comparable pairs
-    EXPECT_THAT(EvaluateExpr(*LtExpr({pair.first, pair.second})),
+    EXPECT_THAT(EvaluateExpr(*LessThanExpr({pair.first, pair.second})),
                 Returns(testutil::Value(true)))
-        << "lt(" << ExprId(pair.first) << ", " << ExprId(pair.second) << ")";
+        << "less_than(" << ExprId(pair.first) << ", " << ExprId(pair.second)
+        << ")";
   }
 }
 
-TEST_F(LtFunctionTest, GreaterThanValuesReturnFalse) {
+TEST_F(LessThanFunctionTest, GreaterThanValuesReturnFalse) {
   for (const auto& pair : ComparisonValueTestData::GreaterThanValues()) {
-    EXPECT_THAT(EvaluateExpr(*LtExpr({pair.first, pair.second})),
+    EXPECT_THAT(EvaluateExpr(*LessThanExpr({pair.first, pair.second})),
                 Returns(testutil::Value(false)))
-        << "lt(" << ExprId(pair.first) << ", " << ExprId(pair.second) << ")";
+        << "less_than(" << ExprId(pair.first) << ", " << ExprId(pair.second)
+        << ")";
   }
 }
 
-TEST_F(LtFunctionTest, MixedTypeValuesReturnFalse) {
+TEST_F(LessThanFunctionTest, MixedTypeValuesReturnFalse) {
   for (const auto& pair : ComparisonValueTestData::MixedTypeValues()) {
-    EXPECT_THAT(EvaluateExpr(*LtExpr({pair.first, pair.second})),
+    EXPECT_THAT(EvaluateExpr(*LessThanExpr({pair.first, pair.second})),
                 Returns(testutil::Value(false)))
-        << "lt(" << ExprId(pair.first) << ", " << ExprId(pair.second) << ")";
+        << "less_than(" << ExprId(pair.first) << ", " << ExprId(pair.second)
+        << ")";
   }
 }
 
-// --- Specific Lt Tests ---
+// --- Specific LessThan Tests ---
 
-TEST_F(LtFunctionTest, NullOperandReturnsNull) {
+TEST_F(LessThanFunctionTest, NullOperandReturnsNull) {
   for (const auto& val :
        ComparisonValueTestData::AllSupportedComparableValues()) {
     EXPECT_THAT(
-        EvaluateExpr(*LtExpr({SharedConstant(model::NullValue()), val})),
+        EvaluateExpr(*LessThanExpr({SharedConstant(model::NullValue()), val})),
         ReturnsNull())
-        << "lt(null, " << ExprId(val) << ")";
+        << "less_than(null, " << ExprId(val) << ")";
     EXPECT_THAT(
-        EvaluateExpr(*LtExpr({val, SharedConstant(model::NullValue())})),
+        EvaluateExpr(*LessThanExpr({val, SharedConstant(model::NullValue())})),
         ReturnsNull())
-        << "lt(" << ExprId(val) << ", null)";
+        << "less_than(" << ExprId(val) << ", null)";
   }
-  EXPECT_THAT(EvaluateExpr(*LtExpr({SharedConstant(model::NullValue()),
-                                    SharedConstant(model::NullValue())})),
+  EXPECT_THAT(EvaluateExpr(*LessThanExpr({SharedConstant(model::NullValue()),
+                                          SharedConstant(model::NullValue())})),
               ReturnsNull());
-  EXPECT_THAT(
-      EvaluateExpr(*LtExpr({SharedConstant(model::NullValue()),
-                            std::make_shared<api::Field>("nonexistent")})),
-      ReturnsError());
+  EXPECT_THAT(EvaluateExpr(
+                  *LessThanExpr({SharedConstant(model::NullValue()),
+                                 std::make_shared<api::Field>("nonexistent")})),
+              ReturnsError());
 }
 
-TEST_F(LtFunctionTest, NaNComparisonsReturnFalse) {
+TEST_F(LessThanFunctionTest, NaNComparisonsReturnFalse) {
   auto nan_expr = SharedConstant(std::numeric_limits<double>::quiet_NaN());
-  EXPECT_THAT(EvaluateExpr(*LtExpr({nan_expr, nan_expr})),
+  EXPECT_THAT(EvaluateExpr(*LessThanExpr({nan_expr, nan_expr})),
               Returns(testutil::Value(false)));
 
   for (const auto& num_val : ComparisonValueTestData::NumericValues()) {
-    EXPECT_THAT(EvaluateExpr(*LtExpr({nan_expr, num_val})),
+    EXPECT_THAT(EvaluateExpr(*LessThanExpr({nan_expr, num_val})),
                 Returns(testutil::Value(false)))
-        << "lt(NaN, " << ExprId(num_val) << ")";
-    EXPECT_THAT(EvaluateExpr(*LtExpr({num_val, nan_expr})),
+        << "less_than(NaN, " << ExprId(num_val) << ")";
+    EXPECT_THAT(EvaluateExpr(*LessThanExpr({num_val, nan_expr})),
                 Returns(testutil::Value(false)))
-        << "lt(" << ExprId(num_val) << ", NaN)";
+        << "less_than(" << ExprId(num_val) << ", NaN)";
   }
   for (const auto& other_val :
        ComparisonValueTestData::AllSupportedComparableValues()) {
@@ -499,120 +510,127 @@ TEST_F(LtFunctionTest, NaNComparisonsReturnFalse) {
       }
     }
     if (!is_numeric) {
-      EXPECT_THAT(EvaluateExpr(*LtExpr({nan_expr, other_val})),
+      EXPECT_THAT(EvaluateExpr(*LessThanExpr({nan_expr, other_val})),
                   Returns(testutil::Value(false)))
-          << "lt(NaN, " << ExprId(other_val) << ")";
-      EXPECT_THAT(EvaluateExpr(*LtExpr({other_val, nan_expr})),
+          << "less_than(NaN, " << ExprId(other_val) << ")";
+      EXPECT_THAT(EvaluateExpr(*LessThanExpr({other_val, nan_expr})),
                   Returns(testutil::Value(false)))
-          << "lt(" << ExprId(other_val) << ", NaN)";
+          << "less_than(" << ExprId(other_val) << ", NaN)";
     }
   }
-  EXPECT_THAT(
-      EvaluateExpr(*LtExpr({SharedConstant(testutil::Array(testutil::Value(
-                                std::numeric_limits<double>::quiet_NaN()))),
-                            SharedConstant(testutil::Array(testutil::Value(
-                                std::numeric_limits<double>::quiet_NaN())))})),
-      Returns(testutil::Value(false)));
+  EXPECT_THAT(EvaluateExpr(*LessThanExpr(
+                  {SharedConstant(testutil::Array(testutil::Value(
+                       std::numeric_limits<double>::quiet_NaN()))),
+                   SharedConstant(testutil::Array(testutil::Value(
+                       std::numeric_limits<double>::quiet_NaN())))})),
+              Returns(testutil::Value(false)));
 }
 
-TEST_F(LtFunctionTest, ErrorHandling) {
+TEST_F(LessThanFunctionTest, ErrorHandling) {
   auto error_expr = std::make_shared<api::Field>("a.b");
   auto non_map_input = testutil::Doc("coll/doc", 1, testutil::Map("a", 123));
 
   for (const auto& val :
        ComparisonValueTestData::AllSupportedComparableValues()) {
-    EXPECT_THAT(EvaluateExpr(*LtExpr({error_expr, val}), non_map_input),
+    EXPECT_THAT(EvaluateExpr(*LessThanExpr({error_expr, val}), non_map_input),
                 ReturnsError());
-    EXPECT_THAT(EvaluateExpr(*LtExpr({val, error_expr}), non_map_input),
+    EXPECT_THAT(EvaluateExpr(*LessThanExpr({val, error_expr}), non_map_input),
                 ReturnsError());
   }
-  EXPECT_THAT(EvaluateExpr(*LtExpr({error_expr, error_expr}), non_map_input),
-              ReturnsError());
   EXPECT_THAT(
-      EvaluateExpr(*LtExpr({error_expr, SharedConstant(model::NullValue())}),
-                   non_map_input),
+      EvaluateExpr(*LessThanExpr({error_expr, error_expr}), non_map_input),
       ReturnsError());
+  EXPECT_THAT(EvaluateExpr(*LessThanExpr({error_expr,
+                                          SharedConstant(model::NullValue())}),
+                           non_map_input),
+              ReturnsError());
 }
 
-TEST_F(LtFunctionTest, MissingFieldReturnsError) {
-  EXPECT_THAT(EvaluateExpr(*LtExpr({std::make_shared<api::Field>("nonexistent"),
-                                    SharedConstant(testutil::Value(1LL))})),
-              ReturnsError());
+TEST_F(LessThanFunctionTest, MissingFieldReturnsError) {
   EXPECT_THAT(
-      EvaluateExpr(*LtExpr({SharedConstant(testutil::Value(1LL)),
-                            std::make_shared<api::Field>("nonexistent")})),
+      EvaluateExpr(*LessThanExpr({std::make_shared<api::Field>("nonexistent"),
+                                  SharedConstant(testutil::Value(1LL))})),
       ReturnsError());
+  EXPECT_THAT(EvaluateExpr(
+                  *LessThanExpr({SharedConstant(testutil::Value(1LL)),
+                                 std::make_shared<api::Field>("nonexistent")})),
+              ReturnsError());
 }
 
-// --- Lte (<=) Tests ---
+// --- LessThanOrEqual (<=) Tests ---
 
-TEST_F(LteFunctionTest, EquivalentValuesReturnTrue) {
+TEST_F(LessThanOrEqualFunctionTest, EquivalentValuesReturnTrue) {
   for (const auto& pair : ComparisonValueTestData::EquivalentValues()) {
-    EXPECT_THAT(EvaluateExpr(*LteExpr({pair.first, pair.second})),
+    EXPECT_THAT(EvaluateExpr(*LessThanOrEqualExpr({pair.first, pair.second})),
                 Returns(testutil::Value(true)))
-        << "lte(" << ExprId(pair.first) << ", " << ExprId(pair.second) << ")";
+        << "less_than_or_equal(" << ExprId(pair.first) << ", "
+        << ExprId(pair.second) << ")";
   }
 }
 
-TEST_F(LteFunctionTest, LessThanValuesReturnTrue) {
+TEST_F(LessThanOrEqualFunctionTest, LessThanValuesReturnTrue) {
   for (const auto& pair : ComparisonValueTestData::LessThanValues()) {
-    EXPECT_THAT(EvaluateExpr(*LteExpr({pair.first, pair.second})),
+    EXPECT_THAT(EvaluateExpr(*LessThanOrEqualExpr({pair.first, pair.second})),
                 Returns(testutil::Value(true)))
-        << "lte(" << ExprId(pair.first) << ", " << ExprId(pair.second) << ")";
+        << "less_than_or_equal(" << ExprId(pair.first) << ", "
+        << ExprId(pair.second) << ")";
   }
 }
 
-TEST_F(LteFunctionTest, GreaterThanValuesReturnFalse) {
+TEST_F(LessThanOrEqualFunctionTest, GreaterThanValuesReturnFalse) {
   for (const auto& pair : ComparisonValueTestData::GreaterThanValues()) {
-    EXPECT_THAT(EvaluateExpr(*LteExpr({pair.first, pair.second})),
+    EXPECT_THAT(EvaluateExpr(*LessThanOrEqualExpr({pair.first, pair.second})),
                 Returns(testutil::Value(false)))
-        << "lte(" << ExprId(pair.first) << ", " << ExprId(pair.second) << ")";
+        << "less_than_or_equal(" << ExprId(pair.first) << ", "
+        << ExprId(pair.second) << ")";
   }
 }
 
-TEST_F(LteFunctionTest, MixedTypeValuesReturnFalse) {
+TEST_F(LessThanOrEqualFunctionTest, MixedTypeValuesReturnFalse) {
   for (const auto& pair : ComparisonValueTestData::MixedTypeValues()) {
-    EXPECT_THAT(EvaluateExpr(*LteExpr({pair.first, pair.second})),
+    EXPECT_THAT(EvaluateExpr(*LessThanOrEqualExpr({pair.first, pair.second})),
                 Returns(testutil::Value(false)))
-        << "lte(" << ExprId(pair.first) << ", " << ExprId(pair.second) << ")";
+        << "less_than_or_equal(" << ExprId(pair.first) << ", "
+        << ExprId(pair.second) << ")";
   }
 }
 
-// --- Specific Lte Tests ---
+// --- Specific LessThanOrEqual Tests ---
 
-TEST_F(LteFunctionTest, NullOperandReturnsNull) {
+TEST_F(LessThanOrEqualFunctionTest, NullOperandReturnsNull) {
   for (const auto& val :
        ComparisonValueTestData::AllSupportedComparableValues()) {
-    EXPECT_THAT(
-        EvaluateExpr(*LteExpr({SharedConstant(model::NullValue()), val})),
-        ReturnsNull())
-        << "lte(null, " << ExprId(val) << ")";
-    EXPECT_THAT(
-        EvaluateExpr(*LteExpr({val, SharedConstant(model::NullValue())})),
-        ReturnsNull())
-        << "lte(" << ExprId(val) << ", null)";
-  }
-  EXPECT_THAT(EvaluateExpr(*LteExpr({SharedConstant(model::NullValue()),
-                                     SharedConstant(model::NullValue())})),
-              ReturnsNull());
-  EXPECT_THAT(
-      EvaluateExpr(*LteExpr({SharedConstant(model::NullValue()),
-                             std::make_shared<api::Field>("nonexistent")})),
-      ReturnsError());
+    EXPECT_THAT(EvaluateExpr(*LessThanOrEqualExpr(
+                    {SharedConstant(model::NullValue()), val})),
+                ReturnsNull())
+        << "less_than_or_equal(null, " << ExprId(val) << ")";
+    EXPECT_THAT(EvaluateExpr(*LessThanOrEqualExpr(
+                    {val, SharedConstant(model::NullValue())})),
+                ReturnsNull())
+        << "less_than_or_equal(" << ExprId(val) << ", null)";
+  }
+  EXPECT_THAT(
+      EvaluateExpr(*LessThanOrEqualExpr({SharedConstant(model::NullValue()),
+                                         SharedConstant(model::NullValue())})),
+      ReturnsNull());
+  EXPECT_THAT(EvaluateExpr(*LessThanOrEqualExpr(
+                  {SharedConstant(model::NullValue()),
+                   std::make_shared<api::Field>("nonexistent")})),
+              ReturnsError());
 }
 
-TEST_F(LteFunctionTest, NaNComparisonsReturnFalse) {
+TEST_F(LessThanOrEqualFunctionTest, NaNComparisonsReturnFalse) {
   auto nan_expr = SharedConstant(std::numeric_limits<double>::quiet_NaN());
-  EXPECT_THAT(EvaluateExpr(*LteExpr({nan_expr, nan_expr})),
+  EXPECT_THAT(EvaluateExpr(*LessThanOrEqualExpr({nan_expr, nan_expr})),
               Returns(testutil::Value(false)));
 
   for (const auto& num_val : ComparisonValueTestData::NumericValues()) {
-    EXPECT_THAT(EvaluateExpr(*LteExpr({nan_expr, num_val})),
+    EXPECT_THAT(EvaluateExpr(*LessThanOrEqualExpr({nan_expr, num_val})),
                 Returns(testutil::Value(false)))
-        << "lte(NaN, " << ExprId(num_val) << ")";
-    EXPECT_THAT(EvaluateExpr(*LteExpr({num_val, nan_expr})),
+        << "less_than_or_equal(NaN, " << ExprId(num_val) << ")";
+    EXPECT_THAT(EvaluateExpr(*LessThanOrEqualExpr({num_val, nan_expr})),
                 Returns(testutil::Value(false)))
-        << "lte(" << ExprId(num_val) << ", NaN)";
+        << "less_than_or_equal(" << ExprId(num_val) << ", NaN)";
   }
   for (const auto& other_val :
        ComparisonValueTestData::AllSupportedComparableValues()) {
@@ -624,71 +642,77 @@ TEST_F(LteFunctionTest, NaNComparisonsReturnFalse) {
       }
     }
     if (!is_numeric) {
-      EXPECT_THAT(EvaluateExpr(*LteExpr({nan_expr, other_val})),
+      EXPECT_THAT(EvaluateExpr(*LessThanOrEqualExpr({nan_expr, other_val})),
                   Returns(testutil::Value(false)))
-          << "lte(NaN, " << ExprId(other_val) << ")";
-      EXPECT_THAT(EvaluateExpr(*LteExpr({other_val, nan_expr})),
+          << "less_than_or_equal(NaN, " << ExprId(other_val) << ")";
+      EXPECT_THAT(EvaluateExpr(*LessThanOrEqualExpr({other_val, nan_expr})),
                   Returns(testutil::Value(false)))
-          << "lte(" << ExprId(other_val) << ", NaN)";
+          << "less_than_or_equal(" << ExprId(other_val) << ", NaN)";
     }
   }
-  EXPECT_THAT(
-      EvaluateExpr(*LteExpr({SharedConstant(testutil::Array(testutil::Value(
-                                 std::numeric_limits<double>::quiet_NaN()))),
-                             SharedConstant(testutil::Array(testutil::Value(
-                                 std::numeric_limits<double>::quiet_NaN())))})),
-      Returns(testutil::Value(false)));
+  EXPECT_THAT(EvaluateExpr(*LessThanOrEqualExpr(
+                  {SharedConstant(testutil::Array(testutil::Value(
+                       std::numeric_limits<double>::quiet_NaN()))),
+                   SharedConstant(testutil::Array(testutil::Value(
+                       std::numeric_limits<double>::quiet_NaN())))})),
+              Returns(testutil::Value(false)));
 }
 
-TEST_F(LteFunctionTest, ErrorHandling) {
+TEST_F(LessThanOrEqualFunctionTest, ErrorHandling) {
   auto error_expr = std::make_shared<api::Field>("a.b");
   auto non_map_input = testutil::Doc("coll/doc", 1, testutil::Map("a", 123));
 
   for (const auto& val :
        ComparisonValueTestData::AllSupportedComparableValues()) {
-    EXPECT_THAT(EvaluateExpr(*LteExpr({error_expr, val}), non_map_input),
-                ReturnsError());
-    EXPECT_THAT(EvaluateExpr(*LteExpr({val, error_expr}), non_map_input),
-                ReturnsError());
+    EXPECT_THAT(
+        EvaluateExpr(*LessThanOrEqualExpr({error_expr, val}), non_map_input),
+        ReturnsError());
+    EXPECT_THAT(
+        EvaluateExpr(*LessThanOrEqualExpr({val, error_expr}), non_map_input),
+        ReturnsError());
   }
-  EXPECT_THAT(EvaluateExpr(*LteExpr({error_expr, error_expr}), non_map_input),
+  EXPECT_THAT(EvaluateExpr(*LessThanOrEqualExpr({error_expr, error_expr}),
+                           non_map_input),
               ReturnsError());
   EXPECT_THAT(
-      EvaluateExpr(*LteExpr({error_expr, SharedConstant(model::NullValue())}),
+      EvaluateExpr(*LessThanOrEqualExpr(
+                       {error_expr, SharedConstant(model::NullValue())}),
                    non_map_input),
       ReturnsError());
 }
 
-TEST_F(LteFunctionTest, MissingFieldReturnsError) {
-  EXPECT_THAT(
-      EvaluateExpr(*LteExpr({std::make_shared<api::Field>("nonexistent"),
-                             SharedConstant(testutil::Value(1LL))})),
-      ReturnsError());
-  EXPECT_THAT(
-      EvaluateExpr(*LteExpr({SharedConstant(testutil::Value(1LL)),
-                             std::make_shared<api::Field>("nonexistent")})),
-      ReturnsError());
+TEST_F(LessThanOrEqualFunctionTest, MissingFieldReturnsError) {
+  EXPECT_THAT(EvaluateExpr(*LessThanOrEqualExpr(
+                  {std::make_shared<api::Field>("nonexistent"),
+                   SharedConstant(testutil::Value(1LL))})),
+              ReturnsError());
+  EXPECT_THAT(EvaluateExpr(*LessThanOrEqualExpr(
+                  {SharedConstant(testutil::Value(1LL)),
+                   std::make_shared<api::Field>("nonexistent")})),
+              ReturnsError());
 }
 
-// --- Gt (>) Tests ---
+// --- GreaterThan (>) Tests ---
 
-TEST_F(GtFunctionTest, EquivalentValuesReturnFalse) {
+TEST_F(GreaterThanFunctionTest, EquivalentValuesReturnFalse) {
   for (const auto& pair : ComparisonValueTestData::EquivalentValues()) {
-    EXPECT_THAT(EvaluateExpr(*GtExpr({pair.first, pair.second})),
+    EXPECT_THAT(EvaluateExpr(*GreaterThanExpr({pair.first, pair.second})),
                 Returns(testutil::Value(false)))
-        << "gt(" << ExprId(pair.first) << ", " << ExprId(pair.second) << ")";
+        << "greater_than(" << ExprId(pair.first) << ", " << ExprId(pair.second)
+        << ")";
   }
 }
 
-TEST_F(GtFunctionTest, LessThanValuesReturnFalse) {
+TEST_F(GreaterThanFunctionTest, LessThanValuesReturnFalse) {
   for (const auto& pair : ComparisonValueTestData::LessThanValues()) {
-    EXPECT_THAT(EvaluateExpr(*GtExpr({pair.first, pair.second})),
+    EXPECT_THAT(EvaluateExpr(*GreaterThanExpr({pair.first, pair.second})),
                 Returns(testutil::Value(false)))
-        << "gt(" << ExprId(pair.first) << ", " << ExprId(pair.second) << ")";
+        << "greater_than(" << ExprId(pair.first) << ", " << ExprId(pair.second)
+        << ")";
   }
 }
 
-TEST_F(GtFunctionTest, GreaterThanValuesReturnTrue) {
+TEST_F(GreaterThanFunctionTest, GreaterThanValuesReturnTrue) {
   for (const auto& pair : ComparisonValueTestData::GreaterThanValues()) {
     // This set includes pairs like {1.0, 1} which compare as !GreaterThan.
     // We expect false for those, true otherwise.
@@ -696,55 +720,58 @@ TEST_F(GtFunctionTest, GreaterThanValuesReturnTrue) {
         std::dynamic_pointer_cast<const api::Constant>(pair.first);
     auto right_const =
         std::dynamic_pointer_cast<const api::Constant>(pair.second);
-    EXPECT_THAT(EvaluateExpr(*GtExpr({pair.first, pair.second})),
+    EXPECT_THAT(EvaluateExpr(*GreaterThanExpr({pair.first, pair.second})),
                 Returns(testutil::Value(true)))
-        << "gt(" << ExprId(pair.first) << ", " << ExprId(pair.second) << ")";
+        << "greater_than(" << ExprId(pair.first) << ", " << ExprId(pair.second)
+        << ")";
   }
 }
 
-TEST_F(GtFunctionTest, MixedTypeValuesReturnFalse) {
+TEST_F(GreaterThanFunctionTest, MixedTypeValuesReturnFalse) {
   for (const auto& pair : ComparisonValueTestData::MixedTypeValues()) {
-    EXPECT_THAT(EvaluateExpr(*GtExpr({pair.first, pair.second})),
+    EXPECT_THAT(EvaluateExpr(*GreaterThanExpr({pair.first, pair.second})),
                 Returns(testutil::Value(false)))
-        << "gt(" << ExprId(pair.first) << ", " << ExprId(pair.second) << ")";
+        << "greater_than(" << ExprId(pair.first) << ", " << ExprId(pair.second)
+        << ")";
   }
 }
 
-// --- Specific Gt Tests ---
+// --- Specific GreaterThan Tests ---
 
-TEST_F(GtFunctionTest, NullOperandReturnsNull) {
+TEST_F(GreaterThanFunctionTest, NullOperandReturnsNull) {
   for (const auto& val :
        ComparisonValueTestData::AllSupportedComparableValues()) {
-    EXPECT_THAT(
-        EvaluateExpr(*GtExpr({SharedConstant(model::NullValue()), val})),
-        ReturnsNull())
-        << "gt(null, " << ExprId(val) << ")";
-    EXPECT_THAT(
-        EvaluateExpr(*GtExpr({val, SharedConstant(model::NullValue())})),
-        ReturnsNull())
-        << "gt(" << ExprId(val) << ", null)";
+    EXPECT_THAT(EvaluateExpr(*GreaterThanExpr(
+                    {SharedConstant(model::NullValue()), val})),
+                ReturnsNull())
+        << "greater_than(null, " << ExprId(val) << ")";
+    EXPECT_THAT(EvaluateExpr(*GreaterThanExpr(
+                    {val, SharedConstant(model::NullValue())})),
+                ReturnsNull())
+        << "greater_than(" << ExprId(val) << ", null)";
   }
-  EXPECT_THAT(EvaluateExpr(*GtExpr({SharedConstant(model::NullValue()),
-                                    SharedConstant(model::NullValue())})),
-              ReturnsNull());
   EXPECT_THAT(
-      EvaluateExpr(*GtExpr({SharedConstant(model::NullValue()),
-                            std::make_shared<api::Field>("nonexistent")})),
-      ReturnsError());
+      EvaluateExpr(*GreaterThanExpr({SharedConstant(model::NullValue()),
+                                     SharedConstant(model::NullValue())})),
+      ReturnsNull());
+  EXPECT_THAT(EvaluateExpr(*GreaterThanExpr(
+                  {SharedConstant(model::NullValue()),
+                   std::make_shared<api::Field>("nonexistent")})),
+              ReturnsError());
 }
 
-TEST_F(GtFunctionTest, NaNComparisonsReturnFalse) {
+TEST_F(GreaterThanFunctionTest, NaNComparisonsReturnFalse) {
   auto nan_expr = SharedConstant(std::numeric_limits<double>::quiet_NaN());
-  EXPECT_THAT(EvaluateExpr(*GtExpr({nan_expr, nan_expr})),
+  EXPECT_THAT(EvaluateExpr(*GreaterThanExpr({nan_expr, nan_expr})),
               Returns(testutil::Value(false)));
 
   for (const auto& num_val : ComparisonValueTestData::NumericValues()) {
-    EXPECT_THAT(EvaluateExpr(*GtExpr({nan_expr, num_val})),
+    EXPECT_THAT(EvaluateExpr(*GreaterThanExpr({nan_expr, num_val})),
                 Returns(testutil::Value(false)))
-        << "gt(NaN, " << ExprId(num_val) << ")";
-    EXPECT_THAT(EvaluateExpr(*GtExpr({num_val, nan_expr})),
+        << "greater_than(NaN, " << ExprId(num_val) << ")";
+    EXPECT_THAT(EvaluateExpr(*GreaterThanExpr({num_val, nan_expr})),
                 Returns(testutil::Value(false)))
-        << "gt(" << ExprId(num_val) << ", NaN)";
+        << "greater_than(" << ExprId(num_val) << ", NaN)";
   }
   for (const auto& other_val :
        ComparisonValueTestData::AllSupportedComparableValues()) {
@@ -756,120 +783,134 @@ TEST_F(GtFunctionTest, NaNComparisonsReturnFalse) {
       }
     }
     if (!is_numeric) {
-      EXPECT_THAT(EvaluateExpr(*GtExpr({nan_expr, other_val})),
+      EXPECT_THAT(EvaluateExpr(*GreaterThanExpr({nan_expr, other_val})),
                   Returns(testutil::Value(false)))
-          << "gt(NaN, " << ExprId(other_val) << ")";
-      EXPECT_THAT(EvaluateExpr(*GtExpr({other_val, nan_expr})),
+          << "greater_than(NaN, " << ExprId(other_val) << ")";
+      EXPECT_THAT(EvaluateExpr(*GreaterThanExpr({other_val, nan_expr})),
                   Returns(testutil::Value(false)))
-          << "gt(" << ExprId(other_val) << ", NaN)";
+          << "greater_than(" << ExprId(other_val) << ", NaN)";
     }
   }
-  EXPECT_THAT(
-      EvaluateExpr(*GtExpr({SharedConstant(testutil::Array(testutil::Value(
-                                std::numeric_limits<double>::quiet_NaN()))),
-                            SharedConstant(testutil::Array(testutil::Value(
-                                std::numeric_limits<double>::quiet_NaN())))})),
-      Returns(testutil::Value(false)));
+  EXPECT_THAT(EvaluateExpr(*GreaterThanExpr(
+                  {SharedConstant(testutil::Array(testutil::Value(
+                       std::numeric_limits<double>::quiet_NaN()))),
+                   SharedConstant(testutil::Array(testutil::Value(
+                       std::numeric_limits<double>::quiet_NaN())))})),
+              Returns(testutil::Value(false)));
 }
 
-TEST_F(GtFunctionTest, ErrorHandling) {
+TEST_F(GreaterThanFunctionTest, ErrorHandling) {
   auto error_expr = std::make_shared<api::Field>("a.b");
   auto non_map_input = testutil::Doc("coll/doc", 1, testutil::Map("a", 123));
 
   for (const auto& val :
        ComparisonValueTestData::AllSupportedComparableValues()) {
-    EXPECT_THAT(EvaluateExpr(*GtExpr({error_expr, val}), non_map_input),
-                ReturnsError());
-    EXPECT_THAT(EvaluateExpr(*GtExpr({val, error_expr}), non_map_input),
-                ReturnsError());
+    EXPECT_THAT(
+        EvaluateExpr(*GreaterThanExpr({error_expr, val}), non_map_input),
+        ReturnsError());
+    EXPECT_THAT(
+        EvaluateExpr(*GreaterThanExpr({val, error_expr}), non_map_input),
+        ReturnsError());
   }
-  EXPECT_THAT(EvaluateExpr(*GtExpr({error_expr, error_expr}), non_map_input),
-              ReturnsError());
   EXPECT_THAT(
-      EvaluateExpr(*GtExpr({error_expr, SharedConstant(model::NullValue())}),
-                   non_map_input),
+      EvaluateExpr(*GreaterThanExpr({error_expr, error_expr}), non_map_input),
+      ReturnsError());
+  EXPECT_THAT(
+      EvaluateExpr(
+          *GreaterThanExpr({error_expr, SharedConstant(model::NullValue())}),
+          non_map_input),
       ReturnsError());
 }
 
-TEST_F(GtFunctionTest, MissingFieldReturnsError) {
-  EXPECT_THAT(EvaluateExpr(*GtExpr({std::make_shared<api::Field>("nonexistent"),
+TEST_F(GreaterThanFunctionTest, MissingFieldReturnsError) {
+  EXPECT_THAT(EvaluateExpr(
+                  *GreaterThanExpr({std::make_shared<api::Field>("nonexistent"),
                                     SharedConstant(testutil::Value(1LL))})),
               ReturnsError());
-  EXPECT_THAT(
-      EvaluateExpr(*GtExpr({SharedConstant(testutil::Value(1LL)),
-                            std::make_shared<api::Field>("nonexistent")})),
-      ReturnsError());
+  EXPECT_THAT(EvaluateExpr(*GreaterThanExpr(
+                  {SharedConstant(testutil::Value(1LL)),
+                   std::make_shared<api::Field>("nonexistent")})),
+              ReturnsError());
 }
 
-// --- Gte (>=) Tests ---
+// --- GreaterThanOrEqual (>=) Tests ---
 
-TEST_F(GteFunctionTest, EquivalentValuesReturnTrue) {
+TEST_F(GreaterThanOrEqualFunctionTest, EquivalentValuesReturnTrue) {
   for (const auto& pair : ComparisonValueTestData::EquivalentValues()) {
-    EXPECT_THAT(EvaluateExpr(*GteExpr({pair.first, pair.second})),
-                Returns(testutil::Value(true)))
-        << "gte(" << ExprId(pair.first) << ", " << ExprId(pair.second) << ")";
+    EXPECT_THAT(
+        EvaluateExpr(*GreaterThanOrEqualExpr({pair.first, pair.second})),
+        Returns(testutil::Value(true)))
+        << "greater_than_or_equal(" << ExprId(pair.first) << ", "
+        << ExprId(pair.second) << ")";
   }
 }
 
-TEST_F(GteFunctionTest, LessThanValuesReturnFalse) {
+TEST_F(GreaterThanOrEqualFunctionTest, LessThanValuesReturnFalse) {
   for (const auto& pair : ComparisonValueTestData::LessThanValues()) {
-    EXPECT_THAT(EvaluateExpr(*GteExpr({pair.first, pair.second})),
-                Returns(testutil::Value(false)))
-        << "gte(" << ExprId(pair.first) << ", " << ExprId(pair.second) << ")";
+    EXPECT_THAT(
+        EvaluateExpr(*GreaterThanOrEqualExpr({pair.first, pair.second})),
+        Returns(testutil::Value(false)))
+        << "greater_than_or_equal(" << ExprId(pair.first) << ", "
+        << ExprId(pair.second) << ")";
   }
 }
 
-TEST_F(GteFunctionTest, GreaterThanValuesReturnTrue) {
+TEST_F(GreaterThanOrEqualFunctionTest, GreaterThanValuesReturnTrue) {
   for (const auto& pair : ComparisonValueTestData::GreaterThanValues()) {
-    EXPECT_THAT(EvaluateExpr(*GteExpr({pair.first, pair.second})),
-                Returns(testutil::Value(true)))
-        << "gte(" << ExprId(pair.first) << ", " << ExprId(pair.second) << ")";
+    EXPECT_THAT(
+        EvaluateExpr(*GreaterThanOrEqualExpr({pair.first, pair.second})),
+        Returns(testutil::Value(true)))
+        << "greater_than_or_equal(" << ExprId(pair.first) << ", "
+        << ExprId(pair.second) << ")";
   }
 }
 
-TEST_F(GteFunctionTest, MixedTypeValuesReturnFalse) {
+TEST_F(GreaterThanOrEqualFunctionTest, MixedTypeValuesReturnFalse) {
   for (const auto& pair : ComparisonValueTestData::MixedTypeValues()) {
-    EXPECT_THAT(EvaluateExpr(*GteExpr({pair.first, pair.second})),
-                Returns(testutil::Value(false)))
-        << "gte(" << ExprId(pair.first) << ", " << ExprId(pair.second) << ")";
+    EXPECT_THAT(
+        EvaluateExpr(*GreaterThanOrEqualExpr({pair.first, pair.second})),
+        Returns(testutil::Value(false)))
+        << "greater_than_or_equal(" << ExprId(pair.first) << ", "
+        << ExprId(pair.second) << ")";
   }
 }
 
-// --- Specific Gte Tests ---
+// --- Specific GreaterThanOrEqual Tests ---
 
-TEST_F(GteFunctionTest, NullOperandReturnsNull) {
+TEST_F(GreaterThanOrEqualFunctionTest, NullOperandReturnsNull) {
   for (const auto& val :
        ComparisonValueTestData::AllSupportedComparableValues()) {
-    EXPECT_THAT(
-        EvaluateExpr(*GteExpr({SharedConstant(model::NullValue()), val})),
-        ReturnsNull())
-        << "gte(null, " << ExprId(val) << ")";
-    EXPECT_THAT(
-        EvaluateExpr(*GteExpr({val, SharedConstant(model::NullValue())})),
-        ReturnsNull())
-        << "gte(" << ExprId(val) << ", null)";
-  }
-  EXPECT_THAT(EvaluateExpr(*GteExpr({SharedConstant(model::NullValue()),
-                                     SharedConstant(model::NullValue())})),
+    EXPECT_THAT(EvaluateExpr(*GreaterThanOrEqualExpr(
+                    {SharedConstant(model::NullValue()), val})),
+                ReturnsNull())
+        << "greater_than_or_equal(null, " << ExprId(val) << ")";
+    EXPECT_THAT(EvaluateExpr(*GreaterThanOrEqualExpr(
+                    {val, SharedConstant(model::NullValue())})),
+                ReturnsNull())
+        << "greater_than_or_equal(" << ExprId(val) << ", null)";
+  }
+  EXPECT_THAT(EvaluateExpr(*GreaterThanOrEqualExpr(
+                  {SharedConstant(model::NullValue()),
+                   SharedConstant(model::NullValue())})),
               ReturnsNull());
-  EXPECT_THAT(
-      EvaluateExpr(*GteExpr({SharedConstant(model::NullValue()),
-                             std::make_shared<api::Field>("nonexistent")})),
-      ReturnsError());
+  EXPECT_THAT(EvaluateExpr(*GreaterThanOrEqualExpr(
+                  {SharedConstant(model::NullValue()),
+                   std::make_shared<api::Field>("nonexistent")})),
+              ReturnsError());
 }
 
-TEST_F(GteFunctionTest, NaNComparisonsReturnFalse) {
+TEST_F(GreaterThanOrEqualFunctionTest, NaNComparisonsReturnFalse) {
   auto nan_expr = SharedConstant(std::numeric_limits<double>::quiet_NaN());
-  EXPECT_THAT(EvaluateExpr(*GteExpr({nan_expr, nan_expr})),
+  EXPECT_THAT(EvaluateExpr(*GreaterThanOrEqualExpr({nan_expr, nan_expr})),
               Returns(testutil::Value(false)));
 
   for (const auto& num_val : ComparisonValueTestData::NumericValues()) {
-    EXPECT_THAT(EvaluateExpr(*GteExpr({nan_expr, num_val})),
+    EXPECT_THAT(EvaluateExpr(*GreaterThanOrEqualExpr({nan_expr, num_val})),
                 Returns(testutil::Value(false)))
-        << "gte(NaN, " << ExprId(num_val) << ")";
-    EXPECT_THAT(EvaluateExpr(*GteExpr({num_val, nan_expr})),
+        << "greater_than_or_equal(NaN, " << ExprId(num_val) << ")";
+    EXPECT_THAT(EvaluateExpr(*GreaterThanOrEqualExpr({num_val, nan_expr})),
                 Returns(testutil::Value(false)))
-        << "gte(" << ExprId(num_val) << ", NaN)";
+        << "greater_than_or_equal(" << ExprId(num_val) << ", NaN)";
   }
   for (const auto& other_val :
        ComparisonValueTestData::AllSupportedComparableValues()) {
@@ -881,50 +922,54 @@ TEST_F(GteFunctionTest, NaNComparisonsReturnFalse) {
       }
     }
     if (!is_numeric) {
-      EXPECT_THAT(EvaluateExpr(*GteExpr({nan_expr, other_val})),
+      EXPECT_THAT(EvaluateExpr(*GreaterThanOrEqualExpr({nan_expr, other_val})),
                   Returns(testutil::Value(false)))
-          << "gte(NaN, " << ExprId(other_val) << ")";
-      EXPECT_THAT(EvaluateExpr(*GteExpr({other_val, nan_expr})),
+          << "greater_than_or_equal(NaN, " << ExprId(other_val) << ")";
+      EXPECT_THAT(EvaluateExpr(*GreaterThanOrEqualExpr({other_val, nan_expr})),
                   Returns(testutil::Value(false)))
-          << "gte(" << ExprId(other_val) << ", NaN)";
+          << "greater_than_or_equal(" << ExprId(other_val) << ", NaN)";
     }
   }
-  EXPECT_THAT(
-      EvaluateExpr(*GteExpr({SharedConstant(testutil::Array(testutil::Value(
-                                 std::numeric_limits<double>::quiet_NaN()))),
-                             SharedConstant(testutil::Array(testutil::Value(
-                                 std::numeric_limits<double>::quiet_NaN())))})),
-      Returns(testutil::Value(false)));
+  EXPECT_THAT(EvaluateExpr(*GreaterThanOrEqualExpr(
+                  {SharedConstant(testutil::Array(testutil::Value(
+                       std::numeric_limits<double>::quiet_NaN()))),
+                   SharedConstant(testutil::Array(testutil::Value(
+                       std::numeric_limits<double>::quiet_NaN())))})),
+              Returns(testutil::Value(false)));
 }
 
-TEST_F(GteFunctionTest, ErrorHandling) {
+TEST_F(GreaterThanOrEqualFunctionTest, ErrorHandling) {
   auto error_expr = std::make_shared<api::Field>("a.b");
   auto non_map_input = testutil::Doc("coll/doc", 1, testutil::Map("a", 123));
 
   for (const auto& val :
        ComparisonValueTestData::AllSupportedComparableValues()) {
-    EXPECT_THAT(EvaluateExpr(*GteExpr({error_expr, val}), non_map_input),
-                ReturnsError());
-    EXPECT_THAT(EvaluateExpr(*GteExpr({val, error_expr}), non_map_input),
-                ReturnsError());
+    EXPECT_THAT(
+        EvaluateExpr(*GreaterThanOrEqualExpr({error_expr, val}), non_map_input),
+        ReturnsError());
+    EXPECT_THAT(
+        EvaluateExpr(*GreaterThanOrEqualExpr({val, error_expr}), non_map_input),
+        ReturnsError());
   }
-  EXPECT_THAT(EvaluateExpr(*GteExpr({error_expr, error_expr}), non_map_input),
+  EXPECT_THAT(EvaluateExpr(*GreaterThanOrEqualExpr({error_expr, error_expr}),
+                           non_map_input),
               ReturnsError());
   EXPECT_THAT(
-      EvaluateExpr(*GteExpr({error_expr, SharedConstant(model::NullValue())}),
+      EvaluateExpr(*GreaterThanOrEqualExpr(
+                       {error_expr, SharedConstant(model::NullValue())}),
                    non_map_input),
       ReturnsError());
 }
 
-TEST_F(GteFunctionTest, MissingFieldReturnsError) {
-  EXPECT_THAT(
-      EvaluateExpr(*GteExpr({std::make_shared<api::Field>("nonexistent"),
-                             SharedConstant(testutil::Value(1LL))})),
-      ReturnsError());
-  EXPECT_THAT(
-      EvaluateExpr(*GteExpr({SharedConstant(testutil::Value(1LL)),
-                             std::make_shared<api::Field>("nonexistent")})),
-      ReturnsError());
+TEST_F(GreaterThanOrEqualFunctionTest, MissingFieldReturnsError) {
+  EXPECT_THAT(EvaluateExpr(*GreaterThanOrEqualExpr(
+                  {std::make_shared<api::Field>("nonexistent"),
+                   SharedConstant(testutil::Value(1LL))})),
+              ReturnsError());
+  EXPECT_THAT(EvaluateExpr(*GreaterThanOrEqualExpr(
+                  {SharedConstant(testutil::Value(1LL)),
+                   std::make_shared<api::Field>("nonexistent")})),
+              ReturnsError());
 }
 
 }  // namespace core
diff --git a/Firestore/core/test/unit/core/expressions/debug_test.cc b/Firestore/core/test/unit/core/expressions/debug_test.cc
index 9b6ed4df06a..ae527a16573 100644
--- a/Firestore/core/test/unit/core/expressions/debug_test.cc
+++ b/Firestore/core/test/unit/core/expressions/debug_test.cc
@@ -117,8 +117,9 @@ TEST_F(DebugTest, IsErrorFieldMissingReturnsFalse) {
 }
 
 TEST_F(DebugTest, IsErrorNonErrorReturnsFalse) {
-  EXPECT_THAT(EvaluateExpr(*IsErrorExpr(SharedConstant(42LL))),
-              Returns(Value(false)));
+  EXPECT_THAT(
+      EvaluateExpr(*IsErrorExpr(SharedConstant(static_cast<int64_t>(42LL)))),
+      Returns(Value(false)));
 }
 
 TEST_F(DebugTest, IsErrorExplicitNullReturnsFalse) {
diff --git a/Firestore/core/test/unit/core/expressions/logical_test.cc b/Firestore/core/test/unit/core/expressions/logical_test.cc
index 81633e2c106..73f3d10c4d9 100644
--- a/Firestore/core/test/unit/core/expressions/logical_test.cc
+++ b/Firestore/core/test/unit/core/expressions/logical_test.cc
@@ -50,9 +50,9 @@ using testutil::IsNanExpr;
 using testutil::IsNotNanExpr;
 using testutil::IsNotNullExpr;
 using testutil::IsNullExpr;
-using testutil::LogicalMaxExpr;
-using testutil::LogicalMinExpr;
 using testutil::Map;
+using testutil::MaximumExpr;
+using testutil::MinimumExpr;
 using testutil::NotExpr;
 using testutil::OrExpr;
 using testutil::Returns;
@@ -507,143 +507,141 @@ TEST_F(IsNanFunctionTest, NonNumericReturnsError) {
               ReturnsError());
 }
 
-// --- LogicalMaximum Tests ---
-class LogicalMaximumFunctionTest : public LogicalExpressionsTest {};
+// --- Maximum Tests ---
+class MaximumFunctionTest : public LogicalExpressionsTest {};
 
-TEST_F(LogicalMaximumFunctionTest, NumericType) {
-  auto expr = testutil::LogicalMaxExpr(
+TEST_F(MaximumFunctionTest, NumericType) {
+  auto expr = testutil::MaximumExpr(
       {SharedConstant(Value(1LL)),
-       testutil::LogicalMaxExpr(
+       testutil::MaximumExpr(
            {SharedConstant(Value(2.0)), SharedConstant(Value(3LL))})});
   EXPECT_THAT(EvaluateExpr(*expr),
               Returns(Value(3LL)));  // Max(1, Max(2.0, 3)) -> 3
 }
 
-TEST_F(LogicalMaximumFunctionTest, StringType) {
-  auto expr = testutil::LogicalMaxExpr(
-      {testutil::LogicalMaxExpr(
+TEST_F(MaximumFunctionTest, StringType) {
+  auto expr = testutil::MaximumExpr(
+      {testutil::MaximumExpr(
            {SharedConstant(Value("a")), SharedConstant(Value("b"))}),
        SharedConstant(Value("c"))});
   EXPECT_THAT(EvaluateExpr(*expr),
               Returns(Value("c")));  // Max(Max("a", "b"), "c") -> "c"
 }
 
-TEST_F(LogicalMaximumFunctionTest, MixedType) {
+TEST_F(MaximumFunctionTest, MixedType) {
   // Type order: Null < Bool < Number < Timestamp < String < Blob < Ref <
   // GeoPoint < Array < Map
-  auto expr = testutil::LogicalMaxExpr(
+  auto expr = testutil::MaximumExpr(
       {SharedConstant(Value(1LL)),
-       testutil::LogicalMaxExpr(
+       testutil::MaximumExpr(
            {SharedConstant(Value("1")), SharedConstant(Value(0LL))})});
   EXPECT_THAT(
       EvaluateExpr(*expr),
       Returns(Value("1")));  // Max(1, Max("1", 0)) -> "1" (String > Number)
 }
 
-TEST_F(LogicalMaximumFunctionTest, OnlyNullAndErrorReturnsNull) {
-  auto expr = testutil::LogicalMaxExpr({NullExpr, ErrorExpr()});
+TEST_F(MaximumFunctionTest, OnlyNullAndErrorReturnsNull) {
+  auto expr = testutil::MaximumExpr({NullExpr, ErrorExpr()});
   EXPECT_THAT(EvaluateExpr(*expr, error_doc_), ReturnsNull());
 }
 
-TEST_F(LogicalMaximumFunctionTest, NanAndNumbers) {
+TEST_F(MaximumFunctionTest, NanAndNumbers) {
   // NaN is handled specially; it's skipped unless it's the only non-null/error
   // value.
-  auto expr = testutil::LogicalMaxExpr({NanExpr, SharedConstant(Value(0LL))});
+  auto expr = testutil::MaximumExpr({NanExpr, SharedConstant(Value(0LL))});
   EXPECT_THAT(EvaluateExpr(*expr), Returns(Value(0LL)));  // Max(NaN, 0) -> 0
-  auto expr2 = testutil::LogicalMaxExpr({SharedConstant(Value(0LL)), NanExpr});
+  auto expr2 = testutil::MaximumExpr({SharedConstant(Value(0LL)), NanExpr});
   EXPECT_THAT(EvaluateExpr(*expr2), Returns(Value(0LL)));  // Max(0, NaN) -> 0
-  auto expr3 = testutil::LogicalMaxExpr({NanExpr, NullExpr, ErrorExpr()});
+  auto expr3 = testutil::MaximumExpr({NanExpr, NullExpr, ErrorExpr()});
   EXPECT_THAT(EvaluateExpr(*expr3, error_doc_),
               Returns(Value(NAN)));  // Max(NaN, Null, Error) -> NaN
-  auto expr4 = testutil::LogicalMaxExpr({NanExpr, ErrorExpr()});
+  auto expr4 = testutil::MaximumExpr({NanExpr, ErrorExpr()});
   EXPECT_THAT(EvaluateExpr(*expr4, error_doc_),
               Returns(Value(NAN)));  // Max(NaN, Error) -> NaN
 }
 
-TEST_F(LogicalMaximumFunctionTest, ErrorInputSkip) {
-  auto expr =
-      testutil::LogicalMaxExpr({ErrorExpr(), SharedConstant(Value(1LL))});
+TEST_F(MaximumFunctionTest, ErrorInputSkip) {
+  auto expr = testutil::MaximumExpr({ErrorExpr(), SharedConstant(Value(1LL))});
   EXPECT_THAT(EvaluateExpr(*expr, error_doc_), Returns(Value(1LL)));
 }
 
-TEST_F(LogicalMaximumFunctionTest, NullInputSkip) {
-  auto expr = testutil::LogicalMaxExpr({NullExpr, SharedConstant(Value(1LL))});
+TEST_F(MaximumFunctionTest, NullInputSkip) {
+  auto expr = testutil::MaximumExpr({NullExpr, SharedConstant(Value(1LL))});
   EXPECT_THAT(EvaluateExpr(*expr), Returns(Value(1LL)));
 }
 
-TEST_F(LogicalMaximumFunctionTest, EquivalentNumerics) {
-  auto expr = testutil::LogicalMaxExpr(
+TEST_F(MaximumFunctionTest, EquivalentNumerics) {
+  auto expr = testutil::MaximumExpr(
       {SharedConstant(Value(1LL)), SharedConstant(Value(1.0))});
   // Max(1, 1.0) -> 1 (or 1.0, they are equivalent, result depends on internal
   // order) Let's check if it's equivalent to 1LL
   EXPECT_THAT(EvaluateExpr(*expr), Returns(Value(1LL)));
 }
 
-// --- LogicalMinimum Tests ---
-class LogicalMinimumFunctionTest : public LogicalExpressionsTest {};
+// --- Minimum Tests ---
+class MinimumFunctionTest : public LogicalExpressionsTest {};
 
-TEST_F(LogicalMinimumFunctionTest, NumericType) {
-  auto expr = testutil::LogicalMinExpr(
+TEST_F(MinimumFunctionTest, NumericType) {
+  auto expr = testutil::MinimumExpr(
       {SharedConstant(Value(1LL)),
-       testutil::LogicalMinExpr(
+       testutil::MinimumExpr(
            {SharedConstant(Value(2.0)), SharedConstant(Value(3LL))})});
   EXPECT_THAT(EvaluateExpr(*expr),
               Returns(Value(1LL)));  // Min(1, Min(2.0, 3)) -> 1
 }
 
-TEST_F(LogicalMinimumFunctionTest, StringType) {
-  auto expr = testutil::LogicalMinExpr(
-      {testutil::LogicalMinExpr(
+TEST_F(MinimumFunctionTest, StringType) {
+  auto expr = testutil::MinimumExpr(
+      {testutil::MinimumExpr(
            {SharedConstant(Value("a")), SharedConstant(Value("b"))}),
        SharedConstant(Value("c"))});
   EXPECT_THAT(EvaluateExpr(*expr),
               Returns(Value("a")));  // Min(Min("a", "b"), "c") -> "a"
 }
 
-TEST_F(LogicalMinimumFunctionTest, MixedType) {
+TEST_F(MinimumFunctionTest, MixedType) {
   // Type order: Null < Bool < Number < Timestamp < String < Blob < Ref <
   // GeoPoint < Array < Map
-  auto expr = testutil::LogicalMinExpr(
+  auto expr = testutil::MinimumExpr(
       {SharedConstant(Value(1LL)),
-       testutil::LogicalMinExpr(
+       testutil::MinimumExpr(
            {SharedConstant(Value("1")), SharedConstant(Value(0LL))})});
   EXPECT_THAT(
       EvaluateExpr(*expr),
       Returns(Value(0LL)));  // Min(1, Min("1", 0)) -> 0 (Number < String)
 }
 
-TEST_F(LogicalMinimumFunctionTest, OnlyNullAndErrorReturnsNull) {
-  auto expr = testutil::LogicalMinExpr({NullExpr, ErrorExpr()});
+TEST_F(MinimumFunctionTest, OnlyNullAndErrorReturnsNull) {
+  auto expr = testutil::MinimumExpr({NullExpr, ErrorExpr()});
   EXPECT_THAT(EvaluateExpr(*expr, error_doc_), ReturnsNull());
 }
 
-TEST_F(LogicalMinimumFunctionTest, NanAndNumbers) {
+TEST_F(MinimumFunctionTest, NanAndNumbers) {
   // NaN is handled specially; it's considered the minimum unless skipped.
-  auto expr = testutil::LogicalMinExpr({NanExpr, SharedConstant(Value(0LL))});
+  auto expr = testutil::MinimumExpr({NanExpr, SharedConstant(Value(0LL))});
   EXPECT_THAT(EvaluateExpr(*expr), Returns(Value(NAN)));  // Min(NaN, 0) -> NaN
-  auto expr2 = testutil::LogicalMinExpr({SharedConstant(Value(0LL)), NanExpr});
+  auto expr2 = testutil::MinimumExpr({SharedConstant(Value(0LL)), NanExpr});
   EXPECT_THAT(EvaluateExpr(*expr2), Returns(Value(NAN)));  // Min(0, NaN) -> NaN
-  auto expr3 = testutil::LogicalMinExpr({NanExpr, NullExpr, ErrorExpr()});
+  auto expr3 = testutil::MinimumExpr({NanExpr, NullExpr, ErrorExpr()});
   EXPECT_THAT(EvaluateExpr(*expr3, error_doc_),
               Returns(Value(NAN)));  // Min(NaN, Null, Error) -> NaN
-  auto expr4 = testutil::LogicalMinExpr({NanExpr, ErrorExpr()});
+  auto expr4 = testutil::MinimumExpr({NanExpr, ErrorExpr()});
   EXPECT_THAT(EvaluateExpr(*expr4, error_doc_),
               Returns(Value(NAN)));  // Min(NaN, Error) -> NaN
 }
 
-TEST_F(LogicalMinimumFunctionTest, ErrorInputSkip) {
-  auto expr =
-      testutil::LogicalMinExpr({ErrorExpr(), SharedConstant(Value(1LL))});
+TEST_F(MinimumFunctionTest, ErrorInputSkip) {
+  auto expr = testutil::MinimumExpr({ErrorExpr(), SharedConstant(Value(1LL))});
   EXPECT_THAT(EvaluateExpr(*expr, error_doc_), Returns(Value(1LL)));
 }
 
-TEST_F(LogicalMinimumFunctionTest, NullInputSkip) {
-  auto expr = testutil::LogicalMinExpr({NullExpr, SharedConstant(Value(1LL))});
+TEST_F(MinimumFunctionTest, NullInputSkip) {
+  auto expr = testutil::MinimumExpr({NullExpr, SharedConstant(Value(1LL))});
   EXPECT_THAT(EvaluateExpr(*expr), Returns(Value(1LL)));
 }
 
-TEST_F(LogicalMinimumFunctionTest, EquivalentNumerics) {
-  auto expr = testutil::LogicalMinExpr(
+TEST_F(MinimumFunctionTest, EquivalentNumerics) {
+  auto expr = testutil::MinimumExpr(
       {SharedConstant(Value(1LL)), SharedConstant(Value(1.0))});
   // Min(1, 1.0) -> 1 (or 1.0, they are equivalent)
   EXPECT_THAT(EvaluateExpr(*expr), Returns(Value(1LL)));
@@ -653,16 +651,16 @@ TEST_F(LogicalMinimumFunctionTest, EquivalentNumerics) {
 class NotFunctionTest : public LogicalExpressionsTest {};
 
 TEST_F(NotFunctionTest, TrueToFalse) {
-  // Using EqExpr from comparison_test helpers for simplicity
-  auto true_cond = testutil::EqExpr(
+  // Using EqualExpr from comparison_test helpers for simplicity
+  auto true_cond = testutil::EqualExpr(
       {SharedConstant(Value(1LL)), SharedConstant(Value(1LL))});
   EXPECT_THAT(EvaluateExpr(*testutil::NotExpr(true_cond)),
               Returns(Value(false)));
 }
 
 TEST_F(NotFunctionTest, FalseToTrue) {
-  // Using NeqExpr from comparison_test helpers for simplicity
-  auto false_cond = testutil::NeqExpr(
+  // Using NotEqualExpr from comparison_test helpers for simplicity
+  auto false_cond = testutil::NotEqualExpr(
       {SharedConstant(Value(1LL)), SharedConstant(Value(1LL))});
   EXPECT_THAT(EvaluateExpr(*testutil::NotExpr(false_cond)),
               Returns(Value(true)));
diff --git a/Firestore/core/test/unit/core/expressions/mirroring_semantics_test.cc b/Firestore/core/test/unit/core/expressions/mirroring_semantics_test.cc
index 02a66579b84..3a46b01514a 100644
--- a/Firestore/core/test/unit/core/expressions/mirroring_semantics_test.cc
+++ b/Firestore/core/test/unit/core/expressions/mirroring_semantics_test.cc
@@ -49,29 +49,29 @@ using testutil::CharLengthExpr;
 using testutil::DivideExpr;
 using testutil::EndsWithExpr;
 using testutil::EqAnyExpr;
-using testutil::EqExpr;
+using testutil::EqualExpr;
 using testutil::EvaluateExpr;
-using testutil::GteExpr;
-using testutil::GtExpr;
+using testutil::GreaterThanExpr;
+using testutil::GreaterThanOrEqualExpr;
 using testutil::IsNanExpr;
 using testutil::IsNotNanExpr;
+using testutil::LessThanExpr;
+using testutil::LessThanOrEqualExpr;
 using testutil::LikeExpr;
-using testutil::LteExpr;
-using testutil::LtExpr;
 using testutil::ModExpr;
 using testutil::MultiplyExpr;
-using testutil::NeqExpr;
 using testutil::NotEqAnyExpr;
+using testutil::NotEqualExpr;
 using testutil::RegexContainsExpr;
 using testutil::RegexMatchExpr;
 using testutil::Returns;
 using testutil::ReturnsError;
 using testutil::ReturnsNull;
-using testutil::ReverseExpr;
 using testutil::SharedConstant;
 using testutil::StartsWithExpr;
-using testutil::StrConcatExpr;
-using testutil::StrContainsExpr;
+using testutil::StringConcatExpr;
+using testutil::StringContainsExpr;
+using testutil::StringReverseExpr;
 using testutil::SubtractExpr;
 using testutil::TimestampToUnixMicrosExpr;
 using testutil::TimestampToUnixMillisExpr;
@@ -92,12 +92,14 @@ class MirroringSemanticsTest : public ::testing::Test {
   const std::shared_ptr<Expr> NULL_INPUT = SharedConstant(nullptr);
   // Error: Integer division by zero
   const std::shared_ptr<Expr> ERROR_INPUT =
-      DivideExpr({SharedConstant(1LL), SharedConstant(0LL)});
+      DivideExpr({SharedConstant(static_cast<int64_t>(1LL)),
+                  SharedConstant(static_cast<int64_t>(0LL))});
   // Unset: Field that doesn't exist in the default test document
   const std::shared_ptr<Expr> UNSET_INPUT =
       std::make_shared<Field>("non-existent-field");
   // Valid: A simple valid input for binary tests
-  const std::shared_ptr<Expr> VALID_INPUT = SharedConstant(42LL);
+  const std::shared_ptr<Expr> VALID_INPUT =
+      SharedConstant(static_cast<int64_t>(42LL));
 };
 
 // --- Unary Function Tests ---
@@ -110,7 +112,7 @@ TEST_F(MirroringSemanticsTest, UnaryFunctionInputMirroring) {
       [](auto v) { return IsNanExpr(v); },
       [](auto v) { return IsNotNanExpr(v); },
       [](auto v) { return ArrayLengthExpr(v); },
-      [](auto v) { return ReverseExpr(v); },
+      [](auto v) { return StringReverseExpr(v); },
       [](auto v) { return CharLengthExpr(v); },
       [](auto v) { return ByteLengthExpr(v); },
       [](auto v) { return ToLowerExpr(v); },
@@ -160,7 +162,7 @@ TEST_F(MirroringSemanticsTest, BinaryFunctionInputMirroring) {
   using BinaryBuilder = std::function<std::shared_ptr<Expr>(
       std::shared_ptr<Expr>, std::shared_ptr<Expr>)>;
 
-  // Note: Variadic functions like add, multiply, str_concat are tested
+  // Note: Variadic functions like add, multiply, string_concat are tested
   // with their base binary case here.
   const std::vector<BinaryBuilder> binary_function_builders = {
       // Arithmetic (Variadic, base is binary)
@@ -170,12 +172,12 @@ TEST_F(MirroringSemanticsTest, BinaryFunctionInputMirroring) {
       [](auto v1, auto v2) { return DivideExpr({v1, v2}); },
       [](auto v1, auto v2) { return ModExpr({v1, v2}); },
       // Comparison
-      [](auto v1, auto v2) { return EqExpr({v1, v2}); },
-      [](auto v1, auto v2) { return NeqExpr({v1, v2}); },
-      [](auto v1, auto v2) { return LtExpr({v1, v2}); },
-      [](auto v1, auto v2) { return LteExpr({v1, v2}); },
-      [](auto v1, auto v2) { return GtExpr({v1, v2}); },
-      [](auto v1, auto v2) { return GteExpr({v1, v2}); },
+      [](auto v1, auto v2) { return EqualExpr({v1, v2}); },
+      [](auto v1, auto v2) { return NotEqualExpr({v1, v2}); },
+      [](auto v1, auto v2) { return LessThanExpr({v1, v2}); },
+      [](auto v1, auto v2) { return LessThanOrEqualExpr({v1, v2}); },
+      [](auto v1, auto v2) { return GreaterThanExpr({v1, v2}); },
+      [](auto v1, auto v2) { return GreaterThanOrEqualExpr({v1, v2}); },
       // Array
       [](auto v1, auto v2) { return ArrayContainsExpr({v1, v2}); },
       [](auto v1, auto v2) { return ArrayContainsAllExpr({v1, v2}); },
@@ -186,10 +188,10 @@ TEST_F(MirroringSemanticsTest, BinaryFunctionInputMirroring) {
       [](auto v1, auto v2) { return LikeExpr(v1, v2); },
       [](auto v1, auto v2) { return RegexContainsExpr(v1, v2); },
       [](auto v1, auto v2) { return RegexMatchExpr(v1, v2); },
-      [](auto v1, auto v2) { return StrContainsExpr(v1, v2); },
+      [](auto v1, auto v2) { return StringContainsExpr(v1, v2); },
       [](auto v1, auto v2) { return StartsWithExpr(v1, v2); },
       [](auto v1, auto v2) { return EndsWithExpr(v1, v2); },
-      [](auto v1, auto v2) { return StrConcatExpr({v1, v2}); }
+      [](auto v1, auto v2) { return StringConcatExpr({v1, v2}); }
       // TODO(b/351084804): mapGet is not implemented yet
   };
 
diff --git a/Firestore/core/test/unit/core/expressions/string_test.cc b/Firestore/core/test/unit/core/expressions/string_test.cc
index 17ca21fd914..dba96829ec1 100644
--- a/Firestore/core/test/unit/core/expressions/string_test.cc
+++ b/Firestore/core/test/unit/core/expressions/string_test.cc
@@ -46,11 +46,11 @@ using testutil::RegexMatchExpr;
 using testutil::Returns;
 using testutil::ReturnsError;
 using testutil::ReturnsNull;  // If needed for string functions
-using testutil::ReverseExpr;
 using testutil::SharedConstant;
 using testutil::StartsWithExpr;
-using testutil::StrConcatExpr;
-using testutil::StrContainsExpr;
+using testutil::StringConcatExpr;
+using testutil::StringContainsExpr;
+using testutil::StringReverseExpr;
 using testutil::ToLowerExpr;
 using testutil::ToUpperExpr;
 using testutil::TrimExpr;
@@ -69,7 +69,7 @@ class StrContainsTest : public ::testing::Test {};
 class ToLowerTest : public ::testing::Test {};
 class ToUpperTest : public ::testing::Test {};
 class TrimTest : public ::testing::Test {};
-class ReverseTest : public ::testing::Test {};
+class StringReverseTest : public ::testing::Test {};
 
 // --- ByteLength Tests ---
 TEST_F(ByteLengthTest, EmptyString) {
@@ -83,7 +83,8 @@ TEST_F(ByteLengthTest, EmptyByte) {
 }
 
 TEST_F(ByteLengthTest, NonStringOrBytesReturnsError) {
-  EXPECT_THAT(EvaluateExpr(*ByteLengthExpr(SharedConstant(123LL))),
+  EXPECT_THAT(EvaluateExpr(
+                  *ByteLengthExpr(SharedConstant(static_cast<int64_t>(123LL)))),
               ReturnsError());
   EXPECT_THAT(EvaluateExpr(*ByteLengthExpr(SharedConstant(true))),
               ReturnsError());
@@ -345,20 +346,21 @@ TEST_F(CharLengthTest, LargeString) {
 // --- StrConcat Tests ---
 TEST_F(StrConcatTest, MultipleStringChildrenReturnsCombination) {
   EXPECT_THAT(
-      EvaluateExpr(*StrConcatExpr(
+      EvaluateExpr(*StringConcatExpr(
           {SharedConstant("foo"), SharedConstant(" "), SharedConstant("bar")})),
       Returns(Value("foo bar")));
 }
 
 TEST_F(StrConcatTest, MultipleNonStringChildrenReturnsError) {
   EXPECT_THAT(
-      EvaluateExpr(*StrConcatExpr({SharedConstant("foo"), SharedConstant(42LL),
-                                   SharedConstant("bar")})),
+      EvaluateExpr(*StringConcatExpr(
+          {SharedConstant("foo"), SharedConstant(static_cast<int64_t>(42LL)),
+           SharedConstant("bar")})),
       ReturnsError());
 }
 
 TEST_F(StrConcatTest, MultipleCalls) {
-  auto func = StrConcatExpr(
+  auto func = StringConcatExpr(
       {SharedConstant("foo"), SharedConstant(" "), SharedConstant("bar")});
   EXPECT_THAT(EvaluateExpr(*func), Returns(Value("foo bar")));
   EXPECT_THAT(EvaluateExpr(*func),
@@ -375,7 +377,7 @@ TEST_F(StrConcatTest, LargeNumberOfInputs) {
     expected_result += "a";
   }
   // Need to construct FunctionExpr with vector directly
-  auto func = StrConcatExpr(std::move(args));
+  auto func = StringConcatExpr(std::move(args));
   EXPECT_THAT(EvaluateExpr(*func), Returns(Value(expected_result)));
 }
 
@@ -384,23 +386,25 @@ TEST_F(StrConcatTest, LargeStrings) {
   std::string b500(500, 'b');
   std::string c500(500, 'c');
   // Use .c_str() for std::string variables
-  auto func =
-      StrConcatExpr({SharedConstant(a500.c_str()), SharedConstant(b500.c_str()),
-                     SharedConstant(c500.c_str())});
+  auto func = StringConcatExpr({SharedConstant(a500.c_str()),
+                                SharedConstant(b500.c_str()),
+                                SharedConstant(c500.c_str())});
   EXPECT_THAT(EvaluateExpr(*func), Returns(Value(a500 + b500 + c500)));
 }
 
 // --- EndsWith Tests ---
 TEST_F(EndsWithTest, GetNonStringValueIsError) {
-  EXPECT_THAT(EvaluateExpr(*EndsWithExpr(SharedConstant(42LL),
-                                         SharedConstant("search"))),
-              ReturnsError());
+  EXPECT_THAT(
+      EvaluateExpr(*EndsWithExpr(SharedConstant(static_cast<int64_t>(42LL)),
+                                 SharedConstant("search"))),
+      ReturnsError());
 }
 
 TEST_F(EndsWithTest, GetNonStringSuffixIsError) {
-  EXPECT_THAT(EvaluateExpr(*EndsWithExpr(SharedConstant("search"),
-                                         SharedConstant(42LL))),
-              ReturnsError());
+  EXPECT_THAT(
+      EvaluateExpr(*EndsWithExpr(SharedConstant("search"),
+                                 SharedConstant(static_cast<int64_t>(42LL)))),
+      ReturnsError());
 }
 
 TEST_F(EndsWithTest, GetEmptyInputsReturnsTrue) {
@@ -441,14 +445,15 @@ TEST_F(EndsWithTest, GetLargeSuffixReturnsFalse) {
 
 // --- Like Tests ---
 TEST_F(LikeTest, GetNonStringLikeIsError) {
-  EXPECT_THAT(
-      EvaluateExpr(*LikeExpr(SharedConstant(42LL), SharedConstant("search"))),
-      ReturnsError());
+  EXPECT_THAT(EvaluateExpr(*LikeExpr(SharedConstant(static_cast<int64_t>(42LL)),
+                                     SharedConstant("search"))),
+              ReturnsError());
 }
 
 TEST_F(LikeTest, GetNonStringValueIsError) {
   EXPECT_THAT(
-      EvaluateExpr(*LikeExpr(SharedConstant("ear"), SharedConstant(42LL))),
+      EvaluateExpr(*LikeExpr(SharedConstant("ear"),
+                             SharedConstant(static_cast<int64_t>(42LL)))),
       ReturnsError());
 }
 
@@ -495,15 +500,17 @@ TEST_F(LikeTest, GetDynamicLike) {
 
 // --- RegexContains Tests ---
 TEST_F(RegexContainsTest, GetNonStringRegexIsError) {
-  EXPECT_THAT(EvaluateExpr(*RegexContainsExpr(SharedConstant(42LL),
-                                              SharedConstant("search"))),
+  EXPECT_THAT(EvaluateExpr(
+                  *RegexContainsExpr(SharedConstant(static_cast<int64_t>(42LL)),
+                                     SharedConstant("search"))),
               ReturnsError());
 }
 
 TEST_F(RegexContainsTest, GetNonStringValueIsError) {
-  EXPECT_THAT(EvaluateExpr(*RegexContainsExpr(SharedConstant("ear"),
-                                              SharedConstant(42LL))),
-              ReturnsError());
+  EXPECT_THAT(
+      EvaluateExpr(*RegexContainsExpr(
+          SharedConstant("ear"), SharedConstant(static_cast<int64_t>(42LL)))),
+      ReturnsError());
 }
 
 TEST_F(RegexContainsTest, GetInvalidRegexIsError) {
@@ -553,15 +560,17 @@ TEST_F(RegexContainsTest, GetDynamicRegex) {
 
 // --- RegexMatch Tests ---
 TEST_F(RegexMatchTest, GetNonStringRegexIsError) {
-  EXPECT_THAT(EvaluateExpr(*RegexMatchExpr(SharedConstant(42LL),
-                                           SharedConstant("search"))),
-              ReturnsError());
+  EXPECT_THAT(
+      EvaluateExpr(*RegexMatchExpr(SharedConstant(static_cast<int64_t>(42LL)),
+                                   SharedConstant("search"))),
+      ReturnsError());
 }
 
 TEST_F(RegexMatchTest, GetNonStringValueIsError) {
-  EXPECT_THAT(EvaluateExpr(
-                  *RegexMatchExpr(SharedConstant("ear"), SharedConstant(42LL))),
-              ReturnsError());
+  EXPECT_THAT(
+      EvaluateExpr(*RegexMatchExpr(SharedConstant("ear"),
+                                   SharedConstant(static_cast<int64_t>(42LL)))),
+      ReturnsError());
 }
 
 TEST_F(RegexMatchTest, GetInvalidRegexIsError) {
@@ -617,15 +626,17 @@ TEST_F(RegexMatchTest, GetDynamicRegex) {
 
 // --- StartsWith Tests ---
 TEST_F(StartsWithTest, GetNonStringValueIsError) {
-  EXPECT_THAT(EvaluateExpr(*StartsWithExpr(SharedConstant(42LL),
-                                           SharedConstant("search"))),
-              ReturnsError());
+  EXPECT_THAT(
+      EvaluateExpr(*StartsWithExpr(SharedConstant(static_cast<int64_t>(42LL)),
+                                   SharedConstant("search"))),
+      ReturnsError());
 }
 
 TEST_F(StartsWithTest, GetNonStringPrefixIsError) {
-  EXPECT_THAT(EvaluateExpr(*StartsWithExpr(SharedConstant("search"),
-                                           SharedConstant(42LL))),
-              ReturnsError());
+  EXPECT_THAT(
+      EvaluateExpr(*StartsWithExpr(SharedConstant("search"),
+                                   SharedConstant(static_cast<int64_t>(42LL)))),
+      ReturnsError());
 }
 
 TEST_F(StartsWithTest, GetEmptyInputsReturnsTrue) {
@@ -666,50 +677,52 @@ TEST_F(StartsWithTest, GetLargePrefixReturnsFalse) {
 
 // --- StrContains Tests ---
 TEST_F(StrContainsTest, ValueNonStringIsError) {
-  EXPECT_THAT(EvaluateExpr(*StrContainsExpr(SharedConstant(42LL),
-                                            SharedConstant("value"))),
-              ReturnsError());
+  EXPECT_THAT(
+      EvaluateExpr(*StringContainsExpr(
+          SharedConstant(static_cast<int64_t>(42LL)), SharedConstant("value"))),
+      ReturnsError());
 }
 
 TEST_F(StrContainsTest, SubStringNonStringIsError) {
-  EXPECT_THAT(EvaluateExpr(*StrContainsExpr(SharedConstant("search space"),
-                                            SharedConstant(42LL))),
+  EXPECT_THAT(EvaluateExpr(*StringContainsExpr(
+                  SharedConstant("search space"),
+                  SharedConstant(static_cast<int64_t>(42LL)))),
               ReturnsError());
 }
 
 TEST_F(StrContainsTest, ExecuteTrue) {
-  EXPECT_THAT(EvaluateExpr(
-                  *StrContainsExpr(SharedConstant("abc"), SharedConstant("c"))),
+  EXPECT_THAT(EvaluateExpr(*StringContainsExpr(SharedConstant("abc"),
+                                               SharedConstant("c"))),
               Returns(Value(true)));
-  EXPECT_THAT(EvaluateExpr(*StrContainsExpr(SharedConstant("abc"),
-                                            SharedConstant("bc"))),
+  EXPECT_THAT(EvaluateExpr(*StringContainsExpr(SharedConstant("abc"),
+                                               SharedConstant("bc"))),
               Returns(Value(true)));
-  EXPECT_THAT(EvaluateExpr(*StrContainsExpr(SharedConstant("abc"),
-                                            SharedConstant("abc"))),
+  EXPECT_THAT(EvaluateExpr(*StringContainsExpr(SharedConstant("abc"),
+                                               SharedConstant("abc"))),
+              Returns(Value(true)));
+  EXPECT_THAT(EvaluateExpr(*StringContainsExpr(SharedConstant("abc"),
+                                               SharedConstant(""))),
               Returns(Value(true)));
   EXPECT_THAT(
-      EvaluateExpr(*StrContainsExpr(SharedConstant("abc"), SharedConstant(""))),
-      Returns(Value(true)));
-  EXPECT_THAT(
-      EvaluateExpr(*StrContainsExpr(SharedConstant(""), SharedConstant(""))),
+      EvaluateExpr(*StringContainsExpr(SharedConstant(""), SharedConstant(""))),
       Returns(Value(true)));
-  EXPECT_THAT(EvaluateExpr(
-                  *StrContainsExpr(SharedConstant("☃☃☃"), SharedConstant("☃"))),
+  EXPECT_THAT(EvaluateExpr(*StringContainsExpr(SharedConstant("☃☃☃"),
+                                               SharedConstant("☃"))),
               Returns(Value(true)));
 }
 
 TEST_F(StrContainsTest, ExecuteFalse) {
-  EXPECT_THAT(EvaluateExpr(*StrContainsExpr(SharedConstant("abc"),
-                                            SharedConstant("abcd"))),
+  EXPECT_THAT(EvaluateExpr(*StringContainsExpr(SharedConstant("abc"),
+                                               SharedConstant("abcd"))),
+              Returns(Value(false)));
+  EXPECT_THAT(EvaluateExpr(*StringContainsExpr(SharedConstant("abc"),
+                                               SharedConstant("d"))),
               Returns(Value(false)));
   EXPECT_THAT(EvaluateExpr(
-                  *StrContainsExpr(SharedConstant("abc"), SharedConstant("d"))),
+                  *StringContainsExpr(SharedConstant(""), SharedConstant("a"))),
               Returns(Value(false)));
-  EXPECT_THAT(
-      EvaluateExpr(*StrContainsExpr(SharedConstant(""), SharedConstant("a"))),
-      Returns(Value(false)));
-  EXPECT_THAT(EvaluateExpr(*StrContainsExpr(SharedConstant(""),
-                                            SharedConstant("abcde"))),
+  EXPECT_THAT(EvaluateExpr(*StringContainsExpr(SharedConstant(""),
+                                               SharedConstant("abcde"))),
               Returns(Value(false)));
 }
 
@@ -725,8 +738,9 @@ TEST_F(ToLowerTest, Empty) {
 }
 
 TEST_F(ToLowerTest, NonString) {
-  EXPECT_THAT(EvaluateExpr(*ToLowerExpr(SharedConstant(123LL))),
-              ReturnsError());
+  EXPECT_THAT(
+      EvaluateExpr(*ToLowerExpr(SharedConstant(static_cast<int64_t>(123LL)))),
+      ReturnsError());
 }
 
 TEST_F(ToLowerTest, Null) {
@@ -746,8 +760,9 @@ TEST_F(ToUpperTest, Empty) {
 }
 
 TEST_F(ToUpperTest, NonString) {
-  EXPECT_THAT(EvaluateExpr(*ToUpperExpr(SharedConstant(123LL))),
-              ReturnsError());
+  EXPECT_THAT(
+      EvaluateExpr(*ToUpperExpr(SharedConstant(static_cast<int64_t>(123LL)))),
+      ReturnsError());
 }
 
 TEST_F(ToUpperTest, Null) {
@@ -776,36 +791,39 @@ TEST_F(TrimTest, Empty) {
 }
 
 TEST_F(TrimTest, NonString) {
-  EXPECT_THAT(EvaluateExpr(*TrimExpr(SharedConstant(123LL))), ReturnsError());
+  EXPECT_THAT(
+      EvaluateExpr(*TrimExpr(SharedConstant(static_cast<int64_t>(123LL)))),
+      ReturnsError());
 }
 
 TEST_F(TrimTest, Null) {
   EXPECT_THAT(EvaluateExpr(*TrimExpr(SharedConstant(nullptr))), ReturnsNull());
 }
 
-// --- Reverse Tests ---
-TEST_F(ReverseTest, Basic) {
-  EXPECT_THAT(EvaluateExpr(*ReverseExpr(SharedConstant("abc"))),
+// --- StringReverse Tests ---
+TEST_F(StringReverseTest, Basic) {
+  EXPECT_THAT(EvaluateExpr(*StringReverseExpr(SharedConstant("abc"))),
               Returns(Value("cba")));
 }
 
-TEST_F(ReverseTest, Empty) {
-  EXPECT_THAT(EvaluateExpr(*ReverseExpr(SharedConstant(""))),
+TEST_F(StringReverseTest, Empty) {
+  EXPECT_THAT(EvaluateExpr(*StringReverseExpr(SharedConstant(""))),
               Returns(Value("")));
 }
 
-TEST_F(ReverseTest, Unicode) {
-  EXPECT_THAT(EvaluateExpr(*ReverseExpr(SharedConstant("aé好🂡"))),
+TEST_F(StringReverseTest, Unicode) {
+  EXPECT_THAT(EvaluateExpr(*StringReverseExpr(SharedConstant("aé好🂡"))),
               Returns(Value("🂡好éa")));
 }
 
-TEST_F(ReverseTest, NonString) {
-  EXPECT_THAT(EvaluateExpr(*ReverseExpr(SharedConstant(123LL))),
+TEST_F(StringReverseTest, NonString) {
+  EXPECT_THAT(EvaluateExpr(*StringReverseExpr(
+                  SharedConstant(static_cast<int64_t>(123LL)))),
               ReturnsError());
 }
 
-TEST_F(ReverseTest, Null) {
-  EXPECT_THAT(EvaluateExpr(*ReverseExpr(SharedConstant(nullptr))),
+TEST_F(StringReverseTest, Null) {
+  EXPECT_THAT(EvaluateExpr(*StringReverseExpr(SharedConstant(nullptr))),
               ReturnsNull());
 }
 
diff --git a/Firestore/core/test/unit/core/expressions/timestamp_test.cc b/Firestore/core/test/unit/core/expressions/timestamp_test.cc
index b91dbbff7db..d2fbbaea9f3 100644
--- a/Firestore/core/test/unit/core/expressions/timestamp_test.cc
+++ b/Firestore/core/test/unit/core/expressions/timestamp_test.cc
@@ -48,20 +48,21 @@ TEST_F(UnixMicrosToTimestampTest, StringTypeReturnsError) {
 }
 
 TEST_F(UnixMicrosToTimestampTest, ZeroValueReturnsTimestampEpoch) {
-  EXPECT_THAT(EvaluateExpr(*UnixMicrosToTimestampExpr(SharedConstant(0LL))),
+  EXPECT_THAT(EvaluateExpr(*UnixMicrosToTimestampExpr(
+                  SharedConstant(static_cast<int64_t>(0LL)))),
               Returns(Value(Timestamp(0, 0))));
 }
 
 TEST_F(UnixMicrosToTimestampTest, IntTypeReturnsTimestamp) {
-  EXPECT_THAT(
-      EvaluateExpr(*UnixMicrosToTimestampExpr(SharedConstant(1000000LL))),
-      Returns(Value(Timestamp(1, 0))));
+  EXPECT_THAT(EvaluateExpr(*UnixMicrosToTimestampExpr(
+                  SharedConstant(static_cast<int64_t>(1000000LL)))),
+              Returns(Value(Timestamp(1, 0))));
 }
 
 TEST_F(UnixMicrosToTimestampTest, LongTypeReturnsTimestamp) {
-  EXPECT_THAT(
-      EvaluateExpr(*UnixMicrosToTimestampExpr(SharedConstant(9876543210LL))),
-      Returns(Value(Timestamp(9876, 543210000))));
+  EXPECT_THAT(EvaluateExpr(*UnixMicrosToTimestampExpr(
+                  SharedConstant(static_cast<int64_t>(9876543210LL)))),
+              Returns(Value(Timestamp(9876, 543210000))));
 }
 
 TEST_F(UnixMicrosToTimestampTest, LongTypeNegativeReturnsTimestamp) {
@@ -70,9 +71,9 @@ TEST_F(UnixMicrosToTimestampTest, LongTypeNegativeReturnsTimestamp) {
   timestamp.which_value_type = google_firestore_v1_Value_timestamp_value_tag;
   timestamp.timestamp_value.seconds = -1;
   timestamp.timestamp_value.nanos = 990000000;
-  EXPECT_THAT(
-      EvaluateExpr(*UnixMicrosToTimestampExpr(SharedConstant(-10000LL))),
-      Returns(nanopb::MakeMessage(timestamp)));
+  EXPECT_THAT(EvaluateExpr(*UnixMicrosToTimestampExpr(
+                  SharedConstant(static_cast<int64_t>(-10000LL)))),
+              Returns(nanopb::MakeMessage(timestamp)));
 }
 
 TEST_F(UnixMicrosToTimestampTest, LongTypeNegativeOverflowReturnsError) {
@@ -86,8 +87,8 @@ TEST_F(UnixMicrosToTimestampTest, LongTypeNegativeOverflowReturnsError) {
       Returns(Value(Timestamp(-62135596800LL, 0))));
 
   // Test value just below the boundary (using subtraction)
-  auto below_min_expr =
-      SubtractExpr({SharedConstant(min_micros), SharedConstant(1LL)});
+  auto below_min_expr = SubtractExpr(
+      {SharedConstant(min_micros), SharedConstant(static_cast<int64_t>(1LL))});
   EXPECT_THAT(
       EvaluateExpr(*UnixMicrosToTimestampExpr(std::move(below_min_expr))),
       testutil::ReturnsError());  // Fully qualify
@@ -123,25 +124,27 @@ TEST_F(UnixMillisToTimestampTest, StringTypeReturnsError) {
 }
 
 TEST_F(UnixMillisToTimestampTest, ZeroValueReturnsTimestampEpoch) {
-  EXPECT_THAT(EvaluateExpr(*UnixMillisToTimestampExpr(SharedConstant(0LL))),
+  EXPECT_THAT(EvaluateExpr(*UnixMillisToTimestampExpr(
+                  SharedConstant(static_cast<int64_t>(0LL)))),
               Returns(Value(Timestamp(0, 0))));
 }
 
 TEST_F(UnixMillisToTimestampTest, IntTypeReturnsTimestamp) {
-  EXPECT_THAT(EvaluateExpr(*UnixMillisToTimestampExpr(SharedConstant(1000LL))),
+  EXPECT_THAT(EvaluateExpr(*UnixMillisToTimestampExpr(
+                  SharedConstant(static_cast<int64_t>(1000LL)))),
               Returns(Value(Timestamp(1, 0))));
 }
 
 TEST_F(UnixMillisToTimestampTest, LongTypeReturnsTimestamp) {
-  EXPECT_THAT(
-      EvaluateExpr(*UnixMillisToTimestampExpr(SharedConstant(9876543210LL))),
-      Returns(Value(Timestamp(9876543, 210000000))));
+  EXPECT_THAT(EvaluateExpr(*UnixMillisToTimestampExpr(
+                  SharedConstant(static_cast<int64_t>(9876543210LL)))),
+              Returns(Value(Timestamp(9876543, 210000000))));
 }
 
 TEST_F(UnixMillisToTimestampTest, LongTypeNegativeReturnsTimestamp) {
-  EXPECT_THAT(
-      EvaluateExpr(*UnixMillisToTimestampExpr(SharedConstant(-10000LL))),
-      Returns(Value(Timestamp(-10, 0))));
+  EXPECT_THAT(EvaluateExpr(*UnixMillisToTimestampExpr(
+                  SharedConstant(static_cast<int64_t>(-10000LL)))),
+              Returns(Value(Timestamp(-10, 0))));
 }
 
 TEST_F(UnixMillisToTimestampTest, LongTypeNegativeOverflowReturnsError) {
@@ -187,25 +190,27 @@ TEST_F(UnixSecondsToTimestampTest, StringTypeReturnsError) {
 }
 
 TEST_F(UnixSecondsToTimestampTest, ZeroValueReturnsTimestampEpoch) {
-  EXPECT_THAT(EvaluateExpr(*UnixSecondsToTimestampExpr(SharedConstant(0LL))),
+  EXPECT_THAT(EvaluateExpr(*UnixSecondsToTimestampExpr(
+                  SharedConstant(static_cast<int64_t>(0LL)))),
               Returns(Value(Timestamp(0, 0))));
 }
 
 TEST_F(UnixSecondsToTimestampTest, IntTypeReturnsTimestamp) {
-  EXPECT_THAT(EvaluateExpr(*UnixSecondsToTimestampExpr(SharedConstant(1LL))),
+  EXPECT_THAT(EvaluateExpr(*UnixSecondsToTimestampExpr(
+                  SharedConstant(static_cast<int64_t>(1LL)))),
               Returns(Value(Timestamp(1, 0))));
 }
 
 TEST_F(UnixSecondsToTimestampTest, LongTypeReturnsTimestamp) {
-  EXPECT_THAT(
-      EvaluateExpr(*UnixSecondsToTimestampExpr(SharedConstant(9876543210LL))),
-      Returns(Value(Timestamp(9876543210LL, 0))));
+  EXPECT_THAT(EvaluateExpr(*UnixSecondsToTimestampExpr(
+                  SharedConstant(static_cast<int64_t>(9876543210LL)))),
+              Returns(Value(Timestamp(9876543210LL, 0))));
 }
 
 TEST_F(UnixSecondsToTimestampTest, LongTypeNegativeReturnsTimestamp) {
-  EXPECT_THAT(
-      EvaluateExpr(*UnixSecondsToTimestampExpr(SharedConstant(-10000LL))),
-      Returns(Value(Timestamp(-10000LL, 0))));
+  EXPECT_THAT(EvaluateExpr(*UnixSecondsToTimestampExpr(
+                  SharedConstant(static_cast<int64_t>(-10000LL)))),
+              Returns(Value(Timestamp(-10000LL, 0))));
 }
 
 TEST_F(UnixSecondsToTimestampTest, LongTypeNegativeOverflowReturnsError) {
@@ -244,7 +249,8 @@ class TimestampToUnixMicrosTest : public TimestampExpressionsTest {};
 using testutil::TimestampToUnixMicrosExpr;  // Add using declaration
 
 TEST_F(TimestampToUnixMicrosTest, NonTimestampTypeReturnsError) {
-  EXPECT_THAT(EvaluateExpr(*TimestampToUnixMicrosExpr(SharedConstant(123LL))),
+  EXPECT_THAT(EvaluateExpr(*TimestampToUnixMicrosExpr(
+                  SharedConstant(static_cast<int64_t>(123LL)))),
               testutil::ReturnsError());
 }
 
@@ -324,7 +330,8 @@ class TimestampToUnixMillisTest : public TimestampExpressionsTest {};
 using testutil::TimestampToUnixMillisExpr;  // Add using declaration
 
 TEST_F(TimestampToUnixMillisTest, NonTimestampTypeReturnsError) {
-  EXPECT_THAT(EvaluateExpr(*TimestampToUnixMillisExpr(SharedConstant(123LL))),
+  EXPECT_THAT(EvaluateExpr(*TimestampToUnixMillisExpr(
+                  SharedConstant(static_cast<int64_t>(123LL)))),
               testutil::ReturnsError());
 }
 
@@ -397,7 +404,8 @@ class TimestampToUnixSecondsTest : public TimestampExpressionsTest {};
 using testutil::TimestampToUnixSecondsExpr;  // Add using declaration
 
 TEST_F(TimestampToUnixSecondsTest, NonTimestampTypeReturnsError) {
-  EXPECT_THAT(EvaluateExpr(*TimestampToUnixSecondsExpr(SharedConstant(123LL))),
+  EXPECT_THAT(EvaluateExpr(*TimestampToUnixSecondsExpr(
+                  SharedConstant(static_cast<int64_t>(123LL)))),
               testutil::ReturnsError());
 }
 
@@ -475,55 +483,55 @@ using testutil::ReturnsNull;       // Add using declaration for null checks
 using testutil::TimestampAddExpr;  // Add using declaration
 
 TEST_F(TimestampAddTest, TimestampAddStringTypeReturnsError) {
-  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(SharedConstant("abc"),
-                                             SharedConstant("second"),
-                                             SharedConstant(1LL))),
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant("abc"), SharedConstant("second"),
+                  SharedConstant(static_cast<int64_t>(1LL)))),
               testutil::ReturnsError());
 }
 
 TEST_F(TimestampAddTest, TimestampAddZeroValueReturnsTimestampEpoch) {
   Timestamp epoch(0, 0);
-  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(SharedConstant(epoch),
-                                             SharedConstant("second"),
-                                             SharedConstant(0LL))),
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant(epoch), SharedConstant("second"),
+                  SharedConstant(static_cast<int64_t>(0LL)))),
               Returns(Value(epoch)));
 }
 
 TEST_F(TimestampAddTest, TimestampAddIntTypeReturnsTimestamp) {
   Timestamp epoch(0, 0);
-  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(SharedConstant(epoch),
-                                             SharedConstant("second"),
-                                             SharedConstant(1LL))),
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant(epoch), SharedConstant("second"),
+                  SharedConstant(static_cast<int64_t>(1LL)))),
               Returns(Value(Timestamp(1, 0))));
 }
 
 TEST_F(TimestampAddTest, TimestampAddLongTypeReturnsTimestamp) {
   Timestamp epoch(0, 0);
-  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(SharedConstant(epoch),
-                                             SharedConstant("second"),
-                                             SharedConstant(9876543210LL))),
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant(epoch), SharedConstant("second"),
+                  SharedConstant(static_cast<int64_t>(9876543210LL)))),
               Returns(Value(Timestamp(9876543210LL, 0))));
 }
 
 TEST_F(TimestampAddTest, TimestampAddLongTypeNegativeReturnsTimestamp) {
   Timestamp epoch(0, 0);
-  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(SharedConstant(epoch),
-                                             SharedConstant("second"),
-                                             SharedConstant(-10000LL))),
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant(epoch), SharedConstant("second"),
+                  SharedConstant(static_cast<int64_t>(-10000LL)))),
               Returns(Value(Timestamp(-10000LL, 0))));
 }
 
 TEST_F(TimestampAddTest, TimestampAddLongTypeNegativeOverflowReturnsError) {
   Timestamp min_ts(-62135596800LL, 0);
   // Test adding 0 (boundary)
-  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(SharedConstant(min_ts),
-                                             SharedConstant("second"),
-                                             SharedConstant(0LL))),
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant(min_ts), SharedConstant("second"),
+                  SharedConstant(static_cast<int64_t>(0LL)))),
               Returns(Value(min_ts)));
   // Test adding -1 (overflow)
-  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(SharedConstant(min_ts),
-                                             SharedConstant("second"),
-                                             SharedConstant(-1LL))),
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant(min_ts), SharedConstant("second"),
+                  SharedConstant(static_cast<int64_t>(-1LL)))),
               testutil::ReturnsError());
 }
 
@@ -533,73 +541,73 @@ TEST_F(TimestampAddTest, TimestampAddLongTypePositiveOverflowReturnsError) {
   EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
                   SharedConstant(max_ts),
                   SharedConstant("microsecond"),  // Smallest unit
-                  SharedConstant(0LL))),
+                  SharedConstant(static_cast<int64_t>(0LL)))),
               Returns(Value(max_ts)));  // Expect the same max timestamp
 
   // Test adding 1 microsecond (should overflow)
-  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(SharedConstant(max_ts),
-                                             SharedConstant("microsecond"),
-                                             SharedConstant(1LL))),
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant(max_ts), SharedConstant("microsecond"),
+                  SharedConstant(static_cast<int64_t>(1LL)))),
               testutil::ReturnsError());
 
   // Test adding 1 second to a timestamp close to max
   Timestamp near_max_ts(253402300799LL, 0);
-  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(SharedConstant(near_max_ts),
-                                             SharedConstant("second"),
-                                             SharedConstant(0LL))),
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant(near_max_ts), SharedConstant("second"),
+                  SharedConstant(static_cast<int64_t>(0LL)))),
               Returns(Value(near_max_ts)));
-  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(SharedConstant(near_max_ts),
-                                             SharedConstant("second"),
-                                             SharedConstant(1LL))),
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant(near_max_ts), SharedConstant("second"),
+                  SharedConstant(static_cast<int64_t>(1LL)))),
               testutil::ReturnsError());
 }
 
 TEST_F(TimestampAddTest, TimestampAddLongTypeMinuteReturnsTimestamp) {
   Timestamp epoch(0, 0);
-  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(SharedConstant(epoch),
-                                             SharedConstant("minute"),
-                                             SharedConstant(1LL))),
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant(epoch), SharedConstant("minute"),
+                  SharedConstant(static_cast<int64_t>(1LL)))),
               Returns(Value(Timestamp(60, 0))));
 }
 
 TEST_F(TimestampAddTest, TimestampAddLongTypeHourReturnsTimestamp) {
   Timestamp epoch(0, 0);
-  EXPECT_THAT(
-      EvaluateExpr(*TimestampAddExpr(
-          SharedConstant(epoch), SharedConstant("hour"), SharedConstant(1LL))),
-      Returns(Value(Timestamp(3600, 0))));
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant(epoch), SharedConstant("hour"),
+                  SharedConstant(static_cast<int64_t>(1LL)))),
+              Returns(Value(Timestamp(3600, 0))));
 }
 
 TEST_F(TimestampAddTest, TimestampAddLongTypeDayReturnsTimestamp) {
   Timestamp epoch(0, 0);
-  EXPECT_THAT(
-      EvaluateExpr(*TimestampAddExpr(
-          SharedConstant(epoch), SharedConstant("day"), SharedConstant(1LL))),
-      Returns(Value(Timestamp(86400, 0))));
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant(epoch), SharedConstant("day"),
+                  SharedConstant(static_cast<int64_t>(1LL)))),
+              Returns(Value(Timestamp(86400, 0))));
 }
 
 TEST_F(TimestampAddTest, TimestampAddLongTypeMillisecondReturnsTimestamp) {
   Timestamp epoch(0, 0);
-  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(SharedConstant(epoch),
-                                             SharedConstant("millisecond"),
-                                             SharedConstant(1LL))),
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant(epoch), SharedConstant("millisecond"),
+                  SharedConstant(static_cast<int64_t>(1LL)))),
               Returns(Value(Timestamp(0, 1000000))));
 }
 
 TEST_F(TimestampAddTest, TimestampAddLongTypeMicrosecondReturnsTimestamp) {
   Timestamp epoch(0, 0);
-  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(SharedConstant(epoch),
-                                             SharedConstant("microsecond"),
-                                             SharedConstant(1LL))),
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant(epoch), SharedConstant("microsecond"),
+                  SharedConstant(static_cast<int64_t>(1LL)))),
               Returns(Value(Timestamp(0, 1000))));
 }
 
 TEST_F(TimestampAddTest, TimestampAddInvalidTimeUnitReturnsError) {
   Timestamp epoch(0, 0);
-  EXPECT_THAT(
-      EvaluateExpr(*TimestampAddExpr(
-          SharedConstant(epoch), SharedConstant("abc"), SharedConstant(1LL))),
-      testutil::ReturnsError());
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant(epoch), SharedConstant("abc"),
+                  SharedConstant(static_cast<int64_t>(1LL)))),
+              testutil::ReturnsError());
 }
 
 TEST_F(TimestampAddTest, TimestampAddInvalidAmountReturnsError) {
@@ -620,16 +628,16 @@ TEST_F(TimestampAddTest, TimestampAddNullAmountReturnsNull) {
 
 TEST_F(TimestampAddTest, TimestampAddNullTimeUnitReturnsNull) {
   Timestamp epoch(0, 0);
-  EXPECT_THAT(
-      EvaluateExpr(*TimestampAddExpr(
-          SharedConstant(epoch), SharedConstant(nullptr), SharedConstant(1LL))),
-      ReturnsNull());
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant(epoch), SharedConstant(nullptr),
+                  SharedConstant(static_cast<int64_t>(1LL)))),
+              ReturnsNull());
 }
 
 TEST_F(TimestampAddTest, TimestampAddNullTimestampReturnsNull) {
-  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(SharedConstant(nullptr),
-                                             SharedConstant("second"),
-                                             SharedConstant(1LL))),
+  EXPECT_THAT(EvaluateExpr(*TimestampAddExpr(
+                  SharedConstant(nullptr), SharedConstant("second"),
+                  SharedConstant(static_cast<int64_t>(1LL)))),
               ReturnsNull());
 }
 
diff --git a/Firestore/core/test/unit/core/pipeline/canonify_eq_test.cc b/Firestore/core/test/unit/core/pipeline/canonify_eq_test.cc
index 7a8f4caab57..14ff272dc02 100644
--- a/Firestore/core/test/unit/core/pipeline/canonify_eq_test.cc
+++ b/Firestore/core/test/unit/core/pipeline/canonify_eq_test.cc
@@ -71,7 +71,7 @@ using testutil::SharedConstant;
 using testutil::Value;
 // Expression helpers
 using testutil::EqAnyExpr;
-using testutil::EqExpr;
+using testutil::EqualExpr;
 
 // Helper to get canonical ID directly for RealtimePipeline
 std::string GetPipelineCanonicalId(const RealtimePipeline& pipeline) {
@@ -119,25 +119,27 @@ class CanonifyEqPipelineTest : public ::testing::Test {
 
 TEST_F(CanonifyEqPipelineTest, CanonifySimpleWhere) {
   RealtimePipeline p = StartPipeline("test");
-  p = p.AddingStage(std::make_shared<Where>(EqExpr(
+  p = p.AddingStage(std::make_shared<Where>(EqualExpr(
       {std::make_shared<api::Field>("foo"), SharedConstant(Value(42LL))})));
 
-  EXPECT_EQ(GetPipelineCanonicalId(p),
-            "collection(test)|where(fn(eq[fld(foo),cst(42)]))|sort(fld(__name__"
-            ")asc)");
+  EXPECT_EQ(
+      GetPipelineCanonicalId(p),
+      "collection(test)|where(fn(equal[fld(foo),cst(42)]))|sort(fld(__name__"
+      ")asc)");
 }
 
 TEST_F(CanonifyEqPipelineTest, CanonifyMultipleStages) {
   RealtimePipeline p = StartPipeline("test");
-  p = p.AddingStage(std::make_shared<Where>(EqExpr(
+  p = p.AddingStage(std::make_shared<Where>(EqualExpr(
       {std::make_shared<api::Field>("foo"), SharedConstant(Value(42LL))})));
   p = p.AddingStage(std::make_shared<LimitStage>(10));
   p = p.AddingStage(std::make_shared<SortStage>(
       std::vector<Ordering>{Ordering(std::make_shared<api::Field>("bar"),
                                      api::Ordering::Direction::DESCENDING)}));
-  EXPECT_EQ(GetPipelineCanonicalId(p),
-            "collection(test)|where(fn(eq[fld(foo),cst(42)]))|sort(fld(__name__"
-            ")asc)|limit(10)|sort(fld(bar)desc,fld(__name__)asc)");
+  EXPECT_EQ(
+      GetPipelineCanonicalId(p),
+      "collection(test)|where(fn(equal[fld(foo),cst(42)]))|sort(fld(__name__"
+      ")asc)|limit(10)|sort(fld(bar)desc,fld(__name__)asc)");
 }
 
 // TEST_F(CanonifyEqPipelineTest, CanonifyAddFields) {
@@ -228,7 +230,7 @@ TEST_F(CanonifyEqPipelineTest, CanonifyCollectionGroupSource) {
 //       Value("b"))))));
 //
 //   EXPECT_EQ(GetPipelineCanonicalId(p),
-//             "collection(/foo)|where(fn(eq_any,[fld(bar),list([cst(\"a\"),cst(\"b\")])]))|sort(fld(__name__)asc)");
+//             collection(/foo)|where(fn(equal_any,[fld(bar),list([cst("a"),cst("b")])]))|sort(fld(__name__)asc));
 // }
 
 // ===================================================================
@@ -239,11 +241,11 @@ TEST_F(CanonifyEqPipelineTest, CanonifyCollectionGroupSource) {
 
 TEST_F(CanonifyEqPipelineTest, EqReturnsTrueForIdenticalPipelines) {
   RealtimePipeline p1 = StartPipeline("test");
-  p1 = p1.AddingStage(std::make_shared<Where>(EqExpr(
+  p1 = p1.AddingStage(std::make_shared<Where>(EqualExpr(
       {std::make_shared<api::Field>("foo"), SharedConstant(Value(42LL))})));
 
   RealtimePipeline p2 = StartPipeline("test");
-  p2 = p2.AddingStage(std::make_shared<Where>(EqExpr(
+  p2 = p2.AddingStage(std::make_shared<Where>(EqualExpr(
       {std::make_shared<api::Field>("foo"), SharedConstant(Value(42LL))})));
 
   QueryOrPipeline v1 = QueryOrPipeline(p1);
@@ -253,7 +255,7 @@ TEST_F(CanonifyEqPipelineTest, EqReturnsTrueForIdenticalPipelines) {
 
 TEST_F(CanonifyEqPipelineTest, EqReturnsFalseForDifferentStages) {
   RealtimePipeline p1 = StartPipeline("test");
-  p1 = p1.AddingStage(std::make_shared<Where>(EqExpr(
+  p1 = p1.AddingStage(std::make_shared<Where>(EqualExpr(
       {std::make_shared<api::Field>("foo"), SharedConstant(Value(42LL))})));
 
   RealtimePipeline p2 = StartPipeline("test");
@@ -266,13 +268,13 @@ TEST_F(CanonifyEqPipelineTest, EqReturnsFalseForDifferentStages) {
 
 TEST_F(CanonifyEqPipelineTest, EqReturnsFalseForDifferentParamsInStage) {
   RealtimePipeline p1 = StartPipeline("test");
-  p1 = p1.AddingStage(std::make_shared<Where>(EqExpr(
+  p1 = p1.AddingStage(std::make_shared<Where>(EqualExpr(
       {std::make_shared<api::Field>("foo"), SharedConstant(Value(42LL))})));
 
   RealtimePipeline p2 = StartPipeline("test");
   p2 = p2.AddingStage(std::make_shared<Where>(
-      EqExpr({std::make_shared<api::Field>("bar"),
-              SharedConstant(Value(42LL))})));  // Different field
+      EqualExpr({std::make_shared<api::Field>("bar"),
+                 SharedConstant(Value(42LL))})));  // Different field
 
   QueryOrPipeline v1 = QueryOrPipeline(p1);
   QueryOrPipeline v2 = QueryOrPipeline(p2);
@@ -281,13 +283,13 @@ TEST_F(CanonifyEqPipelineTest, EqReturnsFalseForDifferentParamsInStage) {
 
 TEST_F(CanonifyEqPipelineTest, EqReturnsFalseForDifferentStageOrder) {
   RealtimePipeline p1 = StartPipeline("test");
-  p1 = p1.AddingStage(std::make_shared<Where>(EqExpr(
+  p1 = p1.AddingStage(std::make_shared<Where>(EqualExpr(
       {std::make_shared<api::Field>("foo"), SharedConstant(Value(42LL))})));
   p1 = p1.AddingStage(std::make_shared<LimitStage>(10));
 
   RealtimePipeline p2 = StartPipeline("test");
   p2 = p2.AddingStage(std::make_shared<LimitStage>(10));
-  p2 = p2.AddingStage(std::make_shared<Where>(EqExpr(
+  p2 = p2.AddingStage(std::make_shared<Where>(EqualExpr(
       {std::make_shared<api::Field>("foo"), SharedConstant(Value(42LL))})));
 
   QueryOrPipeline v1 = QueryOrPipeline(p1);
diff --git a/Firestore/core/test/unit/core/pipeline/collection_group_test.cc b/Firestore/core/test/unit/core/pipeline/collection_group_test.cc
index c3e1c21eb71..b350caba5ed 100644
--- a/Firestore/core/test/unit/core/pipeline/collection_group_test.cc
+++ b/Firestore/core/test/unit/core/pipeline/collection_group_test.cc
@@ -55,9 +55,9 @@ using testutil::Array;
 using testutil::ArrayContainsExpr;
 using testutil::Doc;
 using testutil::EqAnyExpr;
-using testutil::GtExpr;
+using testutil::GreaterThanExpr;
 using testutil::Map;
-using testutil::NeqExpr;
+using testutil::NotEqualExpr;
 using testutil::SharedConstant;
 using testutil::Value;
 
@@ -230,7 +230,8 @@ TEST_F(CollectionGroupTest, WhereOnValues) {
 TEST_F(CollectionGroupTest, WhereInequalityOnValues) {
   RealtimePipeline pipeline = StartPipeline("users");
   auto where_expr =
-      GtExpr({std::make_shared<Field>("score"), SharedConstant(80LL)});
+      GreaterThanExpr({std::make_shared<Field>("score"),
+                       SharedConstant(static_cast<int64_t>(80LL))});
   pipeline = pipeline.AddingStage(std::make_shared<Where>(where_expr));
 
   auto doc1 = Doc("users/bob", 1000, Map("score", 90LL));
@@ -249,8 +250,8 @@ TEST_F(CollectionGroupTest, WhereInequalityOnValues) {
 
 TEST_F(CollectionGroupTest, WhereNotEqualOnValues) {
   RealtimePipeline pipeline = StartPipeline("users");
-  auto where_expr =
-      NeqExpr({std::make_shared<Field>("score"), SharedConstant(50LL)});
+  auto where_expr = NotEqualExpr({std::make_shared<Field>("score"),
+                                  SharedConstant(static_cast<int64_t>(50LL))});
   pipeline = pipeline.AddingStage(std::make_shared<Where>(where_expr));
 
   auto doc1 = Doc("users/bob", 1000, Map("score", 90LL));
diff --git a/Firestore/core/test/unit/core/pipeline/collection_test.cc b/Firestore/core/test/unit/core/pipeline/collection_test.cc
index 5e02ad433e9..8c70855cf91 100644
--- a/Firestore/core/test/unit/core/pipeline/collection_test.cc
+++ b/Firestore/core/test/unit/core/pipeline/collection_test.cc
@@ -54,9 +54,9 @@ using testutil::Array;
 using testutil::ArrayContainsExpr;
 using testutil::Doc;
 using testutil::EqAnyExpr;
-using testutil::GtExpr;
+using testutil::GreaterThanExpr;
 using testutil::Map;
-using testutil::NeqExpr;
+using testutil::NotEqualExpr;
 using testutil::SharedConstant;
 using testutil::Value;
 
@@ -224,7 +224,8 @@ TEST_F(CollectionTest, WhereOnValues) {
 TEST_F(CollectionTest, WhereInequalityOnValues) {
   RealtimePipeline pipeline = StartPipeline("/users");  // Use RealtimePipeline
   auto where_expr =
-      GtExpr({std::make_shared<Field>("score"), SharedConstant(80LL)});
+      GreaterThanExpr({std::make_shared<Field>("score"),
+                       SharedConstant(static_cast<int64_t>(80LL))});
   pipeline = pipeline.AddingStage(std::make_shared<Where>(where_expr));
 
   auto doc1 = Doc("users/bob", 1000, Map("score", 90LL));
@@ -238,8 +239,8 @@ TEST_F(CollectionTest, WhereInequalityOnValues) {
 
 TEST_F(CollectionTest, WhereNotEqualOnValues) {
   RealtimePipeline pipeline = StartPipeline("/users");  // Use RealtimePipeline
-  auto where_expr =
-      NeqExpr({std::make_shared<Field>("score"), SharedConstant(50LL)});
+  auto where_expr = NotEqualExpr({std::make_shared<Field>("score"),
+                                  SharedConstant(static_cast<int64_t>(50LL))});
   pipeline = pipeline.AddingStage(std::make_shared<Where>(where_expr));
 
   auto doc1 = Doc("users/bob", 1000, Map("score", 90LL));
diff --git a/Firestore/core/test/unit/core/pipeline/complex_test.cc b/Firestore/core/test/unit/core/pipeline/complex_test.cc
index 9fa651a96dd..0c7b365e54f 100644
--- a/Firestore/core/test/unit/core/pipeline/complex_test.cc
+++ b/Firestore/core/test/unit/core/pipeline/complex_test.cc
@@ -64,12 +64,12 @@ using testutil::AddExpr;
 using testutil::AndExpr;
 using testutil::ArrayContainsAnyExpr;
 using testutil::EqAnyExpr;
-using testutil::EqExpr;
-using testutil::GtExpr;
-using testutil::LteExpr;
-using testutil::LtExpr;
-using testutil::NeqExpr;
+using testutil::EqualExpr;
+using testutil::GreaterThanExpr;
+using testutil::LessThanExpr;
+using testutil::LessThanOrEqualExpr;
 using testutil::NotEqAnyExpr;
+using testutil::NotEqualExpr;
 using testutil::OrExpr;
 using testutil::Value;
 
@@ -129,7 +129,8 @@ TEST_F(ComplexPipelineTest, WhereWithMaxNumberOfStages) {
   for (int i = 1; i <= num_of_fields; ++i) {
     std::string field_name = "field_" + std::to_string(i);
     pipeline = pipeline.AddingStage(std::make_shared<Where>(
-        GtExpr({std::make_shared<Field>(field_name), SharedConstant(0LL)})));
+        GreaterThanExpr({std::make_shared<Field>(field_name),
+                         SharedConstant(static_cast<int64_t>(0LL))})));
   }
 
   EXPECT_THAT(RunPipeline(pipeline, documents),
@@ -382,14 +383,15 @@ TEST_F(ComplexPipelineTest, WhereWithNestedAddFunctionMaxDepth) {
                                 []() { return Value(0LL); });
 
   std::shared_ptr<Expr> add_func =
-      AddExpr({std::make_shared<Field>("field_1"), SharedConstant(1LL)});
+      AddExpr({std::make_shared<Field>("field_1"),
+               SharedConstant(static_cast<int64_t>(1LL))});
   for (int i = 1; i < depth; ++i) {
-    add_func = AddExpr({add_func, SharedConstant(1LL)});
+    add_func = AddExpr({add_func, SharedConstant(static_cast<int64_t>(1LL))});
   }
 
   RealtimePipeline pipeline = StartPipeline("/" + COLLECTION_ID);
-  pipeline = pipeline.AddingStage(
-      std::make_shared<Where>(GtExpr({add_func, SharedConstant(0LL)})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(
+      GreaterThanExpr({add_func, SharedConstant(static_cast<int64_t>(0LL))})));
 
   // Since field_1 starts at 0, adding 1 repeatedly will always result in > 0
   EXPECT_THAT(RunPipeline(pipeline, documents),
@@ -408,8 +410,8 @@ TEST_F(ComplexPipelineTest, WhereWithLargeNumberOrs) {
   or_conditions.reserve(num_of_fields);
   for (int i = 1; i <= num_of_fields; ++i) {
     std::string field_name = "field_" + std::to_string(i);
-    // Use LteExpr to match the TS test logic
-    or_conditions.push_back(LteExpr(
+    // Use LessThanOrEqualExpr to match the TS test logic
+    or_conditions.push_back(LessThanOrEqualExpr(
         {std::make_shared<Field>(field_name), SharedConstant(max_value)}));
   }
 
@@ -437,11 +439,12 @@ TEST_F(ComplexPipelineTest, WhereWithLargeNumberOfConjunctions) {
   for (int i = 1; i <= num_of_fields; ++i) {
     std::string field_name = "field_" + std::to_string(i);
     and_conditions1.push_back(
-        GtExpr({std::make_shared<Field>(field_name), SharedConstant(0LL)}));
-    // Use LtExpr and a large number for the second condition
+        GreaterThanExpr({std::make_shared<Field>(field_name),
+                         SharedConstant(static_cast<int64_t>(0LL))}));
+    // Use LessThanExpr and a large number for the second condition
     and_conditions2.push_back(
-        LtExpr({std::make_shared<Field>(field_name),
-                SharedConstant(std::numeric_limits<int64_t>::max())}));
+        LessThanExpr({std::make_shared<Field>(field_name),
+                      SharedConstant(std::numeric_limits<int64_t>::max())}));
   }
 
   RealtimePipeline pipeline = StartPipeline("/" + COLLECTION_ID);
diff --git a/Firestore/core/test/unit/core/pipeline/disjunctive_test.cc b/Firestore/core/test/unit/core/pipeline/disjunctive_test.cc
index f9c89873c24..497554d7bff 100644
--- a/Firestore/core/test/unit/core/pipeline/disjunctive_test.cc
+++ b/Firestore/core/test/unit/core/pipeline/disjunctive_test.cc
@@ -65,16 +65,16 @@ using testutil::ArrayContainsAllExpr;
 using testutil::ArrayContainsAnyExpr;
 using testutil::ArrayContainsExpr;
 using testutil::EqAnyExpr;
-using testutil::EqExpr;
-using testutil::GteExpr;
-using testutil::GtExpr;
+using testutil::EqualExpr;
+using testutil::GreaterThanExpr;
+using testutil::GreaterThanOrEqualExpr;
 using testutil::IsNanExpr;
 using testutil::IsNullExpr;
+using testutil::LessThanExpr;
+using testutil::LessThanOrEqualExpr;
 using testutil::LikeExpr;
-using testutil::LteExpr;
-using testutil::LtExpr;
-using testutil::NeqExpr;
 using testutil::NotEqAnyExpr;
+using testutil::NotEqualExpr;
 using testutil::NotExpr;
 using testutil::OrExpr;
 using testutil::XorExpr;
@@ -261,7 +261,7 @@ TEST_F(DisjunctivePipelineTest, EqAnyWithAdditionalEqualityDifferentFields) {
            std::make_shared<Field>("name"),
            SharedConstant(Array(Value("alice"), Value("bob"), Value("charlie"),
                                 Value("diane"), Value("eric")))),
-       EqExpr(
+       EqualExpr(
            {std::make_shared<Field>("age"), SharedConstant(Value(10.0))})})));
   pipeline = pipeline.AddingStage(
       std::make_shared<SortStage>(std::vector<Ordering>{Ordering(
@@ -283,8 +283,8 @@ TEST_F(DisjunctivePipelineTest, EqAnyWithAdditionalEqualitySameField) {
       AndExpr({EqAnyExpr(std::make_shared<Field>("name"),
                          SharedConstant(Array(Value("alice"), Value("diane"),
                                               Value("eric")))),
-               EqExpr({std::make_shared<Field>("name"),
-                       SharedConstant(Value("eric"))})})));
+               EqualExpr({std::make_shared<Field>("name"),
+                          SharedConstant(Value("eric"))})})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre(doc5));
 }
@@ -300,8 +300,8 @@ TEST_F(DisjunctivePipelineTest,
   pipeline = pipeline.AddingStage(std::make_shared<Where>(
       AndExpr({EqAnyExpr(std::make_shared<Field>("name"),
                          SharedConstant(Array(Value("alice"), Value("bob")))),
-               EqExpr({std::make_shared<Field>("name"),
-                       SharedConstant(Value("other"))})})));
+               EqualExpr({std::make_shared<Field>("name"),
+                          SharedConstant(Value("other"))})})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents),
               ElementsAre());  // Expect empty result
@@ -321,8 +321,9 @@ TEST_F(DisjunctivePipelineTest, EqAnyWithInequalitiesExclusiveRange) {
       {EqAnyExpr(std::make_shared<Field>("name"),
                  SharedConstant(Array(Value("alice"), Value("bob"),
                                       Value("charlie"), Value("diane")))),
-       GtExpr({std::make_shared<Field>("age"), SharedConstant(Value(10.0))}),
-       LtExpr(
+       GreaterThanExpr(
+           {std::make_shared<Field>("age"), SharedConstant(Value(10.0))}),
+       LessThanExpr(
            {std::make_shared<Field>("age"), SharedConstant(Value(100.0))})})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents),
@@ -343,8 +344,9 @@ TEST_F(DisjunctivePipelineTest, EqAnyWithInequalitiesInclusiveRange) {
       {EqAnyExpr(std::make_shared<Field>("name"),
                  SharedConstant(Array(Value("alice"), Value("bob"),
                                       Value("charlie"), Value("diane")))),
-       GteExpr({std::make_shared<Field>("age"), SharedConstant(Value(10.0))}),
-       LteExpr(
+       GreaterThanOrEqualExpr(
+           {std::make_shared<Field>("age"), SharedConstant(Value(10.0))}),
+       LessThanOrEqualExpr(
            {std::make_shared<Field>("age"), SharedConstant(Value(100.0))})})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents),
@@ -365,8 +367,9 @@ TEST_F(DisjunctivePipelineTest, EqAnyWithInequalitiesAndSort) {
       {EqAnyExpr(std::make_shared<Field>("name"),
                  SharedConstant(Array(Value("alice"), Value("bob"),
                                       Value("charlie"), Value("diane")))),
-       GtExpr({std::make_shared<Field>("age"), SharedConstant(Value(10.0))}),
-       LtExpr(
+       GreaterThanExpr(
+           {std::make_shared<Field>("age"), SharedConstant(Value(10.0))}),
+       LessThanExpr(
            {std::make_shared<Field>("age"), SharedConstant(Value(100.0))})})));
   pipeline = pipeline.AddingStage(
       std::make_shared<SortStage>(std::vector<Ordering>{Ordering(
@@ -389,7 +392,7 @@ TEST_F(DisjunctivePipelineTest, EqAnyWithNotEqual) {
       {EqAnyExpr(std::make_shared<Field>("name"),
                  SharedConstant(Array(Value("alice"), Value("bob"),
                                       Value("charlie"), Value("diane")))),
-       NeqExpr(
+       NotEqualExpr(
            {std::make_shared<Field>("age"), SharedConstant(Value(100.0))})})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents),
@@ -456,7 +459,7 @@ TEST_F(DisjunctivePipelineTest, EqAnyWithExtraEqualitySortOnEqAnyField) {
            std::make_shared<Field>("name"),
            SharedConstant(Array(Value("alice"), Value("bob"), Value("charlie"),
                                 Value("diane"), Value("eric")))),
-       EqExpr(
+       EqualExpr(
            {std::make_shared<Field>("age"), SharedConstant(Value(10.0))})})));
   pipeline = pipeline.AddingStage(
       std::make_shared<SortStage>(std::vector<Ordering>{Ordering(
@@ -479,7 +482,7 @@ TEST_F(DisjunctivePipelineTest, EqAnyWithExtraEqualitySortOnEquality) {
            std::make_shared<Field>("name"),
            SharedConstant(Array(Value("alice"), Value("bob"), Value("charlie"),
                                 Value("diane"), Value("eric")))),
-       EqExpr(
+       EqualExpr(
            {std::make_shared<Field>("age"), SharedConstant(Value(10.0))})})));
   pipeline = pipeline.AddingStage(
       std::make_shared<SortStage>(std::vector<Ordering>{Ordering(
@@ -505,7 +508,7 @@ TEST_F(DisjunctivePipelineTest, EqAnyWithInequalityOnSameField) {
   pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr(
       {EqAnyExpr(std::make_shared<Field>("age"),
                  SharedConstant(Array(Value(10.0), Value(25.0), Value(100.0)))),
-       GtExpr(
+       GreaterThanExpr(
            {std::make_shared<Field>("age"), SharedConstant(Value(20.0))})})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents),
@@ -531,7 +534,7 @@ TEST_F(
       {EqAnyExpr(std::make_shared<Field>("name"),
                  SharedConstant(Array(Value("alice"), Value("bob"),
                                       Value("charlie"), Value("diane")))),
-       GtExpr(
+       GreaterThanExpr(
            {std::make_shared<Field>("age"), SharedConstant(Value(20.0))})})));
   // Sort field is 'age', which is the inequality field, not the EqAny field
   // 'name'. The TS test name seems misleading based on the sort field used.
@@ -700,8 +703,9 @@ TEST_F(DisjunctivePipelineTest, ArrayContainsAnyWithInequality) {
        // Note: Comparing an array field with an array constant using LT might
        // not behave as expected in Firestore backend queries. This test
        // replicates the TS behavior for pipeline evaluation.
-       LtExpr({std::make_shared<Field>("groups"),
-               SharedConstant(Array(Value(3LL), Value(4LL), Value(5LL)))})})));
+       LessThanExpr(
+           {std::make_shared<Field>("groups"),
+            SharedConstant(Array(Value(3LL), Value(4LL), Value(5LL)))})})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents),
               UnorderedElementsAre(doc1, doc2, doc4));
@@ -745,10 +749,11 @@ TEST_F(DisjunctivePipelineTest, BasicOr) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3, doc4};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(OrExpr(
-      {EqExpr({std::make_shared<Field>("name"), SharedConstant(Value("bob"))}),
-       EqExpr(
-           {std::make_shared<Field>("age"), SharedConstant(Value(10.0))})})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(
+      OrExpr({EqualExpr({std::make_shared<Field>("name"),
+                         SharedConstant(Value("bob"))}),
+              EqualExpr({std::make_shared<Field>("age"),
+                         SharedConstant(Value(10.0))})})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents),
               UnorderedElementsAre(doc2, doc4));
@@ -763,11 +768,12 @@ TEST_F(DisjunctivePipelineTest, MultipleOr) {
 
   RealtimePipeline pipeline = StartPipeline("/users");
   pipeline = pipeline.AddingStage(std::make_shared<Where>(OrExpr(
-      {EqExpr({std::make_shared<Field>("name"), SharedConstant(Value("bob"))}),
-       EqExpr(
+      {EqualExpr(
+           {std::make_shared<Field>("name"), SharedConstant(Value("bob"))}),
+       EqualExpr(
            {std::make_shared<Field>("name"), SharedConstant(Value("diane"))}),
-       EqExpr({std::make_shared<Field>("age"), SharedConstant(Value(25.0))}),
-       EqExpr(
+       EqualExpr({std::make_shared<Field>("age"), SharedConstant(Value(25.0))}),
+       EqualExpr(
            {std::make_shared<Field>("age"), SharedConstant(Value(100.0))})})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents),
@@ -782,15 +788,16 @@ TEST_F(DisjunctivePipelineTest, OrMultipleStages) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3, doc4};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(OrExpr(
-      {EqExpr({std::make_shared<Field>("name"), SharedConstant(Value("bob"))}),
-       EqExpr(
-           {std::make_shared<Field>("age"), SharedConstant(Value(10.0))})})));
   pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      OrExpr({EqExpr({std::make_shared<Field>("name"),
-                      SharedConstant(Value("diane"))}),
-              EqExpr({std::make_shared<Field>("age"),
-                      SharedConstant(Value(100.0))})})));
+      OrExpr({EqualExpr({std::make_shared<Field>("name"),
+                         SharedConstant(Value("bob"))}),
+              EqualExpr({std::make_shared<Field>("age"),
+                         SharedConstant(Value(10.0))})})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(
+      OrExpr({EqualExpr({std::make_shared<Field>("name"),
+                         SharedConstant(Value("diane"))}),
+              EqualExpr({std::make_shared<Field>("age"),
+                         SharedConstant(Value(100.0))})})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre(doc4));
 }
@@ -804,14 +811,14 @@ TEST_F(DisjunctivePipelineTest, OrTwoConjunctions) {
 
   RealtimePipeline pipeline = StartPipeline("/users");
   pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      OrExpr({AndExpr({EqExpr({std::make_shared<Field>("name"),
-                               SharedConstant(Value("bob"))}),
-                       EqExpr({std::make_shared<Field>("age"),
-                               SharedConstant(Value(25.0))})}),
-              AndExpr({EqExpr({std::make_shared<Field>("name"),
-                               SharedConstant(Value("diane"))}),
-                       EqExpr({std::make_shared<Field>("age"),
-                               SharedConstant(Value(10.0))})})})));
+      OrExpr({AndExpr({EqualExpr({std::make_shared<Field>("name"),
+                                  SharedConstant(Value("bob"))}),
+                       EqualExpr({std::make_shared<Field>("age"),
+                                  SharedConstant(Value(25.0))})}),
+              AndExpr({EqualExpr({std::make_shared<Field>("name"),
+                                  SharedConstant(Value("diane"))}),
+                       EqualExpr({std::make_shared<Field>("age"),
+                                  SharedConstant(Value(10.0))})})})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents),
               UnorderedElementsAre(doc2, doc4));
@@ -826,12 +833,12 @@ TEST_F(DisjunctivePipelineTest, OrWithInAnd) {  // Renamed from TS: or_withInAnd
 
   RealtimePipeline pipeline = StartPipeline("/users");
   pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      AndExpr({OrExpr({EqExpr({std::make_shared<Field>("name"),
-                               SharedConstant(Value("bob"))}),
-                       EqExpr({std::make_shared<Field>("age"),
-                               SharedConstant(Value(10.0))})}),
-               LtExpr({std::make_shared<Field>("age"),
-                       SharedConstant(Value(80.0))})})));
+      AndExpr({OrExpr({EqualExpr({std::make_shared<Field>("name"),
+                                  SharedConstant(Value("bob"))}),
+                       EqualExpr({std::make_shared<Field>("age"),
+                                  SharedConstant(Value(10.0))})}),
+               LessThanExpr({std::make_shared<Field>("age"),
+                             SharedConstant(Value(80.0))})})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents),
               UnorderedElementsAre(doc2, doc4));
@@ -846,14 +853,14 @@ TEST_F(DisjunctivePipelineTest, AndOfTwoOrs) {
 
   RealtimePipeline pipeline = StartPipeline("/users");
   pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      AndExpr({OrExpr({EqExpr({std::make_shared<Field>("name"),
-                               SharedConstant(Value("bob"))}),
-                       EqExpr({std::make_shared<Field>("age"),
-                               SharedConstant(Value(10.0))})}),
-               OrExpr({EqExpr({std::make_shared<Field>("name"),
-                               SharedConstant(Value("diane"))}),
-                       EqExpr({std::make_shared<Field>("age"),
-                               SharedConstant(Value(100.0))})})})));
+      AndExpr({OrExpr({EqualExpr({std::make_shared<Field>("name"),
+                                  SharedConstant(Value("bob"))}),
+                       EqualExpr({std::make_shared<Field>("age"),
+                                  SharedConstant(Value(10.0))})}),
+               OrExpr({EqualExpr({std::make_shared<Field>("name"),
+                                  SharedConstant(Value("diane"))}),
+                       EqualExpr({std::make_shared<Field>("age"),
+                                  SharedConstant(Value(100.0))})})})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre(doc4));
 }
@@ -867,14 +874,14 @@ TEST_F(DisjunctivePipelineTest, OrOfTwoOrs) {
 
   RealtimePipeline pipeline = StartPipeline("/users");
   pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      OrExpr({OrExpr({EqExpr({std::make_shared<Field>("name"),
-                              SharedConstant(Value("bob"))}),
-                      EqExpr({std::make_shared<Field>("age"),
-                              SharedConstant(Value(10.0))})}),
-              OrExpr({EqExpr({std::make_shared<Field>("name"),
-                              SharedConstant(Value("diane"))}),
-                      EqExpr({std::make_shared<Field>("age"),
-                              SharedConstant(Value(100.0))})})})));
+      OrExpr({OrExpr({EqualExpr({std::make_shared<Field>("name"),
+                                 SharedConstant(Value("bob"))}),
+                      EqualExpr({std::make_shared<Field>("age"),
+                                 SharedConstant(Value(10.0))})}),
+              OrExpr({EqualExpr({std::make_shared<Field>("name"),
+                                 SharedConstant(Value("diane"))}),
+                      EqualExpr({std::make_shared<Field>("age"),
+                                 SharedConstant(Value(100.0))})})})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents),
               UnorderedElementsAre(doc2, doc3, doc4));
@@ -888,13 +895,14 @@ TEST_F(DisjunctivePipelineTest, OrWithEmptyRangeInOneDisjunction) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3, doc4};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(OrExpr(
-      {EqExpr({std::make_shared<Field>("name"), SharedConstant(Value("bob"))}),
-       AndExpr({// This conjunction will always be false
-                EqExpr({std::make_shared<Field>("age"),
-                        SharedConstant(Value(10.0))}),
-                GtExpr({std::make_shared<Field>("age"),
-                        SharedConstant(Value(20.0))})})})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(
+      OrExpr({EqualExpr({std::make_shared<Field>("name"),
+                         SharedConstant(Value("bob"))}),
+              AndExpr({// This conjunction will always be false
+                       EqualExpr({std::make_shared<Field>("age"),
+                                  SharedConstant(Value(10.0))}),
+                       GreaterThanExpr({std::make_shared<Field>("age"),
+                                        SharedConstant(Value(20.0))})})})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre(doc2));
 }
@@ -907,11 +915,11 @@ TEST_F(DisjunctivePipelineTest, OrWithSort) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3, doc4};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(
-      std::make_shared<Where>(OrExpr({EqExpr({std::make_shared<Field>("name"),
-                                              SharedConstant(Value("diane"))}),
-                                      GtExpr({std::make_shared<Field>("age"),
-                                              SharedConstant(Value(20.0))})})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(
+      OrExpr({EqualExpr({std::make_shared<Field>("name"),
+                         SharedConstant(Value("diane"))}),
+              GreaterThanExpr({std::make_shared<Field>("age"),
+                               SharedConstant(Value(20.0))})})));
   pipeline = pipeline.AddingStage(
       std::make_shared<SortStage>(std::vector<Ordering>{Ordering(
           std::make_unique<Field>("age"), Ordering::Direction::ASCENDING)}));
@@ -929,10 +937,11 @@ TEST_F(DisjunctivePipelineTest, OrWithInequalityAndSortSameField) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3, doc4};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(OrExpr(
-      {LtExpr({std::make_shared<Field>("age"), SharedConstant(Value(20.0))}),
-       GtExpr(
-           {std::make_shared<Field>("age"), SharedConstant(Value(50.0))})})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(
+      OrExpr({LessThanExpr({std::make_shared<Field>("age"),
+                            SharedConstant(Value(20.0))}),
+              GreaterThanExpr({std::make_shared<Field>("age"),
+                               SharedConstant(Value(50.0))})})));
   pipeline = pipeline.AddingStage(
       std::make_shared<SortStage>(std::vector<Ordering>{Ordering(
           std::make_unique<Field>("age"), Ordering::Direction::ASCENDING)}));
@@ -949,10 +958,11 @@ TEST_F(DisjunctivePipelineTest, OrWithInequalityAndSortDifferentFields) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3, doc4};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(OrExpr(
-      {LtExpr({std::make_shared<Field>("age"), SharedConstant(Value(20.0))}),
-       GtExpr(
-           {std::make_shared<Field>("age"), SharedConstant(Value(50.0))})})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(
+      OrExpr({LessThanExpr({std::make_shared<Field>("age"),
+                            SharedConstant(Value(20.0))}),
+              GreaterThanExpr({std::make_shared<Field>("age"),
+                               SharedConstant(Value(50.0))})})));
   pipeline = pipeline.AddingStage(
       std::make_shared<SortStage>(std::vector<Ordering>{Ordering(
           std::make_unique<Field>("name"), Ordering::Direction::ASCENDING)}));
@@ -975,10 +985,11 @@ TEST_F(DisjunctivePipelineTest, OrWithInequalityAndSortMultipleFields) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3, doc4, doc5};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(OrExpr(
-      {LtExpr({std::make_shared<Field>("age"), SharedConstant(Value(80.0))}),
-       GtExpr({std::make_shared<Field>("height"),
-               SharedConstant(Value(160.0))})})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(
+      OrExpr({LessThanExpr({std::make_shared<Field>("age"),
+                            SharedConstant(Value(80.0))}),
+              GreaterThanExpr({std::make_shared<Field>("height"),
+                               SharedConstant(Value(160.0))})})));
   pipeline =
       pipeline.AddingStage(std::make_shared<SortStage>(std::vector<Ordering>{
           Ordering(std::make_unique<Field>("age"),
@@ -1004,11 +1015,11 @@ TEST_F(DisjunctivePipelineTest, OrWithSortOnPartialMissingField) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3, doc4};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(
-      std::make_shared<Where>(OrExpr({EqExpr({std::make_shared<Field>("name"),
-                                              SharedConstant(Value("diane"))}),
-                                      GtExpr({std::make_shared<Field>("age"),
-                                              SharedConstant(Value(20.0))})})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(
+      OrExpr({EqualExpr({std::make_shared<Field>("name"),
+                         SharedConstant(Value("diane"))}),
+              GreaterThanExpr({std::make_shared<Field>("age"),
+                               SharedConstant(Value(20.0))})})));
   pipeline = pipeline.AddingStage(
       std::make_shared<SortStage>(std::vector<Ordering>{Ordering(
           std::make_unique<Field>("age"), Ordering::Direction::ASCENDING)}));
@@ -1027,11 +1038,11 @@ TEST_F(DisjunctivePipelineTest, OrWithLimit) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3, doc4};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(
-      std::make_shared<Where>(OrExpr({EqExpr({std::make_shared<Field>("name"),
-                                              SharedConstant(Value("diane"))}),
-                                      GtExpr({std::make_shared<Field>("age"),
-                                              SharedConstant(Value(20.0))})})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(
+      OrExpr({EqualExpr({std::make_shared<Field>("name"),
+                         SharedConstant(Value("diane"))}),
+              GreaterThanExpr({std::make_shared<Field>("age"),
+                               SharedConstant(Value(20.0))})})));
   pipeline = pipeline.AddingStage(
       std::make_shared<SortStage>(std::vector<Ordering>{Ordering(
           std::make_unique<Field>("age"), Ordering::Direction::ASCENDING)}));
@@ -1059,7 +1070,7 @@ TEST_F(DisjunctivePipelineTest, OrIsNullAndEqOnSameField) {
 
   RealtimePipeline pipeline = StartPipeline("/users");
   pipeline = pipeline.AddingStage(std::make_shared<Where>(OrExpr(
-      {EqExpr({std::make_shared<Field>("a"), SharedConstant(Value(1LL))}),
+      {EqualExpr({std::make_shared<Field>("a"), SharedConstant(Value(1LL))}),
        IsNullExpr(std::make_shared<Field>("a"))})));
 
   // Expect docs where a==1 (doc1, doc2, doc3) or a is null (doc4)
@@ -1079,7 +1090,7 @@ TEST_F(DisjunctivePipelineTest, OrIsNullAndEqOnDifferentField) {
 
   RealtimePipeline pipeline = StartPipeline("/users");
   pipeline = pipeline.AddingStage(std::make_shared<Where>(OrExpr(
-      {EqExpr({std::make_shared<Field>("b"), SharedConstant(Value(1LL))}),
+      {EqualExpr({std::make_shared<Field>("b"), SharedConstant(Value(1LL))}),
        IsNullExpr(std::make_shared<Field>("a"))})));
 
   // Expect docs where b==1 (doc3) or a is null (doc4)
@@ -1100,7 +1111,8 @@ TEST_F(DisjunctivePipelineTest, OrIsNotNullAndEqOnSameField) {
   RealtimePipeline pipeline = StartPipeline("/users");
   pipeline = pipeline.AddingStage(std::make_shared<Where>(OrExpr({
       // Note: TS test uses gt(1), C++ uses gt(1) here too.
-      GtExpr({std::make_shared<Field>("a"), SharedConstant(Value(1LL))}),
+      GreaterThanExpr(
+          {std::make_shared<Field>("a"), SharedConstant(Value(1LL))}),
       NotExpr(IsNullExpr(std::make_shared<Field>("a")))  // isNotNull
   })));
 
@@ -1122,7 +1134,7 @@ TEST_F(DisjunctivePipelineTest, OrIsNotNullAndEqOnDifferentField) {
 
   RealtimePipeline pipeline = StartPipeline("/users");
   pipeline = pipeline.AddingStage(std::make_shared<Where>(OrExpr({
-      EqExpr({std::make_shared<Field>("b"), SharedConstant(Value(1LL))}),
+      EqualExpr({std::make_shared<Field>("b"), SharedConstant(Value(1LL))}),
       NotExpr(IsNullExpr(std::make_shared<Field>("a")))  // isNotNull
   })));
 
@@ -1282,7 +1294,7 @@ TEST_F(DisjunctivePipelineTest, NotEqAnyWithAdditionalEqualityDifferentFields) {
   pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr(
       {NotEqAnyExpr(std::make_shared<Field>("name"),
                     SharedConstant(Array(Value("alice"), Value("bob")))),
-       EqExpr(
+       EqualExpr(
            {std::make_shared<Field>("age"), SharedConstant(Value(10.0))})})));
 
   // Expect docs where name is not alice/bob (doc3, doc4, doc5) AND age is 10
@@ -1303,8 +1315,8 @@ TEST_F(DisjunctivePipelineTest, NotEqAnyWithAdditionalEqualitySameField) {
   pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr(
       {NotEqAnyExpr(std::make_shared<Field>("name"),
                     SharedConstant(Array(Value("alice"), Value("diane")))),
-       EqExpr({std::make_shared<Field>("name"),
-               SharedConstant(Value("eric"))})})));
+       EqualExpr({std::make_shared<Field>("name"),
+                  SharedConstant(Value("eric"))})})));
 
   // Expect docs where name is not alice/diane (doc2, doc3, doc5) AND name is
   // eric (doc5)
@@ -1323,8 +1335,9 @@ TEST_F(DisjunctivePipelineTest, NotEqAnyWithInequalitiesExclusiveRange) {
   pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr(
       {NotEqAnyExpr(std::make_shared<Field>("name"),
                     SharedConstant(Array(Value("alice"), Value("charlie")))),
-       GtExpr({std::make_shared<Field>("age"), SharedConstant(Value(10.0))}),
-       LtExpr(
+       GreaterThanExpr(
+           {std::make_shared<Field>("age"), SharedConstant(Value(10.0))}),
+       LessThanExpr(
            {std::make_shared<Field>("age"), SharedConstant(Value(100.0))})})));
 
   // Expect docs where name is not alice/charlie (doc2, doc4, doc5) AND age > 10
@@ -1345,8 +1358,9 @@ TEST_F(DisjunctivePipelineTest, NotEqAnyWithInequalitiesInclusiveRange) {
       {NotEqAnyExpr(
            std::make_shared<Field>("name"),
            SharedConstant(Array(Value("alice"), Value("bob"), Value("eric")))),
-       GteExpr({std::make_shared<Field>("age"), SharedConstant(Value(10.0))}),
-       LteExpr(
+       GreaterThanOrEqualExpr(
+           {std::make_shared<Field>("age"), SharedConstant(Value(10.0))}),
+       LessThanOrEqualExpr(
            {std::make_shared<Field>("age"), SharedConstant(Value(100.0))})})));
 
   // Expect docs where name is not alice/bob/eric (doc3, doc4) AND age >= 10 AND
@@ -1367,8 +1381,9 @@ TEST_F(DisjunctivePipelineTest, NotEqAnyWithInequalitiesAndSort) {
   pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr(
       {NotEqAnyExpr(std::make_shared<Field>("name"),
                     SharedConstant(Array(Value("alice"), Value("diane")))),
-       GtExpr({std::make_shared<Field>("age"), SharedConstant(Value(10.0))}),
-       LteExpr(
+       GreaterThanExpr(
+           {std::make_shared<Field>("age"), SharedConstant(Value(10.0))}),
+       LessThanOrEqualExpr(
            {std::make_shared<Field>("age"), SharedConstant(Value(100.0))})})));
   pipeline = pipeline.AddingStage(
       std::make_shared<SortStage>(std::vector<Ordering>{Ordering(
@@ -1391,7 +1406,7 @@ TEST_F(DisjunctivePipelineTest, NotEqAnyWithNotEqual) {
   pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr(
       {NotEqAnyExpr(std::make_shared<Field>("name"),
                     SharedConstant(Array(Value("alice"), Value("bob")))),
-       NeqExpr(
+       NotEqualExpr(
            {std::make_shared<Field>("age"), SharedConstant(Value(100.0))})})));
 
   // Expect docs where name is not alice/bob (doc3, doc4, doc5) AND age is not
@@ -1451,7 +1466,7 @@ TEST_F(DisjunctivePipelineTest, NotEqAnyWithExtraEqualitySortOnNotEqAnyField) {
   pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr(
       {NotEqAnyExpr(std::make_shared<Field>("name"),
                     SharedConstant(Array(Value("alice"), Value("bob")))),
-       EqExpr(
+       EqualExpr(
            {std::make_shared<Field>("age"), SharedConstant(Value(10.0))})})));
   pipeline = pipeline.AddingStage(
       std::make_shared<SortStage>(std::vector<Ordering>{Ordering(
@@ -1474,7 +1489,7 @@ TEST_F(DisjunctivePipelineTest, NotEqAnyWithExtraEqualitySortOnEquality) {
   pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr(
       {NotEqAnyExpr(std::make_shared<Field>("name"),
                     SharedConstant(Array(Value("alice"), Value("bob")))),
-       EqExpr(
+       EqualExpr(
            {std::make_shared<Field>("age"), SharedConstant(Value(10.0))})})));
   pipeline = pipeline.AddingStage(
       std::make_shared<SortStage>(std::vector<Ordering>{Ordering(
@@ -1497,8 +1512,8 @@ TEST_F(DisjunctivePipelineTest, NotEqAnyWithInequalityOnSameField) {
   pipeline = pipeline.AddingStage(std::make_shared<Where>(
       AndExpr({NotEqAnyExpr(std::make_shared<Field>("age"),
                             SharedConstant(Array(Value(10.0), Value(100.0)))),
-               GtExpr({std::make_shared<Field>("age"),
-                       SharedConstant(Value(20.0))})})));
+               GreaterThanExpr({std::make_shared<Field>("age"),
+                                SharedConstant(Value(20.0))})})));
   pipeline = pipeline.AddingStage(
       std::make_shared<SortStage>(std::vector<Ordering>{Ordering(
           std::make_unique<Field>("age"), Ordering::Direction::ASCENDING)}));
@@ -1523,7 +1538,7 @@ TEST_F(
   pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr(
       {NotEqAnyExpr(std::make_shared<Field>("name"),
                     SharedConstant(Array(Value("alice"), Value("diane")))),
-       GtExpr(
+       GreaterThanExpr(
            {std::make_shared<Field>("age"), SharedConstant(Value(20.0))})})));
   // Sort field is 'age', the inequality field. TS name was misleading.
   pipeline = pipeline.AddingStage(
@@ -1550,26 +1565,28 @@ TEST_F(DisjunctivePipelineTest, NoLimitOnNumOfDisjunctions) {
 
   RealtimePipeline pipeline = StartPipeline("/users");
   pipeline = pipeline.AddingStage(std::make_shared<Where>(OrExpr(
-      {EqExpr(
+      {EqualExpr(
            {std::make_shared<Field>("name"), SharedConstant(Value("alice"))}),
-       EqExpr({std::make_shared<Field>("name"), SharedConstant(Value("bob"))}),
-       EqExpr(
+       EqualExpr(
+           {std::make_shared<Field>("name"), SharedConstant(Value("bob"))}),
+       EqualExpr(
            {std::make_shared<Field>("name"), SharedConstant(Value("charlie"))}),
-       EqExpr(
+       EqualExpr(
            {std::make_shared<Field>("name"), SharedConstant(Value("diane"))}),
-       EqExpr({std::make_shared<Field>("age"), SharedConstant(Value(10.0))}),
-       EqExpr({std::make_shared<Field>("age"), SharedConstant(Value(25.0))}),
-       EqExpr({std::make_shared<Field>("age"),
-               SharedConstant(Value(40.0))}),  // No doc matches this
-       EqExpr({std::make_shared<Field>("age"), SharedConstant(Value(100.0))}),
-       EqExpr(
+       EqualExpr({std::make_shared<Field>("age"), SharedConstant(Value(10.0))}),
+       EqualExpr({std::make_shared<Field>("age"), SharedConstant(Value(25.0))}),
+       EqualExpr({std::make_shared<Field>("age"),
+                  SharedConstant(Value(40.0))}),  // No doc matches this
+       EqualExpr(
+           {std::make_shared<Field>("age"), SharedConstant(Value(100.0))}),
+       EqualExpr(
            {std::make_shared<Field>("height"), SharedConstant(Value(150.0))}),
-       EqExpr({std::make_shared<Field>("height"),
-               SharedConstant(Value(160.0))}),  // No doc matches this
-       EqExpr(
+       EqualExpr({std::make_shared<Field>("height"),
+                  SharedConstant(Value(160.0))}),  // No doc matches this
+       EqualExpr(
            {std::make_shared<Field>("height"), SharedConstant(Value(170.0))}),
-       EqExpr({std::make_shared<Field>("height"),
-               SharedConstant(Value(180.0))})})));
+       EqualExpr({std::make_shared<Field>("height"),
+                  SharedConstant(Value(180.0))})})));
 
   // Since each doc matches at least one condition, all should be returned.
   EXPECT_THAT(RunPipeline(pipeline, documents),
diff --git a/Firestore/core/test/unit/core/pipeline/error_handling_test.cc b/Firestore/core/test/unit/core/pipeline/error_handling_test.cc
index 280749051c1..8db238e591f 100644
--- a/Firestore/core/test/unit/core/pipeline/error_handling_test.cc
+++ b/Firestore/core/test/unit/core/pipeline/error_handling_test.cc
@@ -68,16 +68,16 @@ using testutil::ArrayContainsAnyExpr;
 using testutil::ArrayContainsExpr;
 using testutil::DivideExpr;  // Added for divide test
 using testutil::EqAnyExpr;
-using testutil::EqExpr;
-using testutil::GteExpr;
-using testutil::GtExpr;
+using testutil::EqualExpr;
+using testutil::GreaterThanExpr;
+using testutil::GreaterThanOrEqualExpr;
 using testutil::IsNanExpr;
 using testutil::IsNullExpr;
+using testutil::LessThanExpr;
+using testutil::LessThanOrEqualExpr;
 using testutil::LikeExpr;
-using testutil::LteExpr;
-using testutil::LtExpr;
-using testutil::NeqExpr;
 using testutil::NotEqAnyExpr;
+using testutil::NotEqualExpr;
 using testutil::NotExpr;
 using testutil::OrExpr;
 using testutil::XorExpr;
@@ -123,16 +123,17 @@ TEST_F(ErrorHandlingPipelineTest, WherePartialErrorOr) {
 
   RealtimePipeline pipeline = StartPipeline("/k");
   pipeline = pipeline.AddingStage(std::make_shared<Where>(OrExpr(
-      {EqExpr({std::make_shared<Field>("a"),
-               SharedConstant(Value(true))}),  // Expects boolean true
-       EqExpr({std::make_shared<Field>("b"), SharedConstant(Value(true))}),
-       EqExpr({std::make_shared<Field>("c"), SharedConstant(Value(true))})})));
+      {EqualExpr({std::make_shared<Field>("a"),
+                  SharedConstant(Value(true))}),  // Expects boolean true
+       EqualExpr({std::make_shared<Field>("b"), SharedConstant(Value(true))}),
+       EqualExpr(
+           {std::make_shared<Field>("c"), SharedConstant(Value(true))})})));
 
   // In Firestore, comparisons between different types are generally false.
   // The OR evaluates to true if *any* of the fields 'a', 'b', or 'c' is the
   // boolean value `true`. All documents have at least one field that is boolean
   // `true` or can be evaluated. Assuming type mismatches evaluate to false in
-  // EqExpr for OR.
+  // EqualExpr for OR.
   EXPECT_THAT(RunPipeline(pipeline, documents),
               UnorderedElementsAre(doc1, doc2, doc3, doc4, doc5, doc6));
 }
@@ -164,12 +165,13 @@ TEST_F(ErrorHandlingPipelineTest, WherePartialErrorAnd) {
 
   RealtimePipeline pipeline = StartPipeline("k");
   pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr(
-      {EqExpr({std::make_shared<Field>("a"), SharedConstant(Value(true))}),
-       EqExpr({std::make_shared<Field>("b"), SharedConstant(Value(true))}),
-       EqExpr({std::make_shared<Field>("c"), SharedConstant(Value(true))})})));
+      {EqualExpr({std::make_shared<Field>("a"), SharedConstant(Value(true))}),
+       EqualExpr({std::make_shared<Field>("b"), SharedConstant(Value(true))}),
+       EqualExpr(
+           {std::make_shared<Field>("c"), SharedConstant(Value(true))})})));
 
-  // AND requires all conditions to be true. Type mismatches evaluate EqExpr to
-  // false. Only doc7 has a=true, b=true, AND c=true.
+  // AND requires all conditions to be true. Type mismatches evaluate EqualExpr
+  // to false. Only doc7 has a=true, b=true, AND c=true.
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre(doc7));
 }
 
@@ -201,12 +203,13 @@ TEST_F(ErrorHandlingPipelineTest, WherePartialErrorXor) {
 
   RealtimePipeline pipeline = StartPipeline("k");
   pipeline = pipeline.AddingStage(std::make_shared<Where>(XorExpr(
-      {// Casting might not work directly, using EqExpr for boolean check
-       EqExpr({std::make_shared<Field>("a"), SharedConstant(Value(true))}),
-       EqExpr({std::make_shared<Field>("b"), SharedConstant(Value(true))}),
-       EqExpr({std::make_shared<Field>("c"), SharedConstant(Value(true))})})));
+      {// Casting might not work directly, using EqualExpr for boolean check
+       EqualExpr({std::make_shared<Field>("a"), SharedConstant(Value(true))}),
+       EqualExpr({std::make_shared<Field>("b"), SharedConstant(Value(true))}),
+       EqualExpr(
+           {std::make_shared<Field>("c"), SharedConstant(Value(true))})})));
 
-  // Assuming type mismatches evaluate EqExpr to false:
+  // Assuming type mismatches evaluate EqualExpr to false:
   // doc1: F ^ T ^ F = T
   // doc2: T ^ F ^ F = T
   // doc3: T ^ F ^ F = T
@@ -243,7 +246,7 @@ TEST_F(ErrorHandlingPipelineTest, WhereErrorProducingFunctionReturnsEmpty) {
   RealtimePipeline pipeline = StartPipeline("k");
   // Division operation with string constants - this should likely cause an
   // evaluation error.
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(EqExpr({
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(EqualExpr({
       DivideExpr({SharedConstant(Value("100")),
                   SharedConstant(Value("50"))}),  // Error here
       SharedConstant(Value(2LL))  // Comparing result to integer 2
diff --git a/Firestore/core/test/unit/core/pipeline/inequality_test.cc b/Firestore/core/test/unit/core/pipeline/inequality_test.cc
index d3ede6de7af..ca00529072c 100644
--- a/Firestore/core/test/unit/core/pipeline/inequality_test.cc
+++ b/Firestore/core/test/unit/core/pipeline/inequality_test.cc
@@ -71,16 +71,16 @@ using testutil::ArrayContainsAnyExpr;
 using testutil::ArrayContainsExpr;
 using testutil::DivideExpr;
 using testutil::EqAnyExpr;
-using testutil::EqExpr;
-using testutil::GteExpr;
-using testutil::GtExpr;
+using testutil::EqualExpr;
+using testutil::GreaterThanExpr;
+using testutil::GreaterThanOrEqualExpr;
 using testutil::IsNanExpr;
 using testutil::IsNullExpr;
+using testutil::LessThanExpr;
+using testutil::LessThanOrEqualExpr;
 using testutil::LikeExpr;
-using testutil::LteExpr;
-using testutil::LtExpr;
-using testutil::NeqExpr;
 using testutil::NotEqAnyExpr;
+using testutil::NotEqualExpr;
 using testutil::NotExpr;
 using testutil::OrExpr;
 using testutil::XorExpr;
@@ -103,8 +103,8 @@ TEST_F(InequalityPipelineTest, GreaterThan) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      GtExpr({std::make_shared<Field>("score"), SharedConstant(Value(90LL))})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(GreaterThanExpr(
+      {std::make_shared<Field>("score"), SharedConstant(Value(90LL))})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre(doc3));
 }
@@ -116,8 +116,9 @@ TEST_F(InequalityPipelineTest, GreaterThanOrEqual) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(GteExpr(
-      {std::make_shared<Field>("score"), SharedConstant(Value(90LL))})));
+  pipeline =
+      pipeline.AddingStage(std::make_shared<Where>(GreaterThanOrEqualExpr(
+          {std::make_shared<Field>("score"), SharedConstant(Value(90LL))})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents),
               UnorderedElementsAre(doc1, doc3));
@@ -130,8 +131,8 @@ TEST_F(InequalityPipelineTest, LessThan) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      LtExpr({std::make_shared<Field>("score"), SharedConstant(Value(90LL))})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(LessThanExpr(
+      {std::make_shared<Field>("score"), SharedConstant(Value(90LL))})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre(doc2));
 }
@@ -143,7 +144,7 @@ TEST_F(InequalityPipelineTest, LessThanOrEqual) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(LteExpr(
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(LessThanOrEqualExpr(
       {std::make_shared<Field>("score"), SharedConstant(Value(90LL))})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents),
@@ -157,7 +158,7 @@ TEST_F(InequalityPipelineTest, NotEqual) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(NeqExpr(
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(NotEqualExpr(
       {std::make_shared<Field>("score"), SharedConstant(Value(90LL))})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents),
@@ -187,7 +188,7 @@ TEST_F(InequalityPipelineTest, NotEqualReturnsMixedTypes) {
                                          doc5, doc6, doc7, doc8};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(NeqExpr(
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(NotEqualExpr(
       {std::make_shared<Field>("score"), SharedConstant(Value(90LL))})));
 
   // Neq returns true for different types.
@@ -212,8 +213,8 @@ TEST_F(InequalityPipelineTest, ComparisonHasImplicitBound) {
                                          doc5, doc6, doc7, doc8};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      GtExpr({std::make_shared<Field>("score"), SharedConstant(Value(42LL))})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(GreaterThanExpr(
+      {std::make_shared<Field>("score"), SharedConstant(Value(42LL))})));
 
   // Only numeric types greater than 42 are matched.
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre(doc2));
@@ -248,11 +249,12 @@ TEST_F(InequalityPipelineTest, NotComparisonReturnsMixedType) {
                                          doc5, doc6, doc7, doc8};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(NotExpr(GtExpr(
-      {std::make_shared<Field>("score"), SharedConstant(Value(90LL))}))));
+  pipeline =
+      pipeline.AddingStage(std::make_shared<Where>(NotExpr(GreaterThanExpr(
+          {std::make_shared<Field>("score"), SharedConstant(Value(90LL))}))));
 
   // NOT (score > 90). Comparison is only true for score=100.0. NOT flips it.
-  // Type mismatches result in false for GtExpr, NOT flips to true.
+  // Type mismatches result in false for GreaterThanExpr, NOT flips to true.
   EXPECT_THAT(RunPipeline(pipeline, documents),
               UnorderedElementsAre(doc1, doc3, doc4, doc5, doc6, doc7, doc8));
 }
@@ -269,8 +271,8 @@ TEST_F(InequalityPipelineTest, InequalityWithEqualityOnDifferentField) {
 
   RealtimePipeline pipeline = StartPipeline("/users");
   pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr(
-      {EqExpr({std::make_shared<Field>("rank"), SharedConstant(Value(2LL))}),
-       GtExpr(
+      {EqualExpr({std::make_shared<Field>("rank"), SharedConstant(Value(2LL))}),
+       GreaterThanExpr(
            {std::make_shared<Field>("score"), SharedConstant(Value(80LL))})})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre(doc1));
@@ -284,10 +286,11 @@ TEST_F(InequalityPipelineTest, InequalityWithEqualityOnSameField) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr(
-      {EqExpr({std::make_shared<Field>("score"), SharedConstant(Value(90LL))}),
-       GtExpr(
-           {std::make_shared<Field>("score"), SharedConstant(Value(80LL))})})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(
+      AndExpr({EqualExpr({std::make_shared<Field>("score"),
+                          SharedConstant(Value(90LL))}),
+               GreaterThanExpr({std::make_shared<Field>("score"),
+                                SharedConstant(Value(80LL))})})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre(doc1));
 }
@@ -299,8 +302,9 @@ TEST_F(InequalityPipelineTest, WithSortOnSameField) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(GteExpr(
-      {std::make_shared<Field>("score"), SharedConstant(Value(90LL))})));
+  pipeline =
+      pipeline.AddingStage(std::make_shared<Where>(GreaterThanOrEqualExpr(
+          {std::make_shared<Field>("score"), SharedConstant(Value(90LL))})));
   pipeline = pipeline.AddingStage(
       std::make_shared<SortStage>(std::vector<Ordering>{Ordering(
           std::make_unique<Field>("score"), Ordering::Direction::ASCENDING)}));
@@ -316,8 +320,9 @@ TEST_F(InequalityPipelineTest, WithSortOnDifferentFields) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(GteExpr(
-      {std::make_shared<Field>("score"), SharedConstant(Value(90LL))})));
+  pipeline =
+      pipeline.AddingStage(std::make_shared<Where>(GreaterThanOrEqualExpr(
+          {std::make_shared<Field>("score"), SharedConstant(Value(90LL))})));
   pipeline = pipeline.AddingStage(
       std::make_shared<SortStage>(std::vector<Ordering>{Ordering(
           std::make_unique<Field>("rank"), Ordering::Direction::ASCENDING)}));
@@ -335,10 +340,11 @@ TEST_F(InequalityPipelineTest, WithOrOnSingleField) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(OrExpr(
-      {GtExpr({std::make_shared<Field>("score"), SharedConstant(Value(90LL))}),
-       LtExpr(
-           {std::make_shared<Field>("score"), SharedConstant(Value(60LL))})})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(
+      OrExpr({GreaterThanExpr({std::make_shared<Field>("score"),
+                               SharedConstant(Value(90LL))}),
+              LessThanExpr({std::make_shared<Field>("score"),
+                            SharedConstant(Value(60LL))})})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents),
               UnorderedElementsAre(doc2, doc3));
@@ -355,10 +361,11 @@ TEST_F(InequalityPipelineTest, WithOrOnDifferentFields) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(OrExpr(
-      {GtExpr({std::make_shared<Field>("score"), SharedConstant(Value(80LL))}),
-       LtExpr(
-           {std::make_shared<Field>("rank"), SharedConstant(Value(2LL))})})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(
+      OrExpr({GreaterThanExpr({std::make_shared<Field>("score"),
+                               SharedConstant(Value(80LL))}),
+              LessThanExpr({std::make_shared<Field>("rank"),
+                            SharedConstant(Value(2LL))})})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents),
               UnorderedElementsAre(doc1, doc3));
@@ -375,7 +382,8 @@ TEST_F(InequalityPipelineTest, WithEqAnyOnSingleField) {
 
   RealtimePipeline pipeline = StartPipeline("/users");
   pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr(
-      {GtExpr({std::make_shared<Field>("score"), SharedConstant(Value(80LL))}),
+      {GreaterThanExpr(
+           {std::make_shared<Field>("score"), SharedConstant(Value(80LL))}),
        EqAnyExpr(
            std::make_shared<Field>("score"),
            SharedConstant(Array(Value(50LL), Value(80LL), Value(97LL))))})));
@@ -396,7 +404,8 @@ TEST_F(InequalityPipelineTest, WithEqAnyOnDifferentFields) {
 
   RealtimePipeline pipeline = StartPipeline("/users");
   pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr(
-      {LtExpr({std::make_shared<Field>("rank"), SharedConstant(Value(3LL))}),
+      {LessThanExpr(
+           {std::make_shared<Field>("rank"), SharedConstant(Value(3LL))}),
        EqAnyExpr(
            std::make_shared<Field>("score"),
            SharedConstant(Array(Value(50LL), Value(80LL), Value(97LL))))})));
@@ -415,7 +424,8 @@ TEST_F(InequalityPipelineTest, WithNotEqAnyOnSingleField) {
 
   RealtimePipeline pipeline = StartPipeline("/users");
   pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr(
-      {GtExpr({std::make_shared<Field>("score"), SharedConstant(Value(80LL))}),
+      {GreaterThanExpr(
+           {std::make_shared<Field>("score"), SharedConstant(Value(80LL))}),
        NotEqAnyExpr(std::make_shared<Field>("score"),
                     SharedConstant(Array(Value(90LL), Value(95LL))))})));
 
@@ -488,7 +498,8 @@ TEST_F(InequalityPipelineTest, WithNotEqAnyOnDifferentFields) {
 
   RealtimePipeline pipeline = StartPipeline("/users");
   pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr(
-      {LtExpr({std::make_shared<Field>("rank"), SharedConstant(Value(3LL))}),
+      {LessThanExpr(
+           {std::make_shared<Field>("rank"), SharedConstant(Value(3LL))}),
        NotEqAnyExpr(std::make_shared<Field>("score"),
                     SharedConstant(Array(Value(90LL), Value(95LL))))})));
 
@@ -510,8 +521,8 @@ TEST_F(InequalityPipelineTest, SortByEquality) {
 
   RealtimePipeline pipeline = StartPipeline("/users");
   pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr(
-      {EqExpr({std::make_shared<Field>("rank"), SharedConstant(Value(2LL))}),
-       GtExpr(
+      {EqualExpr({std::make_shared<Field>("rank"), SharedConstant(Value(2LL))}),
+       GreaterThanExpr(
            {std::make_shared<Field>("score"), SharedConstant(Value(80LL))})})));
   pipeline = pipeline.AddingStage(std::make_shared<SortStage>(
       std::vector<Ordering>{Ordering(std::make_unique<Field>("rank"),
@@ -539,7 +550,7 @@ TEST_F(InequalityPipelineTest, WithEqAnySortByEquality) {
   pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr(
       {EqAnyExpr(std::make_shared<Field>("rank"),
                  SharedConstant(Array(Value(2LL), Value(3LL), Value(4LL)))),
-       GtExpr(
+       GreaterThanExpr(
            {std::make_shared<Field>("score"), SharedConstant(Value(80LL))})})));
   pipeline = pipeline.AddingStage(std::make_shared<SortStage>(
       std::vector<Ordering>{Ordering(std::make_unique<Field>("rank"),
@@ -567,10 +578,11 @@ TEST_F(InequalityPipelineTest, WithArray) {
 
   RealtimePipeline pipeline = StartPipeline("/users");
   pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr(
-      {LteExpr({std::make_shared<Field>("scores"),
-                SharedConstant(Array(Value(90LL), Value(90LL), Value(90LL)))}),
-       GtExpr({std::make_shared<Field>("rounds"),
-               SharedConstant(Array(Value(1LL), Value(2LL)))})})));
+      {LessThanOrEqualExpr(
+           {std::make_shared<Field>("scores"),
+            SharedConstant(Array(Value(90LL), Value(90LL), Value(90LL)))}),
+       GreaterThanExpr({std::make_shared<Field>("rounds"),
+                        SharedConstant(Array(Value(1LL), Value(2LL)))})})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre(doc1));
 }
@@ -597,8 +609,9 @@ TEST_F(InequalityPipelineTest,
 
   RealtimePipeline pipeline = StartPipeline("/users");
   pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr({
-      LteExpr({std::make_shared<Field>("scores"),
-               SharedConstant(Array(Value(90LL), Value(90LL), Value(90LL)))}),
+      LessThanOrEqualExpr(
+          {std::make_shared<Field>("scores"),
+           SharedConstant(Array(Value(90LL), Value(90LL), Value(90LL)))}),
       ArrayContainsExpr(
           {std::make_shared<Field>("rounds"),
            SharedConstant(Value(3LL))})  // TS used ArrayContains here
@@ -616,8 +629,8 @@ TEST_F(InequalityPipelineTest, WithSortAndLimit) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3, doc4};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      GtExpr({std::make_shared<Field>("score"), SharedConstant(Value(80LL))})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(GreaterThanExpr(
+      {std::make_shared<Field>("score"), SharedConstant(Value(80LL))})));
   pipeline = pipeline.AddingStage(
       std::make_shared<SortStage>(std::vector<Ordering>{Ordering(
           std::make_unique<Field>("rank"), Ordering::Direction::ASCENDING)}));
@@ -636,10 +649,11 @@ TEST_F(InequalityPipelineTest, MultipleInequalitiesOnSingleField) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr(
-      {GtExpr({std::make_shared<Field>("score"), SharedConstant(Value(90LL))}),
-       LtExpr({std::make_shared<Field>("score"),
-               SharedConstant(Value(100LL))})})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(
+      AndExpr({GreaterThanExpr({std::make_shared<Field>("score"),
+                                SharedConstant(Value(90LL))}),
+               LessThanExpr({std::make_shared<Field>("score"),
+                             SharedConstant(Value(100LL))})})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre(doc3));
 }
@@ -656,10 +670,11 @@ TEST_F(InequalityPipelineTest,
   PipelineInputOutputVector documents = {doc1, doc2, doc3};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr(
-      {GtExpr({std::make_shared<Field>("score"), SharedConstant(Value(90LL))}),
-       LtExpr(
-           {std::make_shared<Field>("rank"), SharedConstant(Value(2LL))})})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(
+      AndExpr({GreaterThanExpr({std::make_shared<Field>("score"),
+                                SharedConstant(Value(90LL))}),
+               LessThanExpr({std::make_shared<Field>("rank"),
+                             SharedConstant(Value(2LL))})})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre(doc3));
 }
@@ -677,10 +692,11 @@ TEST_F(InequalityPipelineTest,
   PipelineInputOutputVector documents = {doc1, doc2, doc3};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr(
-      {GtExpr({std::make_shared<Field>("score"), SharedConstant(Value(80LL))}),
-       LtExpr(
-           {std::make_shared<Field>("rank"), SharedConstant(Value(3LL))})})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(
+      AndExpr({GreaterThanExpr({std::make_shared<Field>("score"),
+                                SharedConstant(Value(80LL))}),
+               LessThanExpr({std::make_shared<Field>("rank"),
+                             SharedConstant(Value(3LL))})})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents),
               UnorderedElementsAre(doc1, doc3));
@@ -699,10 +715,11 @@ TEST_F(InequalityPipelineTest, MultipleInequalitiesOnDifferentFieldsAllMatch) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr(
-      {GtExpr({std::make_shared<Field>("score"), SharedConstant(Value(40LL))}),
-       LtExpr(
-           {std::make_shared<Field>("rank"), SharedConstant(Value(4LL))})})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(
+      AndExpr({GreaterThanExpr({std::make_shared<Field>("score"),
+                                SharedConstant(Value(40LL))}),
+               LessThanExpr({std::make_shared<Field>("rank"),
+                             SharedConstant(Value(4LL))})})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents),
               UnorderedElementsAre(doc1, doc2, doc3));
@@ -718,10 +735,11 @@ TEST_F(InequalityPipelineTest, MultipleInequalitiesOnDifferentFieldsNoMatch) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr(
-      {LtExpr({std::make_shared<Field>("score"), SharedConstant(Value(90LL))}),
-       GtExpr(
-           {std::make_shared<Field>("rank"), SharedConstant(Value(3LL))})})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(
+      AndExpr({LessThanExpr({std::make_shared<Field>("score"),
+                             SharedConstant(Value(90LL))}),
+               GreaterThanExpr({std::make_shared<Field>("rank"),
+                                SharedConstant(Value(3LL))})})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre());
 }
@@ -739,12 +757,15 @@ TEST_F(InequalityPipelineTest, MultipleInequalitiesWithBoundedRanges) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3, doc4};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr(
-      {GtExpr({std::make_shared<Field>("rank"), SharedConstant(Value(0LL))}),
-       LtExpr({std::make_shared<Field>("rank"), SharedConstant(Value(4LL))}),
-       GtExpr({std::make_shared<Field>("score"), SharedConstant(Value(80LL))}),
-       LtExpr(
-           {std::make_shared<Field>("score"), SharedConstant(Value(95LL))})})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(
+      AndExpr({GreaterThanExpr({std::make_shared<Field>("rank"),
+                                SharedConstant(Value(0LL))}),
+               LessThanExpr({std::make_shared<Field>("rank"),
+                             SharedConstant(Value(4LL))}),
+               GreaterThanExpr({std::make_shared<Field>("score"),
+                                SharedConstant(Value(80LL))}),
+               LessThanExpr({std::make_shared<Field>("score"),
+                             SharedConstant(Value(95LL))})})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre(doc1));
 }
@@ -758,10 +779,11 @@ TEST_F(InequalityPipelineTest, MultipleInequalitiesWithSingleSortAsc) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr(
-      {LtExpr({std::make_shared<Field>("rank"), SharedConstant(Value(3LL))}),
-       GtExpr(
-           {std::make_shared<Field>("score"), SharedConstant(Value(80LL))})})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(
+      AndExpr({LessThanExpr({std::make_shared<Field>("rank"),
+                             SharedConstant(Value(3LL))}),
+               GreaterThanExpr({std::make_shared<Field>("score"),
+                                SharedConstant(Value(80LL))})})));
   pipeline = pipeline.AddingStage(
       std::make_shared<SortStage>(std::vector<Ordering>{Ordering(
           std::make_unique<Field>("rank"), Ordering::Direction::ASCENDING)}));
@@ -778,10 +800,11 @@ TEST_F(InequalityPipelineTest, MultipleInequalitiesWithSingleSortDesc) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr(
-      {LtExpr({std::make_shared<Field>("rank"), SharedConstant(Value(3LL))}),
-       GtExpr(
-           {std::make_shared<Field>("score"), SharedConstant(Value(80LL))})})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(
+      AndExpr({LessThanExpr({std::make_shared<Field>("rank"),
+                             SharedConstant(Value(3LL))}),
+               GreaterThanExpr({std::make_shared<Field>("score"),
+                                SharedConstant(Value(80LL))})})));
   pipeline = pipeline.AddingStage(
       std::make_shared<SortStage>(std::vector<Ordering>{Ordering(
           std::make_unique<Field>("rank"), Ordering::Direction::DESCENDING)}));
@@ -798,10 +821,11 @@ TEST_F(InequalityPipelineTest, MultipleInequalitiesWithMultipleSortAsc) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr(
-      {LtExpr({std::make_shared<Field>("rank"), SharedConstant(Value(3LL))}),
-       GtExpr(
-           {std::make_shared<Field>("score"), SharedConstant(Value(80LL))})})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(
+      AndExpr({LessThanExpr({std::make_shared<Field>("rank"),
+                             SharedConstant(Value(3LL))}),
+               GreaterThanExpr({std::make_shared<Field>("score"),
+                                SharedConstant(Value(80LL))})})));
   pipeline = pipeline.AddingStage(std::make_shared<SortStage>(
       std::vector<Ordering>{Ordering(std::make_unique<Field>("rank"),
                                      Ordering::Direction::ASCENDING),
@@ -820,10 +844,11 @@ TEST_F(InequalityPipelineTest, MultipleInequalitiesWithMultipleSortDesc) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr(
-      {LtExpr({std::make_shared<Field>("rank"), SharedConstant(Value(3LL))}),
-       GtExpr(
-           {std::make_shared<Field>("score"), SharedConstant(Value(80LL))})})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(
+      AndExpr({LessThanExpr({std::make_shared<Field>("rank"),
+                             SharedConstant(Value(3LL))}),
+               GreaterThanExpr({std::make_shared<Field>("score"),
+                                SharedConstant(Value(80LL))})})));
   pipeline = pipeline.AddingStage(std::make_shared<SortStage>(
       std::vector<Ordering>{Ordering(std::make_unique<Field>("rank"),
                                      Ordering::Direction::DESCENDING),
@@ -843,10 +868,11 @@ TEST_F(InequalityPipelineTest,
   PipelineInputOutputVector documents = {doc1, doc2, doc3};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr(
-      {LtExpr({std::make_shared<Field>("rank"), SharedConstant(Value(3LL))}),
-       GtExpr(
-           {std::make_shared<Field>("score"), SharedConstant(Value(80LL))})})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(
+      AndExpr({LessThanExpr({std::make_shared<Field>("rank"),
+                             SharedConstant(Value(3LL))}),
+               GreaterThanExpr({std::make_shared<Field>("score"),
+                                SharedConstant(Value(80LL))})})));
   pipeline = pipeline.AddingStage(std::make_shared<SortStage>(
       std::vector<Ordering>{Ordering(std::make_unique<Field>("score"),
                                      Ordering::Direction::DESCENDING),
diff --git a/Firestore/core/test/unit/core/pipeline/nested_properties_test.cc b/Firestore/core/test/unit/core/pipeline/nested_properties_test.cc
index 84b2197c725..bdeaf3fa51f 100644
--- a/Firestore/core/test/unit/core/pipeline/nested_properties_test.cc
+++ b/Firestore/core/test/unit/core/pipeline/nested_properties_test.cc
@@ -66,13 +66,13 @@ using testutil::Map;
 using testutil::SharedConstant;
 using testutil::Value;
 // Expression helpers
-using testutil::EqExpr;
+using testutil::EqualExpr;
 using testutil::ExistsExpr;
-using testutil::GteExpr;
-using testutil::GtExpr;
+using testutil::GreaterThanExpr;
+using testutil::GreaterThanOrEqualExpr;
 using testutil::IsNullExpr;
-using testutil::LtExpr;
-using testutil::NeqExpr;
+using testutil::LessThanExpr;
+using testutil::NotEqualExpr;
 using testutil::NotExpr;
 
 // Test Fixture for Nested Properties Pipeline tests
@@ -129,8 +129,8 @@ TEST_F(NestedPropertiesPipelineTest, WhereEqualityDeeplyNested) {
 
   RealtimePipeline pipeline = StartPipeline("/users");
   pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      EqExpr({std::make_shared<Field>("a.b.c.d.e.f.g.h.i.j.k"),
-              SharedConstant(Value(42LL))})));
+      EqualExpr({std::make_shared<Field>("a.b.c.d.e.f.g.h.i.j.k"),
+                 SharedConstant(Value(42LL))})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre(doc1));
 }
@@ -180,8 +180,8 @@ TEST_F(NestedPropertiesPipelineTest, WhereInequalityDeeplyNested) {
 
   RealtimePipeline pipeline = StartPipeline("/users");
   pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      GteExpr({std::make_shared<Field>("a.b.c.d.e.f.g.h.i.j.k"),
-               SharedConstant(Value(0LL))})));
+      GreaterThanOrEqualExpr({std::make_shared<Field>("a.b.c.d.e.f.g.h.i.j.k"),
+                              SharedConstant(Value(0LL))})));
   pipeline =
       pipeline.AddingStage(std::make_shared<SortStage>(std::vector<Ordering>{
           Ordering(std::make_unique<Field>(FieldPath::kDocumentKeyPath),
@@ -205,9 +205,9 @@ TEST_F(NestedPropertiesPipelineTest, WhereEquality) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3, doc4};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(
-      std::make_shared<Where>(EqExpr({std::make_shared<Field>("address.street"),
-                                      SharedConstant(Value("76"))})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(
+      EqualExpr({std::make_shared<Field>("address.street"),
+                 SharedConstant(Value("76"))})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre(doc2));
 }
@@ -227,11 +227,11 @@ TEST_F(NestedPropertiesPipelineTest, MultipleFilters) {
 
   RealtimePipeline pipeline = StartPipeline("/users");
   pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      EqExpr({std::make_shared<Field>("address.city"),
-              SharedConstant(Value("San Francisco"))})));
-  pipeline = pipeline.AddingStage(
-      std::make_shared<Where>(GtExpr({std::make_shared<Field>("address.zip"),
-                                      SharedConstant(Value(90000LL))})));
+      EqualExpr({std::make_shared<Field>("address.city"),
+                 SharedConstant(Value("San Francisco"))})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(
+      GreaterThanExpr({std::make_shared<Field>("address.zip"),
+                       SharedConstant(Value(90000LL))})));
 
   // city == "San Francisco" AND zip > 90000
   // doc1: T AND 94105 > 90000 (T) -> True
@@ -255,13 +255,13 @@ TEST_F(NestedPropertiesPipelineTest, MultipleFiltersRedundant) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3, doc4};
 
   RealtimePipeline pipeline = StartPipeline("/users");
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(EqualExpr(
+      {std::make_shared<Field>("address"),
+       SharedConstant(Map(  // Use testutil::Map helper
+           "city", "San Francisco", "state", "CA", "zip", 94105LL))})));
   pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      EqExpr({std::make_shared<Field>("address"),
-              SharedConstant(Map(  // Use testutil::Map helper
-                  "city", "San Francisco", "state", "CA", "zip", 94105LL))})));
-  pipeline = pipeline.AddingStage(
-      std::make_shared<Where>(GtExpr({std::make_shared<Field>("address.zip"),
-                                      SharedConstant(Value(90000LL))})));
+      GreaterThanExpr({std::make_shared<Field>("address.zip"),
+                       SharedConstant(Value(90000LL))})));
 
   // address == {city: SF, state: CA, zip: 94105} AND address.zip > 90000
   // doc1: T AND 94105 > 90000 (T) -> True
@@ -288,11 +288,11 @@ TEST_F(NestedPropertiesPipelineTest, MultipleFiltersWithCompositeIndex) {
 
   RealtimePipeline pipeline = StartPipeline("/users");
   pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      EqExpr({std::make_shared<Field>("address.city"),
-              SharedConstant(Value("San Francisco"))})));
-  pipeline = pipeline.AddingStage(
-      std::make_shared<Where>(GtExpr({std::make_shared<Field>("address.zip"),
-                                      SharedConstant(Value(90000LL))})));
+      EqualExpr({std::make_shared<Field>("address.city"),
+                 SharedConstant(Value("San Francisco"))})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(
+      GreaterThanExpr({std::make_shared<Field>("address.zip"),
+                       SharedConstant(Value(90000LL))})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre(doc1));
 }
@@ -314,26 +314,26 @@ TEST_F(NestedPropertiesPipelineTest, WhereInequality) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3, doc4};
 
   RealtimePipeline pipeline1 = StartPipeline("/users");
-  pipeline1 = pipeline1.AddingStage(
-      std::make_shared<Where>(GtExpr({std::make_shared<Field>("address.zip"),
-                                      SharedConstant(Value(90000LL))})));
+  pipeline1 = pipeline1.AddingStage(std::make_shared<Where>(
+      GreaterThanExpr({std::make_shared<Field>("address.zip"),
+                       SharedConstant(Value(90000LL))})));
   EXPECT_THAT(RunPipeline(pipeline1, documents), ElementsAre(doc1, doc3));
 
   RealtimePipeline pipeline2 = StartPipeline("/users");
-  pipeline2 = pipeline2.AddingStage(
-      std::make_shared<Where>(LtExpr({std::make_shared<Field>("address.zip"),
-                                      SharedConstant(Value(90000LL))})));
+  pipeline2 = pipeline2.AddingStage(std::make_shared<Where>(
+      LessThanExpr({std::make_shared<Field>("address.zip"),
+                    SharedConstant(Value(90000LL))})));
   EXPECT_THAT(RunPipeline(pipeline2, documents), ElementsAre(doc2));
 
   RealtimePipeline pipeline3 = StartPipeline("/users");
-  pipeline3 = pipeline3.AddingStage(std::make_shared<Where>(LtExpr(
+  pipeline3 = pipeline3.AddingStage(std::make_shared<Where>(LessThanExpr(
       {std::make_shared<Field>("address.zip"), SharedConstant(Value(0LL))})));
   EXPECT_THAT(RunPipeline(pipeline3, documents), IsEmpty());
 
   RealtimePipeline pipeline4 = StartPipeline("/users");
-  pipeline4 = pipeline4.AddingStage(
-      std::make_shared<Where>(NeqExpr({std::make_shared<Field>("address.zip"),
-                                       SharedConstant(Value(10011LL))})));
+  pipeline4 = pipeline4.AddingStage(std::make_shared<Where>(
+      NotEqualExpr({std::make_shared<Field>("address.zip"),
+                    SharedConstant(Value(10011LL))})));
   EXPECT_THAT(RunPipeline(pipeline4, documents), ElementsAre(doc1, doc3));
 }
 
@@ -474,8 +474,8 @@ TEST_F(NestedPropertiesPipelineTest, QuotedNestedPropertyFilterNested) {
 
   RealtimePipeline pipeline = StartPipeline("/users");
   pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      EqExpr({std::make_shared<Field>("address.city"),
-              SharedConstant(Value("San Francisco"))})));
+      EqualExpr({std::make_shared<Field>("address.city"),
+                 SharedConstant(Value("San Francisco"))})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre(doc2));
 }
@@ -491,8 +491,8 @@ TEST_F(NestedPropertiesPipelineTest, QuotedNestedPropertyFilterQuotedNested) {
   RealtimePipeline pipeline = StartPipeline("/users");
   // Use FieldPath constructor for field names containing dots
   pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      EqExpr({std::make_shared<Field>(FieldPath({"address.city"})),
-              SharedConstant(Value("San Francisco"))})));
+      EqualExpr({std::make_shared<Field>(FieldPath({"address.city"})),
+                 SharedConstant(Value("San Francisco"))})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre(doc1));
 }
diff --git a/Firestore/core/test/unit/core/pipeline/null_semantics_test.cc b/Firestore/core/test/unit/core/pipeline/null_semantics_test.cc
index c04d0a9594e..d55e1e3d12c 100644
--- a/Firestore/core/test/unit/core/pipeline/null_semantics_test.cc
+++ b/Firestore/core/test/unit/core/pipeline/null_semantics_test.cc
@@ -66,16 +66,16 @@ using testutil::ArrayContainsAllExpr;
 using testutil::ArrayContainsAnyExpr;
 using testutil::ArrayContainsExpr;
 using testutil::EqAnyExpr;
-using testutil::EqExpr;
-using testutil::GteExpr;
-using testutil::GtExpr;
+using testutil::EqualExpr;
+using testutil::GreaterThanExpr;
+using testutil::GreaterThanOrEqualExpr;
 using testutil::IsErrorExpr;  // Add using for IsErrorExpr
 using testutil::IsNanExpr;
 using testutil::IsNullExpr;
-using testutil::LteExpr;
-using testutil::LtExpr;
-using testutil::NeqExpr;
+using testutil::LessThanExpr;
+using testutil::LessThanOrEqualExpr;
 using testutil::NotEqAnyExpr;
+using testutil::NotEqualExpr;
 using testutil::NotExpr;
 using testutil::OrExpr;
 using testutil::XorExpr;
@@ -166,7 +166,7 @@ TEST_F(NullSemanticsPipelineTest, WhereEqConstantAsNull) {
 
   RealtimePipeline pipeline = StartPipeline("/users");
   // Equality filters never match null or missing fields.
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(EqExpr(
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(EqualExpr(
       {std::make_shared<Field>("score"), SharedConstant(Value(nullptr))})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre());
@@ -183,7 +183,7 @@ TEST_F(NullSemanticsPipelineTest, WhereEqFieldAsNull) {
   RealtimePipeline pipeline = StartPipeline("/users");
   // Equality filters never match null or missing fields, even against other
   // fields.
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(EqExpr(
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(EqualExpr(
       {std::make_shared<Field>("score"), std::make_shared<Field>("rank")})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre());
@@ -203,8 +203,8 @@ TEST_F(NullSemanticsPipelineTest, WhereEqSegmentField) {
   RealtimePipeline pipeline = StartPipeline("/users");
   // Equality filters never match null or missing fields.
   pipeline = pipeline.AddingStage(
-      std::make_shared<Where>(EqExpr({std::make_shared<Field>("score.bonus"),
-                                      SharedConstant(Value(nullptr))})));
+      std::make_shared<Where>(EqualExpr({std::make_shared<Field>("score.bonus"),
+                                         SharedConstant(Value(nullptr))})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre());
 }
@@ -228,10 +228,10 @@ TEST_F(NullSemanticsPipelineTest, WhereEqSingleFieldAndSegmentField) {
   RealtimePipeline pipeline = StartPipeline("/users");
   // Equality filters never match null or missing fields.
   pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      AndExpr({EqExpr({std::make_shared<Field>("score.bonus"),
-                       SharedConstant(Value(nullptr))}),
-               EqExpr({std::make_shared<Field>("rank"),
-                       SharedConstant(Value(nullptr))})})));
+      AndExpr({EqualExpr({std::make_shared<Field>("score.bonus"),
+                          SharedConstant(Value(nullptr))}),
+               EqualExpr({std::make_shared<Field>("rank"),
+                          SharedConstant(Value(nullptr))})})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre());
 }
@@ -250,8 +250,8 @@ TEST_F(NullSemanticsPipelineTest, WhereEqNullInArray) {
   RealtimePipeline pipeline = StartPipeline("/k");
   // Equality filters never match null values, even within arrays.
   pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      EqExpr({std::make_shared<Field>("foo"),
-              SharedConstant(Value(Array(Value(nullptr))))})));
+      EqualExpr({std::make_shared<Field>("foo"),
+                 SharedConstant(Value(Array(Value(nullptr))))})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre());
 }
@@ -275,8 +275,8 @@ TEST_F(NullSemanticsPipelineTest, WhereEqNullOtherInArray) {
   RealtimePipeline pipeline = StartPipeline("/k");
   // Equality filters never match null values, even within arrays.
   pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      EqExpr({std::make_shared<Field>("foo"),
-              SharedConstant(Value(Array(Value(1.0), Value(nullptr))))})));
+      EqualExpr({std::make_shared<Field>("foo"),
+                 SharedConstant(Value(Array(Value(1.0), Value(nullptr))))})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre());
 }
@@ -294,11 +294,11 @@ TEST_F(NullSemanticsPipelineTest, WhereEqNullNanInArray) {
 
   RealtimePipeline pipeline = StartPipeline("/k");
   // Equality filters never match null or NaN values, even within arrays.
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      EqExpr({std::make_shared<Field>("foo"),
-              SharedConstant(Value(
-                  Array(Value(nullptr),
-                        Value(std::numeric_limits<double>::quiet_NaN()))))})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(EqualExpr(
+      {std::make_shared<Field>("foo"),
+       SharedConstant(
+           Value(Array(Value(nullptr),
+                       Value(std::numeric_limits<double>::quiet_NaN()))))})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre());
 }
@@ -313,7 +313,7 @@ TEST_F(NullSemanticsPipelineTest, WhereEqNullInMap) {
 
   RealtimePipeline pipeline = StartPipeline("/k");
   // Equality filters never match null values, even within maps.
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(EqExpr(
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(EqualExpr(
       {std::make_shared<Field>("foo"), SharedConstant(Map("a", nullptr))})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre());
@@ -333,8 +333,8 @@ TEST_F(NullSemanticsPipelineTest, WhereEqNullOtherInMap) {
   RealtimePipeline pipeline = StartPipeline("/k");
   // Equality filters never match null values, even within maps.
   pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      EqExpr({std::make_shared<Field>("foo"),
-              SharedConstant(Map("a", 1.0, "b", nullptr))})));
+      EqualExpr({std::make_shared<Field>("foo"),
+                 SharedConstant(Map("a", 1.0, "b", nullptr))})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre());
 }
@@ -349,10 +349,10 @@ TEST_F(NullSemanticsPipelineTest, WhereEqNullNanInMap) {
 
   RealtimePipeline pipeline = StartPipeline("/k");
   // Equality filters never match null or NaN values, even within maps.
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      EqExpr({std::make_shared<Field>("foo"),
-              SharedConstant(Map("a", nullptr, "b",
-                                 std::numeric_limits<double>::quiet_NaN()))})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(EqualExpr(
+      {std::make_shared<Field>("foo"),
+       SharedConstant(Map("a", nullptr, "b",
+                          std::numeric_limits<double>::quiet_NaN()))})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre());
 }
@@ -382,8 +382,8 @@ TEST_F(NullSemanticsPipelineTest, WhereEqMapWithNullArray) {
   RealtimePipeline pipeline = StartPipeline("/k");
   // Equality filters never match null values, even within nested arrays/maps.
   pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      EqExpr({std::make_shared<Field>("foo"),
-              SharedConstant(Map("a", Value(Array(Value(nullptr)))))})));
+      EqualExpr({std::make_shared<Field>("foo"),
+                 SharedConstant(Map("a", Value(Array(Value(nullptr)))))})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre());
 }
@@ -417,7 +417,7 @@ TEST_F(NullSemanticsPipelineTest, WhereEqMapWithNullOtherArray) {
 
   RealtimePipeline pipeline = StartPipeline("/k");
   // Equality filters never match null values, even within nested arrays/maps.
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(EqExpr(
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(EqualExpr(
       {std::make_shared<Field>("foo"),
        SharedConstant(Map("a", Value(Array(Value(1.0), Value(nullptr)))))})));
 
@@ -449,7 +449,7 @@ TEST_F(NullSemanticsPipelineTest, WhereEqMapWithNullNanArray) {
   RealtimePipeline pipeline = StartPipeline("/k");
   // Equality filters never match null or NaN values, even within nested
   // arrays/maps.
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(EqExpr(
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(EqualExpr(
       {std::make_shared<Field>("foo"),
        SharedConstant(Map(
            "a",
@@ -466,10 +466,11 @@ TEST_F(NullSemanticsPipelineTest, WhereCompositeConditionWithNull) {
 
   RealtimePipeline pipeline = StartPipeline("/users");
   // Equality filters never match null values.
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr(
-      {EqExpr({std::make_shared<Field>("score"), SharedConstant(Value(42LL))}),
-       EqExpr({std::make_shared<Field>("rank"),
-               SharedConstant(Value(nullptr))})})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(
+      AndExpr({EqualExpr({std::make_shared<Field>("score"),
+                          SharedConstant(Value(42LL))}),
+               EqualExpr({std::make_shared<Field>("rank"),
+                          SharedConstant(Value(nullptr))})})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre());
 }
@@ -660,7 +661,7 @@ TEST_F(NullSemanticsPipelineTest, WhereNeqConstantAsNull) {
 
   RealtimePipeline pipeline = StartPipeline("/users");
   // != null is not a supported query.
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(NeqExpr(
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(NotEqualExpr(
       {std::make_shared<Field>("score"), SharedConstant(Value(nullptr))})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre());
@@ -676,7 +677,7 @@ TEST_F(NullSemanticsPipelineTest, WhereNeqFieldAsNull) {
 
   RealtimePipeline pipeline = StartPipeline("/users");
   // != null is not a supported query, even against fields.
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(NeqExpr(
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(NotEqualExpr(
       {std::make_shared<Field>("score"), std::make_shared<Field>("rank")})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre());
@@ -696,8 +697,8 @@ TEST_F(NullSemanticsPipelineTest, WhereNeqNullInArray) {
   RealtimePipeline pipeline = StartPipeline("/k");
   // != [null] is not a supported query.
   pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      NeqExpr({std::make_shared<Field>("foo"),
-               SharedConstant(Value(Array(Value(nullptr))))})));
+      NotEqualExpr({std::make_shared<Field>("foo"),
+                    SharedConstant(Value(Array(Value(nullptr))))})));
 
   // Based on TS result, this seems to match documents where 'foo' is not
   // exactly `[null]`. This behavior might differ in C++ SDK. Assuming it
@@ -723,9 +724,9 @@ TEST_F(NullSemanticsPipelineTest, WhereNeqNullOtherInArray) {
 
   RealtimePipeline pipeline = StartPipeline("/k");
   // != [1.0, null] is not a supported query.
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      NeqExpr({std::make_shared<Field>("foo"),
-               SharedConstant(Value(Array(Value(1.0), Value(nullptr))))})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(NotEqualExpr(
+      {std::make_shared<Field>("foo"),
+       SharedConstant(Value(Array(Value(1.0), Value(nullptr))))})));
 
   // Based on TS result.
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre(doc1));
@@ -744,11 +745,11 @@ TEST_F(NullSemanticsPipelineTest, WhereNeqNullNanInArray) {
 
   RealtimePipeline pipeline = StartPipeline("/k");
   // != [null, NaN] is not a supported query.
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      NeqExpr({std::make_shared<Field>("foo"),
-               SharedConstant(Value(
-                   Array(Value(nullptr),
-                         Value(std::numeric_limits<double>::quiet_NaN()))))})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(NotEqualExpr(
+      {std::make_shared<Field>("foo"),
+       SharedConstant(
+           Value(Array(Value(nullptr),
+                       Value(std::numeric_limits<double>::quiet_NaN()))))})));
 
   // Based on TS result.
   EXPECT_THAT(
@@ -775,7 +776,7 @@ TEST_F(NullSemanticsPipelineTest, WhereNeqNullInMap) {
 
   RealtimePipeline pipeline = StartPipeline("/k");
   // != {a: null} is not a supported query.
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(NeqExpr(
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(NotEqualExpr(
       {std::make_shared<Field>("foo"), SharedConstant(Map("a", nullptr))})));
 
   // Based on TS result.
@@ -797,8 +798,8 @@ TEST_F(NullSemanticsPipelineTest, WhereNeqNullOtherInMap) {
   RealtimePipeline pipeline = StartPipeline("/k");
   // != {a: 1.0, b: null} is not a supported query.
   pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      NeqExpr({std::make_shared<Field>("foo"),
-               SharedConstant(Map("a", 1.0, "b", nullptr))})));
+      NotEqualExpr({std::make_shared<Field>("foo"),
+                    SharedConstant(Map("a", 1.0, "b", nullptr))})));
 
   // Based on TS result.
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre(doc1));
@@ -814,7 +815,7 @@ TEST_F(NullSemanticsPipelineTest, WhereNeqNullNanInMap) {
 
   RealtimePipeline pipeline = StartPipeline("/k");
   // != {a: null, b: NaN} is not a supported query.
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(NeqExpr(
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(NotEqualExpr(
       {std::make_shared<Field>("foo"),
        SharedConstant(Map("a", nullptr, "b",
                           std::numeric_limits<double>::quiet_NaN()))})));
@@ -858,7 +859,7 @@ TEST_F(NullSemanticsPipelineTest, WhereGt) {
 
   RealtimePipeline pipeline = StartPipeline("users");
   // > null is not supported.
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(GtExpr(
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(GreaterThanExpr(
       {std::make_shared<Field>("score"), SharedConstant(Value(nullptr))})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre());
@@ -875,8 +876,9 @@ TEST_F(NullSemanticsPipelineTest, WhereGte) {
 
   RealtimePipeline pipeline = StartPipeline("users");
   // >= null is not supported.
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(GteExpr(
-      {std::make_shared<Field>("score"), SharedConstant(Value(nullptr))})));
+  pipeline =
+      pipeline.AddingStage(std::make_shared<Where>(GreaterThanOrEqualExpr(
+          {std::make_shared<Field>("score"), SharedConstant(Value(nullptr))})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre());
 }
@@ -892,7 +894,7 @@ TEST_F(NullSemanticsPipelineTest, WhereLt) {
 
   RealtimePipeline pipeline = StartPipeline("users");
   // < null is not supported.
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(LtExpr(
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(LessThanExpr(
       {std::make_shared<Field>("score"), SharedConstant(Value(nullptr))})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre());
@@ -909,7 +911,7 @@ TEST_F(NullSemanticsPipelineTest, WhereLte) {
 
   RealtimePipeline pipeline = StartPipeline("users");
   // <= null is not supported.
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(LteExpr(
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(LessThanOrEqualExpr(
       {std::make_shared<Field>("score"), SharedConstant(Value(nullptr))})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre());
@@ -930,8 +932,9 @@ TEST_F(NullSemanticsPipelineTest, WhereAnd) {
   RealtimePipeline pipeline = StartPipeline("k");
   // Need explicit boolean comparison
   pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr(
-      {EqExpr({std::make_shared<Field>("a"), SharedConstant(Value(true))}),
-       EqExpr({std::make_shared<Field>("b"), SharedConstant(Value(true))})})));
+      {EqualExpr({std::make_shared<Field>("a"), SharedConstant(Value(true))}),
+       EqualExpr(
+           {std::make_shared<Field>("b"), SharedConstant(Value(true))})})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre(doc4));
 }
@@ -951,8 +954,9 @@ TEST_F(NullSemanticsPipelineTest, WhereIsNullAnd) {
   RealtimePipeline pipeline = StartPipeline("k");
   // Need explicit boolean comparison
   pipeline = pipeline.AddingStage(std::make_shared<Where>(IsNullExpr(AndExpr(
-      {EqExpr({std::make_shared<Field>("a"), SharedConstant(Value(true))}),
-       EqExpr({std::make_shared<Field>("b"), SharedConstant(Value(true))})}))));
+      {EqualExpr({std::make_shared<Field>("a"), SharedConstant(Value(true))}),
+       EqualExpr(
+           {std::make_shared<Field>("b"), SharedConstant(Value(true))})}))));
 
   // Expect docs where (a==true AND b==true) evaluates to NULL.
   // This happens if either a or b is null/missing AND the other is not false.
@@ -998,9 +1002,10 @@ TEST_F(NullSemanticsPipelineTest, WhereIsErrorAnd) {
   // This happens if either a or b is missing.
   pipeline = pipeline.AddingStage(
       std::make_shared<Where>(IsErrorExpr(AndExpr(  // Use IsErrorExpr helper
-          {EqExpr({std::make_shared<Field>("a"), SharedConstant(Value(true))}),
-           EqExpr({std::make_shared<Field>("b"),
-                   SharedConstant(Value(true))})}))));
+          {EqualExpr(
+               {std::make_shared<Field>("a"), SharedConstant(Value(true))}),
+           EqualExpr({std::make_shared<Field>("b"),
+                      SharedConstant(Value(true))})}))));
 
   EXPECT_THAT(RunPipeline(pipeline, documents),
               UnorderedElementsAre(doc2, doc5, doc8));
@@ -1015,8 +1020,9 @@ TEST_F(NullSemanticsPipelineTest, WhereOr) {
   RealtimePipeline pipeline = StartPipeline("k");
   // Need explicit boolean comparison
   pipeline = pipeline.AddingStage(std::make_shared<Where>(OrExpr(
-      {EqExpr({std::make_shared<Field>("a"), SharedConstant(Value(true))}),
-       EqExpr({std::make_shared<Field>("b"), SharedConstant(Value(true))})})));
+      {EqualExpr({std::make_shared<Field>("a"), SharedConstant(Value(true))}),
+       EqualExpr(
+           {std::make_shared<Field>("b"), SharedConstant(Value(true))})})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre(doc1));
 }
@@ -1036,8 +1042,9 @@ TEST_F(NullSemanticsPipelineTest, WhereIsNullOr) {
   RealtimePipeline pipeline = StartPipeline("k");
   // Need explicit boolean comparison
   pipeline = pipeline.AddingStage(std::make_shared<Where>(IsNullExpr(OrExpr(
-      {EqExpr({std::make_shared<Field>("a"), SharedConstant(Value(true))}),
-       EqExpr({std::make_shared<Field>("b"), SharedConstant(Value(true))})}))));
+      {EqualExpr({std::make_shared<Field>("a"), SharedConstant(Value(true))}),
+       EqualExpr(
+           {std::make_shared<Field>("b"), SharedConstant(Value(true))})}))));
 
   // Expect docs where (a==true OR b==true) evaluates to NULL.
   // This happens if neither is true AND at least one is null/missing.
@@ -1084,9 +1091,10 @@ TEST_F(NullSemanticsPipelineTest, WhereIsErrorOr) {
   // This happens if either a or b is missing.
   pipeline = pipeline.AddingStage(
       std::make_shared<Where>(IsErrorExpr(OrExpr(  // Use IsErrorExpr helper
-          {EqExpr({std::make_shared<Field>("a"), SharedConstant(Value(true))}),
-           EqExpr({std::make_shared<Field>("b"),
-                   SharedConstant(Value(true))})}))));
+          {EqualExpr(
+               {std::make_shared<Field>("a"), SharedConstant(Value(true))}),
+           EqualExpr({std::make_shared<Field>("b"),
+                      SharedConstant(Value(true))})}))));
 
   EXPECT_THAT(RunPipeline(pipeline, documents),
               UnorderedElementsAre(doc2, doc5, doc8));
@@ -1108,8 +1116,9 @@ TEST_F(NullSemanticsPipelineTest, WhereXor) {
   RealtimePipeline pipeline = StartPipeline("k");
   // Need explicit boolean comparison and assume XorExpr exists
   pipeline = pipeline.AddingStage(std::make_shared<Where>(XorExpr(
-      {EqExpr({std::make_shared<Field>("a"), SharedConstant(Value(true))}),
-       EqExpr({std::make_shared<Field>("b"), SharedConstant(Value(true))})})));
+      {EqualExpr({std::make_shared<Field>("a"), SharedConstant(Value(true))}),
+       EqualExpr(
+           {std::make_shared<Field>("b"), SharedConstant(Value(true))})})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre(doc4));
 }
@@ -1129,8 +1138,9 @@ TEST_F(NullSemanticsPipelineTest, WhereIsNullXor) {
   RealtimePipeline pipeline = StartPipeline("k");
   // Need explicit boolean comparison and assume XorExpr exists
   pipeline = pipeline.AddingStage(std::make_shared<Where>(IsNullExpr(XorExpr(
-      {EqExpr({std::make_shared<Field>("a"), SharedConstant(Value(true))}),
-       EqExpr({std::make_shared<Field>("b"), SharedConstant(Value(true))})}))));
+      {EqualExpr({std::make_shared<Field>("a"), SharedConstant(Value(true))}),
+       EqualExpr(
+           {std::make_shared<Field>("b"), SharedConstant(Value(true))})}))));
 
   // Expect docs where (a==true XOR b==true) evaluates to NULL.
   // This happens if either operand is null/missing.
@@ -1177,9 +1187,10 @@ TEST_F(NullSemanticsPipelineTest, WhereIsErrorXor) {
   // This happens if either a or b is missing.
   pipeline = pipeline.AddingStage(
       std::make_shared<Where>(IsErrorExpr(XorExpr(  // Use IsErrorExpr helper
-          {EqExpr({std::make_shared<Field>("a"), SharedConstant(Value(true))}),
-           EqExpr({std::make_shared<Field>("b"),
-                   SharedConstant(Value(true))})}))));
+          {EqualExpr(
+               {std::make_shared<Field>("a"), SharedConstant(Value(true))}),
+           EqualExpr({std::make_shared<Field>("b"),
+                      SharedConstant(Value(true))})}))));
 
   EXPECT_THAT(RunPipeline(pipeline, documents),
               UnorderedElementsAre(doc2, doc5, doc8));
@@ -1196,7 +1207,7 @@ TEST_F(NullSemanticsPipelineTest, WhereNot) {
 
   RealtimePipeline pipeline = StartPipeline("k");
   pipeline = pipeline.AddingStage(std::make_shared<Where>(NotExpr(
-      EqExpr({std::make_shared<Field>("a"), SharedConstant(Value(true))}))));
+      EqualExpr({std::make_shared<Field>("a"), SharedConstant(Value(true))}))));
 
   // Based on TS result, only doc2 matches. This implies NOT only works if the
   // inner expression evaluates cleanly to a boolean. Let's adjust expectation
@@ -1215,8 +1226,9 @@ TEST_F(NullSemanticsPipelineTest, WhereIsNullNot) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3};
 
   RealtimePipeline pipeline = StartPipeline("k");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(IsNullExpr(NotExpr(
-      EqExpr({std::make_shared<Field>("a"), SharedConstant(Value(true))})))));
+  pipeline =
+      pipeline.AddingStage(std::make_shared<Where>(IsNullExpr(NotExpr(EqualExpr(
+          {std::make_shared<Field>("a"), SharedConstant(Value(true))})))));
 
   // Based on TS result, only doc3 matches. This implies NOT(null_operand)
   // results in null. Let's adjust expectation to match TS.
@@ -1243,7 +1255,7 @@ TEST_F(NullSemanticsPipelineTest, WhereIsErrorNot) {
   // This happens if a is missing.
   pipeline = pipeline.AddingStage(
       std::make_shared<Where>(IsErrorExpr(NotExpr(  // Use IsErrorExpr helper
-          EqExpr(
+          EqualExpr(
               {std::make_shared<Field>("a"), SharedConstant(Value(true))})))));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre(doc4));
diff --git a/Firestore/core/test/unit/core/pipeline/number_semantics_test.cc b/Firestore/core/test/unit/core/pipeline/number_semantics_test.cc
index cf05c027088..2f2aff0ead5 100644
--- a/Firestore/core/test/unit/core/pipeline/number_semantics_test.cc
+++ b/Firestore/core/test/unit/core/pipeline/number_semantics_test.cc
@@ -66,15 +66,15 @@ using testutil::ArrayContainsAllExpr;
 using testutil::ArrayContainsAnyExpr;
 using testutil::ArrayContainsExpr;
 using testutil::EqAnyExpr;
-using testutil::EqExpr;
-using testutil::GteExpr;
-using testutil::GtExpr;
+using testutil::EqualExpr;
+using testutil::GreaterThanExpr;
+using testutil::GreaterThanOrEqualExpr;
 using testutil::IsNanExpr;
 using testutil::IsNullExpr;
-using testutil::LteExpr;
-using testutil::LtExpr;
-using testutil::NeqExpr;
+using testutil::LessThanExpr;
+using testutil::LessThanOrEqualExpr;
 using testutil::NotEqAnyExpr;
+using testutil::NotEqualExpr;
 using testutil::NotExpr;
 using testutil::OrExpr;
 using testutil::XorExpr;
@@ -101,8 +101,8 @@ TEST_F(NumberSemanticsPipelineTest, ZeroNegativeDoubleZero) {
   RealtimePipeline pipeline =
       StartPipeline("/users");  // Assuming /users based on keys
   // Firestore treats 0, -0, 0.0, -0.0 as equal.
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      EqExpr({std::make_shared<Field>("score"), SharedConstant(Value(-0.0))})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(EqualExpr(
+      {std::make_shared<Field>("score"), SharedConstant(Value(-0.0))})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents),
               UnorderedElementsAre(doc1, doc2, doc3, doc4));
@@ -117,8 +117,8 @@ TEST_F(NumberSemanticsPipelineTest, ZeroNegativeIntegerZero) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3, doc4, doc5};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      EqExpr({std::make_shared<Field>("score"), SharedConstant(Value(-0LL))})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(EqualExpr(
+      {std::make_shared<Field>("score"), SharedConstant(Value(-0LL))})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents),
               UnorderedElementsAre(doc1, doc2, doc3, doc4));
@@ -133,8 +133,8 @@ TEST_F(NumberSemanticsPipelineTest, ZeroPositiveDoubleZero) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3, doc4, doc5};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      EqExpr({std::make_shared<Field>("score"), SharedConstant(Value(0.0))})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(EqualExpr(
+      {std::make_shared<Field>("score"), SharedConstant(Value(0.0))})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents),
               UnorderedElementsAre(doc1, doc2, doc3, doc4));
@@ -149,8 +149,8 @@ TEST_F(NumberSemanticsPipelineTest, ZeroPositiveIntegerZero) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3, doc4, doc5};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      EqExpr({std::make_shared<Field>("score"), SharedConstant(Value(0LL))})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(EqualExpr(
+      {std::make_shared<Field>("score"), SharedConstant(Value(0LL))})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents),
               UnorderedElementsAre(doc1, doc2, doc3, doc4));
@@ -166,7 +166,7 @@ TEST_F(NumberSemanticsPipelineTest, EqualNan) {
 
   RealtimePipeline pipeline = StartPipeline("/users");
   // NaN is not equal to anything, including NaN.
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(EqExpr(
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(EqualExpr(
       {std::make_shared<Field>("age"),
        SharedConstant(Value(std::numeric_limits<double>::quiet_NaN()))})));
 
@@ -183,7 +183,7 @@ TEST_F(NumberSemanticsPipelineTest, LessThanNan) {
 
   RealtimePipeline pipeline = StartPipeline("/users");
   // Comparisons with NaN are always false.
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(LtExpr(
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(LessThanExpr(
       {std::make_shared<Field>("age"),
        SharedConstant(Value(std::numeric_limits<double>::quiet_NaN()))})));
 
@@ -200,7 +200,7 @@ TEST_F(NumberSemanticsPipelineTest, LessThanEqualNan) {
 
   RealtimePipeline pipeline = StartPipeline("/users");
   // Comparisons with NaN are always false.
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(LteExpr(
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(LessThanOrEqualExpr(
       {std::make_shared<Field>("age"),
        SharedConstant(Value(std::numeric_limits<double>::quiet_NaN()))})));
 
@@ -217,9 +217,10 @@ TEST_F(NumberSemanticsPipelineTest, GreaterThanEqualNan) {
 
   RealtimePipeline pipeline = StartPipeline("/users");
   // Comparisons with NaN are always false.
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(GteExpr(
-      {std::make_shared<Field>("age"),
-       SharedConstant(Value(std::numeric_limits<double>::quiet_NaN()))})));
+  pipeline =
+      pipeline.AddingStage(std::make_shared<Where>(GreaterThanOrEqualExpr(
+          {std::make_shared<Field>("age"),
+           SharedConstant(Value(std::numeric_limits<double>::quiet_NaN()))})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre());
 }
@@ -234,7 +235,7 @@ TEST_F(NumberSemanticsPipelineTest, GreaterThanNan) {
 
   RealtimePipeline pipeline = StartPipeline("/users");
   // Comparisons with NaN are always false.
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(GtExpr(
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(GreaterThanExpr(
       {std::make_shared<Field>("age"),
        SharedConstant(Value(std::numeric_limits<double>::quiet_NaN()))})));
 
@@ -251,7 +252,7 @@ TEST_F(NumberSemanticsPipelineTest, NotEqualNan) {
 
   RealtimePipeline pipeline = StartPipeline("/users");
   // != NaN is always true (as NaN != NaN).
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(NeqExpr(
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(NotEqualExpr(
       {std::make_shared<Field>("age"),
        SharedConstant(Value(std::numeric_limits<double>::quiet_NaN()))})));
 
@@ -388,10 +389,10 @@ TEST_F(NumberSemanticsPipelineTest, ArrayWithNan) {
 
   RealtimePipeline pipeline = StartPipeline("/k");
   // Equality filters never match NaN values, even within arrays.
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      EqExpr({std::make_shared<Field>("foo"),
-              SharedConstant(Value(
-                  Array(Value(std::numeric_limits<double>::quiet_NaN()))))})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(EqualExpr(
+      {std::make_shared<Field>("foo"),
+       SharedConstant(
+           Value(Array(Value(std::numeric_limits<double>::quiet_NaN()))))})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre());
 }
diff --git a/Firestore/core/test/unit/core/pipeline/sort_test.cc b/Firestore/core/test/unit/core/pipeline/sort_test.cc
index 3802324eb29..9de47dec73e 100644
--- a/Firestore/core/test/unit/core/pipeline/sort_test.cc
+++ b/Firestore/core/test/unit/core/pipeline/sort_test.cc
@@ -66,9 +66,9 @@ using testutil::Value;
 // Expression helpers
 using testutil::AddExpr;
 using testutil::AndExpr;
-using testutil::EqExpr;
+using testutil::EqualExpr;
 using testutil::ExistsExpr;
-using testutil::GtExpr;
+using testutil::GreaterThanExpr;
 using testutil::NotExpr;
 using testutil::RegexMatchExpr;
 
@@ -147,8 +147,8 @@ TEST_F(SortPipelineTest, SingleResultAscendingImplicitExists) {
   auto doc1 = Doc("users/a", 1000, Map("name", "alice", "age", 10LL));
   PipelineInputOutputVector documents = {doc1};
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      EqExpr({std::make_shared<Field>("age"), SharedConstant(Value(10LL))})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(EqualExpr(
+      {std::make_shared<Field>("age"), SharedConstant(Value(10LL))})));
   pipeline = pipeline.AddingStage(
       std::make_shared<SortStage>(std::vector<Ordering>{Ordering(
           std::make_unique<Field>("age"), Ordering::Direction::ASCENDING)}));
@@ -181,8 +181,8 @@ TEST_F(SortPipelineTest, SingleResultDescendingImplicitExists) {
   auto doc1 = Doc("users/a", 1000, Map("name", "alice", "age", 10LL));
   PipelineInputOutputVector documents = {doc1};
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      EqExpr({std::make_shared<Field>("age"), SharedConstant(Value(10LL))})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(EqualExpr(
+      {std::make_shared<Field>("age"), SharedConstant(Value(10LL))})));
   pipeline = pipeline.AddingStage(
       std::make_shared<SortStage>(std::vector<Ordering>{Ordering(
           std::make_unique<Field>("age"), Ordering::Direction::DESCENDING)}));
@@ -230,8 +230,8 @@ TEST_F(SortPipelineTest, MultipleResultsAmbiguousOrderImplicitExists) {
   auto doc5 = Doc("users/e", 1000, Map("name", "eric", "age", 10.0));
   PipelineInputOutputVector documents = {doc1, doc2, doc3, doc4, doc5};
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      GtExpr({std::make_shared<Field>("age"), SharedConstant(Value(0.0))})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(GreaterThanExpr(
+      {std::make_shared<Field>("age"), SharedConstant(Value(0.0))})));
   pipeline = pipeline.AddingStage(
       std::make_shared<SortStage>(std::vector<Ordering>{Ordering(
           std::make_unique<Field>("age"), Ordering::Direction::DESCENDING)}));
@@ -308,8 +308,8 @@ TEST_F(SortPipelineTest, MultipleResultsFullOrderImplicitExists) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3, doc4, doc5};
   RealtimePipeline pipeline = StartPipeline("/users");
   pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      EqExpr({std::make_shared<Field>("age"),
-              std::make_shared<Field>("age")})));  // Implicit exists age
+      EqualExpr({std::make_shared<Field>("age"),
+                 std::make_shared<Field>("age")})));  // Implicit exists age
   pipeline = pipeline.AddingStage(std::make_shared<Where>(
       RegexMatchExpr(std::make_shared<Field>("name"),
                      SharedConstant(Value(".*")))));  // Implicit exists name
diff --git a/Firestore/core/test/unit/core/pipeline/unicode_test.cc b/Firestore/core/test/unit/core/pipeline/unicode_test.cc
index 4828a2a23cc..41b76568a69 100644
--- a/Firestore/core/test/unit/core/pipeline/unicode_test.cc
+++ b/Firestore/core/test/unit/core/pipeline/unicode_test.cc
@@ -66,11 +66,11 @@ using testutil::Value;
 // Expression helpers
 using testutil::AndExpr;
 using testutil::Constant;  // Renamed from ConstantExpr
-using testutil::EqExpr;
-using testutil::GteExpr;
-using testutil::GtExpr;
-using testutil::LteExpr;
-using testutil::LtExpr;
+using testutil::EqualExpr;
+using testutil::GreaterThanExpr;
+using testutil::GreaterThanOrEqualExpr;
+using testutil::LessThanExpr;
+using testutil::LessThanOrEqualExpr;
 
 // Test Fixture for Unicode Pipeline tests
 class UnicodePipelineTest : public ::testing::Test {
@@ -111,10 +111,11 @@ TEST_F(UnicodePipelineTest, UnicodeSurrogates) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3};
   RealtimePipeline pipeline = StartDatabasePipeline();
   pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr(
-      {LteExpr({std::make_shared<Field>("str"),
-                SharedConstant("🄟")}),  // Renamed from ConstantExpr
-       GteExpr({std::make_shared<Field>("str"),
-                SharedConstant("Ｐ")})})));  // Renamed from ConstantExpr
+      {LessThanOrEqualExpr({std::make_shared<Field>("str"),
+                            SharedConstant("🄟")}),  // Renamed from ConstantExpr
+       GreaterThanOrEqualExpr(
+           {std::make_shared<Field>("str"),
+            SharedConstant("Ｐ")})})));  // Renamed from ConstantExpr
   pipeline = pipeline.AddingStage(
       std::make_shared<SortStage>(std::vector<Ordering>{Ordering(
           std::make_unique<Field>("str"), Ordering::Direction::ASCENDING)}));
diff --git a/Firestore/core/test/unit/core/pipeline/where_test.cc b/Firestore/core/test/unit/core/pipeline/where_test.cc
index f6753d29475..a50cf1ecacd 100644
--- a/Firestore/core/test/unit/core/pipeline/where_test.cc
+++ b/Firestore/core/test/unit/core/pipeline/where_test.cc
@@ -70,16 +70,16 @@ using testutil::ArrayContainsAnyExpr;
 using testutil::ArrayContainsExpr;
 using testutil::DivideExpr;
 using testutil::EqAnyExpr;
-using testutil::EqExpr;
+using testutil::EqualExpr;
 using testutil::ExistsExpr;
-using testutil::GteExpr;
-using testutil::GtExpr;
+using testutil::GreaterThanExpr;
+using testutil::GreaterThanOrEqualExpr;
 using testutil::IsNanExpr;
 using testutil::IsNullExpr;
-using testutil::LteExpr;
-using testutil::LtExpr;
+using testutil::LessThanExpr;
+using testutil::LessThanOrEqualExpr;
 // using testutil::NeqAnyExpr; // Not used
-using testutil::NeqExpr;
+using testutil::NotEqualExpr;
 using testutil::NotExpr;
 using testutil::OrExpr;
 using testutil::RegexMatchExpr;  // For 'like'
@@ -105,8 +105,9 @@ class WherePipelineTest : public ::testing::Test {
 TEST_F(WherePipelineTest, EmptyDatabaseReturnsNoResults) {
   PipelineInputOutputVector documents = {};
   RealtimePipeline pipeline = StartDatabasePipeline();
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      GteExpr({std::make_shared<Field>("age"), SharedConstant(Value(10LL))})));
+  pipeline =
+      pipeline.AddingStage(std::make_shared<Where>(GreaterThanOrEqualExpr(
+          {std::make_shared<Field>("age"), SharedConstant(Value(10LL))})));
   EXPECT_THAT(RunPipeline(pipeline, documents), IsEmpty());
 }
 
@@ -120,10 +121,11 @@ TEST_F(WherePipelineTest, DuplicateConditions) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3, doc4, doc5};
 
   RealtimePipeline pipeline = StartDatabasePipeline();
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(AndExpr(
-      {GteExpr({std::make_shared<Field>("age"), SharedConstant(Value(10.0))}),
-       GteExpr(
-           {std::make_shared<Field>("age"), SharedConstant(Value(20.0))})})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(
+      AndExpr({GreaterThanOrEqualExpr({std::make_shared<Field>("age"),
+                                       SharedConstant(Value(10.0))}),
+               GreaterThanOrEqualExpr({std::make_shared<Field>("age"),
+                                       SharedConstant(Value(20.0))})})));
 
   // Note: TS test expected [doc1, doc2, doc3]. Let's re-evaluate based on C++
   // types. age >= 10.0 AND age >= 20.0 => age >= 20.0 Matches: doc1 (75.5),
@@ -138,12 +140,12 @@ TEST_F(WherePipelineTest, LogicalEquivalentConditionEqual) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3};
 
   RealtimePipeline pipeline1 = StartDatabasePipeline();
-  pipeline1 = pipeline1.AddingStage(std::make_shared<Where>(
-      EqExpr({std::make_shared<Field>("age"), SharedConstant(Value(25.0))})));
+  pipeline1 = pipeline1.AddingStage(std::make_shared<Where>(EqualExpr(
+      {std::make_shared<Field>("age"), SharedConstant(Value(25.0))})));
 
   RealtimePipeline pipeline2 = StartDatabasePipeline();
-  pipeline2 = pipeline2.AddingStage(std::make_shared<Where>(
-      EqExpr({SharedConstant(Value(25.0)), std::make_shared<Field>("age")})));
+  pipeline2 = pipeline2.AddingStage(std::make_shared<Where>(EqualExpr(
+      {SharedConstant(Value(25.0)), std::make_shared<Field>("age")})));
 
   auto result1 = RunPipeline(pipeline1, documents);
   auto result2 = RunPipeline(pipeline2, documents);
@@ -159,16 +161,18 @@ TEST_F(WherePipelineTest, LogicalEquivalentConditionAnd) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3};
 
   RealtimePipeline pipeline1 = StartDatabasePipeline();
-  pipeline1 = pipeline1.AddingStage(std::make_shared<Where>(AndExpr(
-      {GtExpr({std::make_shared<Field>("age"), SharedConstant(Value(10.0))}),
-       LtExpr(
-           {std::make_shared<Field>("age"), SharedConstant(Value(70.0))})})));
+  pipeline1 = pipeline1.AddingStage(std::make_shared<Where>(
+      AndExpr({GreaterThanExpr({std::make_shared<Field>("age"),
+                                SharedConstant(Value(10.0))}),
+               LessThanExpr({std::make_shared<Field>("age"),
+                             SharedConstant(Value(70.0))})})));
 
   RealtimePipeline pipeline2 = StartDatabasePipeline();
-  pipeline2 = pipeline2.AddingStage(std::make_shared<Where>(AndExpr(
-      {LtExpr({std::make_shared<Field>("age"), SharedConstant(Value(70.0))}),
-       GtExpr(
-           {std::make_shared<Field>("age"), SharedConstant(Value(10.0))})})));
+  pipeline2 = pipeline2.AddingStage(std::make_shared<Where>(
+      AndExpr({LessThanExpr({std::make_shared<Field>("age"),
+                             SharedConstant(Value(70.0))}),
+               GreaterThanExpr({std::make_shared<Field>("age"),
+                                SharedConstant(Value(10.0))})})));
 
   auto result1 = RunPipeline(pipeline1, documents);
   auto result2 = RunPipeline(pipeline2, documents);
@@ -185,16 +189,18 @@ TEST_F(WherePipelineTest, LogicalEquivalentConditionOr) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3};
 
   RealtimePipeline pipeline1 = StartDatabasePipeline();
-  pipeline1 = pipeline1.AddingStage(std::make_shared<Where>(OrExpr(
-      {LtExpr({std::make_shared<Field>("age"), SharedConstant(Value(10.0))}),
-       GtExpr(
-           {std::make_shared<Field>("age"), SharedConstant(Value(80.0))})})));
+  pipeline1 = pipeline1.AddingStage(std::make_shared<Where>(
+      OrExpr({LessThanExpr({std::make_shared<Field>("age"),
+                            SharedConstant(Value(10.0))}),
+              GreaterThanExpr({std::make_shared<Field>("age"),
+                               SharedConstant(Value(80.0))})})));
 
   RealtimePipeline pipeline2 = StartDatabasePipeline();
-  pipeline2 = pipeline2.AddingStage(std::make_shared<Where>(OrExpr(
-      {GtExpr({std::make_shared<Field>("age"), SharedConstant(Value(80.0))}),
-       LtExpr(
-           {std::make_shared<Field>("age"), SharedConstant(Value(10.0))})})));
+  pipeline2 = pipeline2.AddingStage(std::make_shared<Where>(
+      OrExpr({GreaterThanExpr({std::make_shared<Field>("age"),
+                               SharedConstant(Value(80.0))}),
+              LessThanExpr({std::make_shared<Field>("age"),
+                            SharedConstant(Value(10.0))})})));
 
   auto result1 = RunPipeline(pipeline1, documents);
   auto result2 = RunPipeline(pipeline2, documents);
@@ -239,10 +245,12 @@ TEST_F(WherePipelineTest, RepeatedStages) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3, doc4, doc5};
 
   RealtimePipeline pipeline = StartDatabasePipeline();
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      GteExpr({std::make_shared<Field>("age"), SharedConstant(Value(10.0))})));
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      GteExpr({std::make_shared<Field>("age"), SharedConstant(Value(20.0))})));
+  pipeline =
+      pipeline.AddingStage(std::make_shared<Where>(GreaterThanOrEqualExpr(
+          {std::make_shared<Field>("age"), SharedConstant(Value(10.0))})));
+  pipeline =
+      pipeline.AddingStage(std::make_shared<Where>(GreaterThanOrEqualExpr(
+          {std::make_shared<Field>("age"), SharedConstant(Value(20.0))})));
 
   // age >= 10.0 THEN age >= 20.0 => age >= 20.0
   // Matches: doc1 (75.5), doc2 (25.0), doc3 (100.0)
@@ -260,9 +268,9 @@ TEST_F(WherePipelineTest, CompositeEqualities) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3, doc4, doc5};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      EqExpr({std::make_shared<Field>("age"), SharedConstant(Value(75LL))})));
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(EqExpr(
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(EqualExpr(
+      {std::make_shared<Field>("age"), SharedConstant(Value(75LL))})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(EqualExpr(
       {std::make_shared<Field>("height"), SharedConstant(Value(55LL))})));
 
   EXPECT_THAT(RunPipeline(pipeline, documents), ElementsAre(doc3));
@@ -277,9 +285,9 @@ TEST_F(WherePipelineTest, CompositeInequalities) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3, doc4, doc5};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      GtExpr({std::make_shared<Field>("age"), SharedConstant(Value(50LL))})));
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(LtExpr(
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(GreaterThanExpr(
+      {std::make_shared<Field>("age"), SharedConstant(Value(50LL))})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(LessThanExpr(
       {std::make_shared<Field>("height"), SharedConstant(Value(75LL))})));
 
   // age > 50 AND height < 75
@@ -337,9 +345,9 @@ TEST_F(WherePipelineTest, CompositeMixed) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3, doc4, doc5};
 
   RealtimePipeline pipeline = StartPipeline("/users");
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(
-      EqExpr({std::make_shared<Field>("age"), SharedConstant(Value(75LL))})));
-  pipeline = pipeline.AddingStage(std::make_shared<Where>(GtExpr(
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(EqualExpr(
+      {std::make_shared<Field>("age"), SharedConstant(Value(75LL))})));
+  pipeline = pipeline.AddingStage(std::make_shared<Where>(GreaterThanExpr(
       {std::make_shared<Field>("height"), SharedConstant(Value(45LL))})));
   pipeline = pipeline.AddingStage(std::make_shared<Where>(
       RegexMatchExpr(std::make_shared<Field>("last"),
@@ -610,9 +618,9 @@ TEST_F(WherePipelineTest, AndExpressionLogicallyEquivalentToSeparatedStages) {
   PipelineInputOutputVector documents = {doc1, doc2, doc3};
 
   auto equalityArgument1 =
-      EqExpr({std::make_shared<Field>("a"), SharedConstant(Value(1LL))});
+      EqualExpr({std::make_shared<Field>("a"), SharedConstant(Value(1LL))});
   auto equalityArgument2 =
-      EqExpr({std::make_shared<Field>("b"), SharedConstant(Value(2LL))});
+      EqualExpr({std::make_shared<Field>("b"), SharedConstant(Value(2LL))});
 
   // Combined AND
   RealtimePipeline pipeline_and_1 = StartDatabasePipeline();
diff --git a/Firestore/core/test/unit/core/pipeline_util_test.cc b/Firestore/core/test/unit/core/pipeline_util_test.cc
index c944a842337..b6a9aa1abee 100644
--- a/Firestore/core/test/unit/core/pipeline_util_test.cc
+++ b/Firestore/core/test/unit/core/pipeline_util_test.cc
@@ -63,18 +63,18 @@ api::RealtimePipeline StartPipeline(
 api::RealtimePipeline TestPipeline(int id) {
   auto pipeline = StartPipeline("coll");
   if (id == 1) {
-    pipeline = pipeline.AddingStage(
-        std::make_shared<api::Where>(testutil::NotExpr(testutil::GtExpr(
+    pipeline = pipeline.AddingStage(std::make_shared<api::Where>(
+        testutil::NotExpr(testutil::GreaterThanExpr(
             {std::make_shared<Field>("score"),
              testutil::SharedConstant(testutil::Value(90LL))}))));
   } else if (id == 2) {
     pipeline = pipeline.AddingStage(
-        std::make_shared<api::Where>(testutil::NotExpr(testutil::LtExpr(
+        std::make_shared<api::Where>(testutil::NotExpr(testutil::LessThanExpr(
             {std::make_shared<Field>("score"),
              testutil::SharedConstant(testutil::Value(90LL))}))));
   } else if (id == 3) {  // Same as id 1
-    pipeline = pipeline.AddingStage(
-        std::make_shared<api::Where>(testutil::NotExpr(testutil::GtExpr(
+    pipeline = pipeline.AddingStage(std::make_shared<api::Where>(
+        testutil::NotExpr(testutil::GreaterThanExpr(
             {std::make_shared<Field>("score"),
              testutil::SharedConstant(testutil::Value(90LL))}))));
   }
diff --git a/Firestore/core/test/unit/local/local_serializer_test.cc b/Firestore/core/test/unit/local/local_serializer_test.cc
index 577830efe42..83668fdb4e6 100644
--- a/Firestore/core/test/unit/local/local_serializer_test.cc
+++ b/Firestore/core/test/unit/local/local_serializer_test.cc
@@ -734,8 +734,8 @@ TEST_F(LocalSerializerTest, EncodesTargetDataWithPipeline) {
   // Construct the pipeline
   auto ppl = StartPipeline("rooms");
   ppl = ppl.AddingStage(std::make_shared<api::Where>(
-      testutil::EqExpr({std::make_shared<api::Field>("name"),
-                        testutil::SharedConstant("testroom")})));
+      testutil::EqualExpr({std::make_shared<api::Field>("name"),
+                           testutil::SharedConstant("testroom")})));
   api::Ordering ordering(std::make_unique<api::Field>("age"),
                          api::Ordering::DESCENDING);
   ppl = ppl.AddingStage(
@@ -772,14 +772,14 @@ TEST_F(LocalSerializerTest, EncodesTargetDataWithPipeline) {
     stage1_arg1->set_reference_value("/rooms");
   }
 
-  // Stage 2: Where(EqExpr(Field("name"), Value("testroom")))
+  // Stage 2: Where(EqualExpr(Field("name"), Value("testroom")))
   {
     google::firestore::v1::Pipeline_Stage* stage2_proto =
         pipeline_proto_obj->add_stages();  // Changed type
     stage2_proto->set_name("where");
-    v1::Value* stage2_arg1_expr = stage2_proto->add_args();  // The EqExpr
+    v1::Value* stage2_arg1_expr = stage2_proto->add_args();  // The EqualExpr
     v1::Function* eq_func = stage2_arg1_expr->mutable_function_value();
-    eq_func->set_name("eq");
+    eq_func->set_name("equal");
 
     v1::Value* eq_arg1_field = eq_func->add_args();  // Field("name")
     eq_arg1_field->set_field_reference_value("name");
diff --git a/Firestore/core/test/unit/local/query_engine_test.cc b/Firestore/core/test/unit/local/query_engine_test.cc
index 168a4f9f0aa..ff7b53bf9a1 100644
--- a/Firestore/core/test/unit/local/query_engine_test.cc
+++ b/Firestore/core/test/unit/local/query_engine_test.cc
@@ -1082,10 +1082,11 @@ TEST_P(QueryEngineTest, HandlesServerTimestampEstimate) {
 
     auto pipeline = api::RealtimePipeline(
         {std::make_shared<api::CollectionSource>("coll")}, TestSerializer());
-    pipeline = pipeline.AddingStage(std::make_shared<api::Where>(
-        testutil::GtExpr({testutil::TimestampToUnixMillisExpr(
-                              {std::make_shared<api::Field>("timestamp")}),
-                          testutil::SharedConstant(testutil::Value(1000))})));
+    pipeline = pipeline.AddingStage(
+        std::make_shared<api::Where>(testutil::GreaterThanExpr(
+            {testutil::TimestampToUnixMillisExpr(
+                 {std::make_shared<api::Field>("timestamp")}),
+             testutil::SharedConstant(testutil::Value(1000))})));
 
     DocumentSet result1 = ExpectFullCollectionScan<DocumentSet>(
         [&] { return RunPipeline(pipeline, kMissingLastLimboFreeSnapshot); });
@@ -1118,9 +1119,10 @@ TEST_P(QueryEngineTest, HandlesServerTimestampPrevious) {
 
     auto pipeline = api::RealtimePipeline(
         {std::make_shared<api::CollectionSource>("coll")}, TestSerializer());
-    pipeline = pipeline.AddingStage(std::make_shared<api::Where>(
-        testutil::EqExpr({std::make_shared<api::Field>("matches"),
-                          testutil::SharedConstant(testutil::Value(true))})));
+    pipeline =
+        pipeline.AddingStage(std::make_shared<api::Where>(testutil::EqualExpr(
+            {std::make_shared<api::Field>("matches"),
+             testutil::SharedConstant(testutil::Value(true))})));
 
     DocumentSet result1 = ExpectFullCollectionScan<DocumentSet>(
         [&] { return RunPipeline(pipeline, kMissingLastLimboFreeSnapshot); });
diff --git a/Firestore/core/test/unit/testutil/expression_test_util.cc b/Firestore/core/test/unit/testutil/expression_test_util.cc
index 0c90fa449ad..a2b19e2e354 100644
--- a/Firestore/core/test/unit/testutil/expression_test_util.cc
+++ b/Firestore/core/test/unit/testutil/expression_test_util.cc
@@ -44,7 +44,7 @@ const std::vector<std::shared_ptr<Expr>>
         SharedConstant(-std::numeric_limits<double>::max()),
         SharedConstant(std::numeric_limits<int64_t>::min()),
         SharedConstant(-kMaxLongExactlyRepresentableAsDouble),
-        SharedConstant(-1LL),
+        SharedConstant(static_cast<int64_t>(-1LL)),
         SharedConstant(-0.5),
         SharedConstant(-std::numeric_limits<double>::min()),  // -MIN_NORMAL
         SharedConstant(
@@ -57,8 +57,8 @@ const std::vector<std::shared_ptr<Expr>>
                                                              // (denormalized)
         SharedConstant(std::numeric_limits<double>::min()),  // MIN_NORMAL
         SharedConstant(0.5),
-        SharedConstant(1LL),
-        SharedConstant(42LL),
+        SharedConstant(static_cast<int64_t>(1LL)),
+        SharedConstant(static_cast<int64_t>(42LL)),
         SharedConstant(kMaxLongExactlyRepresentableAsDouble),
         SharedConstant(std::numeric_limits<int64_t>::max()),
         SharedConstant(std::numeric_limits<double>::max()),
@@ -81,7 +81,7 @@ const std::vector<std::shared_ptr<Expr>>
         // C++
         SharedConstant("santé"), SharedConstant("santé et bonheur")};
 
-const auto ComparisonValueTestData::BYTE_VALUES =
+const std::vector<std::shared_ptr<Expr>> ComparisonValueTestData::BYTE_VALUES =
     std::vector<std::shared_ptr<Expr>>{
         SharedConstant(*BlobValue()),  // Empty - use default constructor
         SharedConstant(*BlobValue(0, 2, 56, 42)),  // Use variadic args
@@ -109,8 +109,9 @@ const std::vector<std::shared_ptr<Expr>> ComparisonValueTestData::GEO_VALUES = {
 
 const std::vector<std::shared_ptr<Expr>> ComparisonValueTestData::ARRAY_VALUES =
     {SharedConstant(Array()),
-     SharedConstant(Array(true, 15LL)),
-     SharedConstant(Array(1LL, 2LL)),
+     SharedConstant(Array(true, static_cast<int64_t>(15LL))),
+     SharedConstant(
+         Array(static_cast<int64_t>(1LL), static_cast<int64_t>(2LL))),
      SharedConstant(Array(Value(Timestamp(12, 0)))),
      SharedConstant(Array("foo")),
      SharedConstant(Array("foo", "bar")),
diff --git a/Firestore/core/test/unit/testutil/expression_test_util.h b/Firestore/core/test/unit/testutil/expression_test_util.h
index fab0296b44a..616fbd64df8 100644
--- a/Firestore/core/test/unit/testutil/expression_test_util.h
+++ b/Firestore/core/test/unit/testutil/expression_test_util.h
@@ -211,46 +211,49 @@ inline std::shared_ptr<Expr> TimestampAddExpr(std::shared_ptr<Expr> timestamp,
 
 // --- Comparison Expression Helpers ---
 
-inline std::shared_ptr<Expr> EqExpr(
+inline std::shared_ptr<Expr> EqualExpr(
     std::initializer_list<std::shared_ptr<Expr>> params) {
-  HARD_ASSERT(params.size() == 2, "EqExpr requires exactly 2 parameters");
+  HARD_ASSERT(params.size() == 2, "EqualExpr requires exactly 2 parameters");
   return std::make_shared<FunctionExpr>(
-      "eq", std::vector<std::shared_ptr<Expr>>(params));
+      "equal", std::vector<std::shared_ptr<Expr>>(params));
 }
 
-inline std::shared_ptr<Expr> NeqExpr(
+inline std::shared_ptr<Expr> NotEqualExpr(
     std::initializer_list<std::shared_ptr<Expr>> params) {
-  HARD_ASSERT(params.size() == 2, "NeqExpr requires exactly 2 parameters");
+  HARD_ASSERT(params.size() == 2, "NotEqualExpr requires exactly 2 parameters");
   return std::make_shared<FunctionExpr>(
-      "neq", std::vector<std::shared_ptr<Expr>>(params));
+      "not_equal", std::vector<std::shared_ptr<Expr>>(params));
 }
 
-inline std::shared_ptr<Expr> LtExpr(
+inline std::shared_ptr<Expr> LessThanExpr(
     std::initializer_list<std::shared_ptr<Expr>> params) {
-  HARD_ASSERT(params.size() == 2, "LtExpr requires exactly 2 parameters");
+  HARD_ASSERT(params.size() == 2, "LessThanExpr requires exactly 2 parameters");
   return std::make_shared<FunctionExpr>(
-      "lt", std::vector<std::shared_ptr<Expr>>(params));
+      "less_than", std::vector<std::shared_ptr<Expr>>(params));
 }
 
-inline std::shared_ptr<Expr> LteExpr(
+inline std::shared_ptr<Expr> LessThanOrEqualExpr(
     std::initializer_list<std::shared_ptr<Expr>> params) {
-  HARD_ASSERT(params.size() == 2, "LteExpr requires exactly 2 parameters");
+  HARD_ASSERT(params.size() == 2,
+              "LessThanOrEqualExpr requires exactly 2 parameters");
   return std::make_shared<FunctionExpr>(
-      "lte", std::vector<std::shared_ptr<Expr>>(params));
+      "less_than_or_equal", std::vector<std::shared_ptr<Expr>>(params));
 }
 
-inline std::shared_ptr<Expr> GtExpr(
+inline std::shared_ptr<Expr> GreaterThanExpr(
     std::initializer_list<std::shared_ptr<Expr>> params) {
-  HARD_ASSERT(params.size() == 2, "GtExpr requires exactly 2 parameters");
+  HARD_ASSERT(params.size() == 2,
+              "GreaterThanExpr requires exactly 2 parameters");
   return std::make_shared<FunctionExpr>(
-      "gt", std::vector<std::shared_ptr<Expr>>(params));
+      "greater_than", std::vector<std::shared_ptr<Expr>>(params));
 }
 
-inline std::shared_ptr<Expr> GteExpr(
+inline std::shared_ptr<Expr> GreaterThanOrEqualExpr(
     std::initializer_list<std::shared_ptr<Expr>> params) {
-  HARD_ASSERT(params.size() == 2, "GteExpr requires exactly 2 parameters");
+  HARD_ASSERT(params.size() == 2,
+              "GreaterThanOrEqualExpr requires exactly 2 parameters");
   return std::make_shared<FunctionExpr>(
-      "gte", std::vector<std::shared_ptr<Expr>>(params));
+      "greater_than_or_equal", std::vector<std::shared_ptr<Expr>>(params));
 }
 
 // --- Array Expression Helpers ---
@@ -314,7 +317,7 @@ inline std::shared_ptr<Expr> EqAnyExpr(std::shared_ptr<Expr> search,
   std::vector<std::shared_ptr<Expr>> operands;
   operands.push_back(std::move(search));
   operands.push_back(std::move(values));
-  return std::make_shared<FunctionExpr>("eq_any", std::move(operands));
+  return std::make_shared<FunctionExpr>("equal_any", std::move(operands));
 }
 
 inline std::shared_ptr<Expr> NotEqAnyExpr(std::shared_ptr<Expr> search,
@@ -322,7 +325,7 @@ inline std::shared_ptr<Expr> NotEqAnyExpr(std::shared_ptr<Expr> search,
   std::vector<std::shared_ptr<Expr>> operands;
   operands.push_back(std::move(search));
   operands.push_back(std::move(values));
-  return std::make_shared<FunctionExpr>("not_eq_any", std::move(operands));
+  return std::make_shared<FunctionExpr>("not_equal_any", std::move(operands));
 }
 
 inline std::shared_ptr<Expr> IsNanExpr(std::shared_ptr<Expr> operand) {
@@ -350,14 +353,14 @@ inline std::shared_ptr<Expr> IsErrorExpr(std::shared_ptr<Expr> operand) {
       "is_error", std::vector<std::shared_ptr<Expr>>{std::move(operand)});
 }
 
-inline std::shared_ptr<Expr> LogicalMaxExpr(
+inline std::shared_ptr<Expr> MaximumExpr(
     std::vector<std::shared_ptr<Expr>> operands) {
-  return std::make_shared<FunctionExpr>("logical_maximum", std::move(operands));
+  return std::make_shared<FunctionExpr>("maximum", std::move(operands));
 }
 
-inline std::shared_ptr<Expr> LogicalMinExpr(
+inline std::shared_ptr<Expr> MinimumExpr(
     std::vector<std::shared_ptr<Expr>> operands) {
-  return std::make_shared<FunctionExpr>("logical_minimum", std::move(operands));
+  return std::make_shared<FunctionExpr>("minimum", std::move(operands));
 }
 
 // --- Debugging Expression Helpers ---
@@ -445,19 +448,27 @@ struct ComparisonValueTestData {
       results.push_back({value, value});
     }
 
-    results.push_back({SharedConstant(-42LL), SharedConstant(-42.0)});
-    results.push_back({SharedConstant(-42.0), SharedConstant(-42LL)});
-    results.push_back({SharedConstant(42LL), SharedConstant(42.0)});
-    results.push_back({SharedConstant(42.0), SharedConstant(42LL)});
+    results.push_back(
+        {SharedConstant(static_cast<int64_t>(-42LL)), SharedConstant(-42.0)});
+    results.push_back(
+        {SharedConstant(-42.0), SharedConstant(static_cast<int64_t>(-42LL))});
+    results.push_back(
+        {SharedConstant(static_cast<int64_t>(42LL)), SharedConstant(42.0)});
+    results.push_back(
+        {SharedConstant(42.0), SharedConstant(static_cast<int64_t>(42LL))});
 
     results.push_back({SharedConstant(0.0), SharedConstant(-0.0)});
     results.push_back({SharedConstant(-0.0), SharedConstant(0.0)});
 
-    results.push_back({SharedConstant(0LL), SharedConstant(-0.0)});
-    results.push_back({SharedConstant(-0.0), SharedConstant(0LL)});
+    results.push_back(
+        {SharedConstant(static_cast<int64_t>(0LL)), SharedConstant(-0.0)});
+    results.push_back(
+        {SharedConstant(-0.0), SharedConstant(static_cast<int64_t>(0LL))});
 
-    results.push_back({SharedConstant(0LL), SharedConstant(0.0)});
-    results.push_back({SharedConstant(0.0), SharedConstant(0LL)});
+    results.push_back(
+        {SharedConstant(static_cast<int64_t>(0LL)), SharedConstant(0.0)});
+    results.push_back(
+        {SharedConstant(0.0), SharedConstant(static_cast<int64_t>(0LL))});
 
     return results;
   }
@@ -661,9 +672,9 @@ inline std::shared_ptr<Expr> ToUpperExpr(std::shared_ptr<Expr> operand) {
       "to_upper", std::vector<std::shared_ptr<Expr>>{std::move(operand)});
 }
 
-inline std::shared_ptr<Expr> ReverseExpr(std::shared_ptr<Expr> operand) {
+inline std::shared_ptr<Expr> StringReverseExpr(std::shared_ptr<Expr> operand) {
   return std::make_shared<FunctionExpr>(
-      "reverse", std::vector<std::shared_ptr<Expr>>{std::move(operand)});
+      "string_reverse", std::vector<std::shared_ptr<Expr>>{std::move(operand)});
 }
 
 inline std::shared_ptr<Expr> TrimExpr(std::shared_ptr<Expr> operand) {
@@ -692,10 +703,10 @@ inline std::shared_ptr<Expr> RegexMatchExpr(std::shared_ptr<Expr> value,
       std::vector<std::shared_ptr<Expr>>{std::move(value), std::move(regex)});
 }
 
-inline std::shared_ptr<Expr> StrContainsExpr(std::shared_ptr<Expr> value,
-                                             std::shared_ptr<Expr> search) {
+inline std::shared_ptr<Expr> StringContainsExpr(std::shared_ptr<Expr> value,
+                                                std::shared_ptr<Expr> search) {
   return std::make_shared<FunctionExpr>(
-      "str_contains",
+      "string_contains",
       std::vector<std::shared_ptr<Expr>>{std::move(value), std::move(search)});
 }
 
@@ -713,9 +724,9 @@ inline std::shared_ptr<Expr> EndsWithExpr(std::shared_ptr<Expr> value,
       std::vector<std::shared_ptr<Expr>>{std::move(value), std::move(suffix)});
 }
 
-inline std::shared_ptr<Expr> StrConcatExpr(
+inline std::shared_ptr<Expr> StringConcatExpr(
     std::vector<std::shared_ptr<Expr>> operands) {
-  return std::make_shared<FunctionExpr>("str_concat", std::move(operands));
+  return std::make_shared<FunctionExpr>("string_concat", std::move(operands));
 }
 
 // --- Vector Expression Helpers ---
diff --git a/scripts/run_firestore_emulator.sh b/scripts/run_firestore_emulator.sh
index 7401009c44d..cb3e53c0648 100755
--- a/scripts/run_firestore_emulator.sh
+++ b/scripts/run_firestore_emulator.sh
@@ -25,7 +25,7 @@ if [[ ! -z "${JAVA_HOME_11_X64:-}" ]]; then
   export JAVA_HOME=$JAVA_HOME_11_X64
 fi
 
-VERSION='1.19.7'
+VERSION='1.20.2'
 FILENAME="cloud-firestore-emulator-v${VERSION}.jar"
 URL="https://storage.googleapis.com/firebase-preview-drop/emulator/${FILENAME}"
 
@@ -53,7 +53,7 @@ function ensure_exists() {
 
 # Runs the emulator synchronously
 function run() {
-  exec java -jar "$jar" "$@"
+  EXPERIMENTAL_MODE=true exec java -jar "$jar" "$@"
 }
 
 # Verifies the emulator isn't already running at the PID in the pid_file