Non-null column rules & tests added, as well as mix tests for comparator elimination & short circuiting

Erik Sargent · Erik Sargent · commit e4deb7200be3 · 2019-05-04T16:53:41.000-04:00
diff --git a/src/include/common/internal_types.h b/src/include/common/internal_types.h
@@ -1397,6 +1397,10 @@ enum class RuleType : uint32_t {
   AND_SHORT_CIRCUIT, // (FALSE AND B)
   OR_SHORT_CIRCUIT, // (TRUE OR B)
 
+  // Catalog-based NULL/NON-NULL rules
+  NULL_LOOKUP_ON_NOT_NULL_COLUMN,
+  NOT_NULL_LOOKUP_ON_NOT_NULL_COLUMN,
+
   // Place holder to generate number of rules compile time
   NUM_RULES
 
diff --git a/src/include/expression/tuple_value_expression.h b/src/include/expression/tuple_value_expression.h
@@ -79,6 +79,10 @@ class TupleValueExpression : public AbstractExpression {
     tuple_idx_ = tuple_idx;
   }
 
+  inline void SetIsNotNull(bool is_not_null) {
+    is_not_null_ = is_not_null;
+  }
+
   /**
    * @brief Attribute binding
    * @param binding_contexts
@@ -94,7 +98,9 @@ class TupleValueExpression : public AbstractExpression {
   }
 
   AbstractExpression *Copy() const override {
-    return new TupleValueExpression(*this);
+    TupleValueExpression *t = new TupleValueExpression(*this);
+    t->SetIsNotNull(GetIsNotNull());
+    return t;
   }
 
   virtual bool operator==(const AbstractExpression &rhs) const override {
@@ -116,6 +122,8 @@ class TupleValueExpression : public AbstractExpression {
     if ((table_name_.empty() xor other.table_name_.empty()) ||
         col_name_.empty() xor other.col_name_.empty())
       return false;
+    if (GetIsNotNull() != other.GetIsNotNull())
+      return false;
     bool res = bound_obj_id_ == other.bound_obj_id_;
     if (!table_name_.empty() && !other.table_name_.empty())
       res = table_name_ == other.table_name_ && res;
@@ -151,6 +159,8 @@ class TupleValueExpression : public AbstractExpression {
 
   bool GetIsBound() const { return is_bound_; }
 
+  bool GetIsNotNull() const { return is_not_null_; }
+
   const std::tuple<oid_t, oid_t, oid_t> &GetBoundOid() const {
     return bound_obj_id_;
   }
@@ -196,6 +206,7 @@ class TupleValueExpression : public AbstractExpression {
   int tuple_idx_;
   std::string table_name_;
   std::string col_name_;
+  bool is_not_null_ = false;
 
   const planner::AttributeInfo *ai_;
 };
diff --git a/src/include/optimizer/rule.h b/src/include/optimizer/rule.h
@@ -117,7 +117,8 @@ enum class RewriteRuleSetName : uint32_t {
   COMPARATOR_ELIMINATION,
   EQUIVALENT_TRANSFORM,
   TRANSITIVE_TRANSFORM,
-  BOOLEAN_SHORT_CIRCUIT
+  BOOLEAN_SHORT_CIRCUIT,
+  NULL_LOOKUP
 };
 
 /**
diff --git a/src/include/optimizer/rule_rewrite.h b/src/include/optimizer/rule_rewrite.h
@@ -96,5 +96,28 @@ class OrShortCircuit: public Rule<AbsExpr_Container,ExpressionType,AbsExpr_Expre
                  OptimizeContextTemplate *context) const override;
 };
 
+class NullLookupOnNotNullColumn: public Rule<AbsExpr_Container,ExpressionType,AbsExpr_Expression> {
+ public:
+  NullLookupOnNotNullColumn();
+
+  int Promise(GroupExprTemplate *group_expr, OptimizeContextTemplate *context) const override;
+  bool Check(std::shared_ptr<AbsExpr_Expression> plan, OptimizeContextTemplate *context) const override;
+  void Transform(std::shared_ptr<AbsExpr_Expression> input,
+                 std::vector<std::shared_ptr<AbsExpr_Expression>> &transformed,
+                 OptimizeContextTemplate *context) const override;
+};
+
+class NotNullLookupOnNotNullColumn: public Rule<AbsExpr_Container,ExpressionType,AbsExpr_Expression> {
+ public:
+  NotNullLookupOnNotNullColumn();
+
+  int Promise(GroupExprTemplate *group_expr, OptimizeContextTemplate *context) const override;
+  bool Check(std::shared_ptr<AbsExpr_Expression> plan, OptimizeContextTemplate *context) const override;
+  void Transform(std::shared_ptr<AbsExpr_Expression> input,
+                 std::vector<std::shared_ptr<AbsExpr_Expression>> &transformed,
+                 OptimizeContextTemplate *context) const override;
+};
+
+
 }  // namespace optimizer
 }  // namespace peloton
diff --git a/src/optimizer/binding.cpp b/src/optimizer/binding.cpp
@@ -12,11 +12,15 @@
 
 #include "optimizer/binding.h"
 
+#include <memory>
+
 #include "common/logger.h"
 #include "optimizer/operator_visitor.h"
 #include "optimizer/optimizer.h"
 #include "optimizer/absexpr_expression.h"
 #include "expression/group_marker_expression.h"
+#include "expression/abstract_expression.h"
+#include "expression/tuple_value_expression.h"
 
 namespace peloton {
 namespace optimizer {
@@ -134,6 +138,7 @@ GroupExprBindingIterator<Node,OperatorType,OperatorExpr>::GroupExprBindingIterat
       first_(true),
       has_next_(false),
       current_binding_(std::make_shared<OperatorExpr>(gexpr->Op())) {
+  // First check to make sure that types of pattern & expression match
   if (gexpr->Op().GetType() != pattern->Type()) {
     return;
   }
diff --git a/src/optimizer/rewriter.cpp b/src/optimizer/rewriter.cpp
@@ -66,9 +66,11 @@ void Rewriter::RewriteLoop(int root_group_id) {
   metadata_.SetTaskPool(task_stack.get());
 
   // Perform rewrite first
+  task_stack->Push(new TopDownRewriteTemplate(root_group_id, root_context, RewriteRuleSetName::BOOLEAN_SHORT_CIRCUIT));
   task_stack->Push(new BottomUpRewriteTemplate(root_group_id, root_context, RewriteRuleSetName::TRANSITIVE_TRANSFORM, false));
   task_stack->Push(new BottomUpRewriteTemplate(root_group_id, root_context, RewriteRuleSetName::COMPARATOR_ELIMINATION, false));
 
+  task_stack->Push(new BottomUpRewriteTemplate(root_group_id, root_context, RewriteRuleSetName::NULL_LOOKUP, false));
   auto equiv_task = new TopDownRewriteTemplate(root_group_id, root_context, RewriteRuleSetName::EQUIVALENT_TRANSFORM);
   equiv_task->SetReplaceOnTransform(false); // generate equivalent
   task_stack->Push(equiv_task);
diff --git a/src/optimizer/rule.cpp b/src/optimizer/rule.cpp
@@ -91,6 +91,9 @@ RuleSet<AbsExpr_Container,ExpressionType,AbsExpr_Expression>::RuleSet() {
 
   AddRewriteRule(RewriteRuleSetName::BOOLEAN_SHORT_CIRCUIT, new AndShortCircuit());
   AddRewriteRule(RewriteRuleSetName::BOOLEAN_SHORT_CIRCUIT, new OrShortCircuit());
+
+  AddRewriteRule(RewriteRuleSetName::NULL_LOOKUP, new NullLookupOnNotNullColumn());
+  AddRewriteRule(RewriteRuleSetName::NULL_LOOKUP, new NotNullLookupOnNotNullColumn());
 }
 
 template <>
diff --git a/src/optimizer/rule_rewrite.cpp b/src/optimizer/rule_rewrite.cpp
@@ -431,8 +431,6 @@ void AndShortCircuit::Transform(std::shared_ptr<AbsExpr_Expression> input,
   (void)context;
   (void)transformed;
 
-  LOG_DEBUG("Transforming AND!");
-
   // Asserting guarantees provided by the GroupExprBindingIterator
   // Structure: (FALSE AND <any expression>)
   PELOTON_ASSERT(input->Children().size() == 2);
@@ -485,8 +483,6 @@ void OrShortCircuit::Transform(std::shared_ptr<AbsExpr_Expression> input,
   (void)context;
   (void)transformed;
 
-  LOG_DEBUG("Transforming OR!");
-
   // Asserting guarantees provided by the GroupExprBindingIterator
   // Structure: (TRUE OR <any expression>)
   PELOTON_ASSERT(input->Children().size() == 2);
@@ -509,5 +505,104 @@ void OrShortCircuit::Transform(std::shared_ptr<AbsExpr_Expression> input,
 }
 
 
+NullLookupOnNotNullColumn::NullLookupOnNotNullColumn() {
+  type_ = RuleType::NULL_LOOKUP_ON_NOT_NULL_COLUMN;
+
+  // Structure: [T.X IS NULL]
+  match_pattern = std::make_shared<Pattern<ExpressionType>>(ExpressionType::OPERATOR_IS_NULL);
+  auto child = std::make_shared<Pattern<ExpressionType>>(ExpressionType::VALUE_TUPLE);
+
+  match_pattern->AddChild(child);
+}
+
+int NullLookupOnNotNullColumn::Promise(GroupExprTemplate *group_expr, OptimizeContextTemplate *context) const {
+  (void)group_expr;
+  (void)context;
+  return static_cast<int>(RulePriority::HIGH);
+}
+
+bool NullLookupOnNotNullColumn::Check(std::shared_ptr<AbsExpr_Expression> plan, OptimizeContextTemplate *context) const {
+  (void)plan;
+  (void)context;
+  return true;
+}
+
+void NullLookupOnNotNullColumn::Transform(std::shared_ptr<AbsExpr_Expression> input,
+                                std::vector<std::shared_ptr<AbsExpr_Expression>> &transformed,
+                                OptimizeContextTemplate *context) const {
+  (void)context;
+  (void)transformed;
+
+  // Asserting guarantees provided by the GroupExprBindingIterator
+  // Structure: (TRUE OR <any expression>)
+  PELOTON_ASSERT(input->Children().size() == 1);
+  PELOTON_ASSERT(input->Op().GetType() == ExpressionType::OPERATOR_IS_NULL);
+
+  std::shared_ptr<AbsExpr_Expression> child = input->Children()[0];
+  PELOTON_ASSERT(child->Children().size() == 0);
+  PELOTON_ASSERT(child->Op().GetType() == ExpressionType::VALUE_TUPLE);
+
+  std::shared_ptr<expression::TupleValueExpression> tuple_expr = std::dynamic_pointer_cast<expression::TupleValueExpression>(child->Op().GetExpr());
+
+  // Only transform into [FALSE] if the tuple value expression is specifically non-NULL,
+  //   otherwise do nothing
+  if (tuple_expr->GetIsNotNull()) {
+    type::Value val_false = type::ValueFactory::GetBooleanValue(false);
+    std::shared_ptr<expression::ConstantValueExpression> false_expr = std::make_shared<expression::ConstantValueExpression>(val_false);
+    std::shared_ptr<AbsExpr_Expression> false_container = std::make_shared<AbsExpr_Expression>(AbsExpr_Container(false_expr));
+    transformed.push_back(false_container);
+  }
+}
+
+
+NotNullLookupOnNotNullColumn::NotNullLookupOnNotNullColumn() {
+  type_ = RuleType::NOT_NULL_LOOKUP_ON_NOT_NULL_COLUMN;
+
+  // Structure: [T.X IS NOT NULL]
+  match_pattern = std::make_shared<Pattern<ExpressionType>>(ExpressionType::OPERATOR_IS_NOT_NULL);
+  auto child = std::make_shared<Pattern<ExpressionType>>(ExpressionType::VALUE_TUPLE);
+
+  match_pattern->AddChild(child);
+}
+
+int NotNullLookupOnNotNullColumn::Promise(GroupExprTemplate *group_expr, OptimizeContextTemplate *context) const {
+  (void)group_expr;
+  (void)context;
+  return static_cast<int>(RulePriority::HIGH);
+}
+
+bool NotNullLookupOnNotNullColumn::Check(std::shared_ptr<AbsExpr_Expression> plan, OptimizeContextTemplate *context) const {
+  (void)plan;
+  (void)context;
+  return true;
+}
+
+void NotNullLookupOnNotNullColumn::Transform(std::shared_ptr<AbsExpr_Expression> input,
+                                std::vector<std::shared_ptr<AbsExpr_Expression>> &transformed,
+                                OptimizeContextTemplate *context) const {
+  (void)context;
+  (void)transformed;
+
+  // Asserting guarantees provided by the GroupExprBindingIterator
+  // Structure: (TRUE OR <any expression>)
+  PELOTON_ASSERT(input->Children().size() == 1);
+  PELOTON_ASSERT(input->Op().GetType() == ExpressionType::OPERATOR_IS_NOT_NULL);
+
+  std::shared_ptr<AbsExpr_Expression> child = input->Children()[0];
+  PELOTON_ASSERT(child->Children().size() == 0);
+  PELOTON_ASSERT(child->Op().GetType() == ExpressionType::VALUE_TUPLE);
+
+  std::shared_ptr<expression::TupleValueExpression> tuple_expr = std::dynamic_pointer_cast<expression::TupleValueExpression>(child->Op().GetExpr());
+
+  // Only transform into [TRUE] if the tuple value expression is specifically non-NULL,
+  //   otherwise do nothing
+  if (tuple_expr->GetIsNotNull()) {
+    type::Value val_true = type::ValueFactory::GetBooleanValue(true);
+    std::shared_ptr<expression::ConstantValueExpression> true_expr = std::make_shared<expression::ConstantValueExpression>(val_true);
+    std::shared_ptr<AbsExpr_Expression> true_container = std::make_shared<AbsExpr_Expression>(AbsExpr_Container(true_expr));
+    transformed.push_back(true_container);
+  }
+}
+
 }  // namespace optimizer
 }  // namespace peloton
diff --git a/test/optimizer/rewriter_test.cpp b/test/optimizer/rewriter_test.cpp

Original file line number	Diff line number	Diff line change
`@@ -91,6 +91,9 @@ RuleSet<AbsExpr_Container,ExpressionType,AbsExpr_Expression>::RuleSet() {`
`91`	`91`
`92`	`92`	`AddRewriteRule(RewriteRuleSetName::BOOLEAN_SHORT_CIRCUIT, new AndShortCircuit());`
`93`	`93`	`AddRewriteRule(RewriteRuleSetName::BOOLEAN_SHORT_CIRCUIT, new OrShortCircuit());`
	`94`	`+`
	`95`	`+ AddRewriteRule(RewriteRuleSetName::NULL_LOOKUP, new NullLookupOnNotNullColumn());`
	`96`	`+ AddRewriteRule(RewriteRuleSetName::NULL_LOOKUP, new NotNullLookupOnNotNullColumn());`
`94`	`97`	`}`
`95`	`98`
`96`	`99`	`template <>`