Update: minor enhancement

Author: mapleFU

src/iceberg/expression/expression.cc

@@ -227,17 +227,43 @@ bool OrImpl::Equals(const Expression& expr) const {
 }
 
 // Implementation of Predicate static factory methods
-std::shared_ptr<Predicate> Predicate::AlwaysTrue() { return True::Instance(); }
+const std::shared_ptr<Predicate>& Predicate::AlwaysTrue() {
+  static const std::shared_ptr<Predicate> instance = True::Instance();
+  return instance;
+}
 
-std::shared_ptr<Predicate> Predicate::AlwaysFalse() { return False::Instance(); }
+const std::shared_ptr<Predicate>& Predicate::AlwaysFalse() {
+  static const std::shared_ptr<Predicate> instance = False::Instance();
+  return instance;
+}
 
 std::shared_ptr<Predicate> Predicate::And(std::shared_ptr<Predicate> left,
                                           std::shared_ptr<Predicate> right) {
+  /*
+  auto left_op = left->op();
+  auto right_op = right->op();
+  if (left_op == Operation::kFalse || right_op == Operation::kFalse) {
+    return False::Instance();
+  }
+  if (left_op == Operation::kTrue && right_op == Operation::kTrue) {
+    return left;
+  }
+  */
   return std::make_shared<AndImpl>(std::move(left), std::move(right));
 }
 
 std::shared_ptr<Predicate> Predicate::Or(std::shared_ptr<Predicate> left,
                                          std::shared_ptr<Predicate> right) {
+  /*
+  auto left_op = left->op();
+  auto right_op = right->op();
+  if (left_op == Operation::kTrue || right_op == Operation::kTrue) {
+    return False::Instance();
+  }
+  if (left_op == Operation::kFalse && right_op == Operation::kFalse) {
+    return left;
+  }
+  */
   return std::make_shared<OrImpl>(std::move(left), std::move(right));
 }
 

src/iceberg/expression/expression.h

@@ -127,11 +127,11 @@ class ICEBERG_EXPORT Predicate : public Expression {
 
   /// \brief Creates a True predicate that always evaluates to true.
   /// \return A shared pointer to a True predicate
-  static std::shared_ptr<Predicate> AlwaysTrue();
+  static const std::shared_ptr<Predicate>& AlwaysTrue();
 
   /// \brief Creates a False predicate that always evaluates to false.
   /// \return A shared pointer to a False predicate
-  static std::shared_ptr<Predicate> AlwaysFalse();
+  static const std::shared_ptr<Predicate>& AlwaysFalse();
 
   /// \brief Creates an And predicate that represents logical AND of two predicates.
   /// \param left The left operand of the AND predicate
@@ -162,10 +162,6 @@ class ICEBERG_EXPORT BoundExpression {
   virtual std::string ToString() const = 0;
 };
 
-class ICEBERG_EXPORT BoundPredicate : public BoundExpression {
- public:
-  /// \brief Returns a negated version of this bound predicate.
-  virtual std::shared_ptr<BoundPredicate> Negate() const = 0;
-};
+class ICEBERG_EXPORT BoundPredicate : public BoundExpression {};
 
 }  // namespace iceberg