Attempt at fixing pushdown filter

Author: gangsterveggies

src/include/planner/abstract_join_plan.h

@@ -87,6 +87,10 @@ class AbstractJoinPlan : public AbstractPlan {
   virtual void HandleSubplanBinding(bool from_left,
                                     const BindingContext &input) = 0;
 
+  const std::string GetPredicateInfo() const {
+    return predicate_ != nullptr ? predicate_->GetInfo() : "";
+  }
+
  private:
   /** @brief The type of join that we're going to perform */
   JoinType join_type_;

src/include/planner/hash_join_plan.h

@@ -57,7 +57,9 @@ class HashJoinPlan : public AbstractJoinPlan {
 
   void SetBloomFilterFlag(bool flag) { build_bloomfilter_ = flag; }
 
-  const std::string GetInfo() const override { return "HashJoin"; }
+  const std::string GetInfo() const override {
+    return "HashJoin(" + GetPredicateInfo() + ")";
+  }
 
   const std::vector<oid_t> &GetOuterHashIds() const {
     return outer_column_ids_;

src/optimizer/optimizer_task.cpp

@@ -423,6 +423,11 @@ void TopDownRewrite::execute() {
                                       r.rule->GetMatchPattern());
     if (iterator.HasNext()) {
       auto before = iterator.Next();
+
+      if (!r.rule->Check(before, context_.get())) {
+	continue;
+      }
+      
       PELOTON_ASSERT(!iterator.HasNext());
       std::vector<std::shared_ptr<OperatorExpression>> after;
       r.rule->Transform(before, after, context_.get());

src/optimizer/query_to_operator_transformer.cpp

@@ -123,6 +123,8 @@ void QueryToOperatorTransformer::Visit(parser::SelectStatement *op) {
   predicates_ = std::move(pre_predicates);
 }
 void QueryToOperatorTransformer::Visit(parser::JoinDefinition *node) {
+  auto pre_predicates = std::move(predicates_);
+  
   // Get left operator
   node->left->Accept(this);
   auto left_expr = output_expr_;
@@ -137,25 +139,25 @@ void QueryToOperatorTransformer::Visit(parser::JoinDefinition *node) {
     case JoinType::INNER: {
       predicates_ = CollectPredicates(node->condition.get(), predicates_);
       join_expr = std::make_shared<OperatorExpression>(
-          LogicalJoin::make(JoinType::INNER));
+          LogicalJoin::make(JoinType::INNER, predicates_));
       break;
     }
     case JoinType::OUTER: {
       predicates_ = CollectPredicates(node->condition.get(), predicates_);
       join_expr = std::make_shared<OperatorExpression>(
-          LogicalJoin::make(JoinType::OUTER));
+          LogicalJoin::make(JoinType::OUTER, predicates_));
       break;
     }
     case JoinType::LEFT: {
       predicates_ = CollectPredicates(node->condition.get(), predicates_);
       join_expr = std::make_shared<OperatorExpression>(
-          LogicalJoin::make(JoinType::LEFT));
+          LogicalJoin::make(JoinType::LEFT, predicates_));
       break;
     }
     case JoinType::RIGHT: {
       predicates_ = CollectPredicates(node->condition.get(), predicates_);
       join_expr = std::make_shared<OperatorExpression>(
-          LogicalJoin::make(JoinType::RIGHT));
+          LogicalJoin::make(JoinType::RIGHT, predicates_));
       break;
     }
     case JoinType::SEMI: {
@@ -171,6 +173,7 @@ void QueryToOperatorTransformer::Visit(parser::JoinDefinition *node) {
   join_expr->PushChild(right_expr);
 
   output_expr_ = join_expr;
+  predicates_ = std::move(pre_predicates);
 }
 void QueryToOperatorTransformer::Visit(parser::TableRef *node) {
   if (node->select != nullptr) {

src/optimizer/rule.cpp

@@ -46,7 +46,7 @@ RuleSet::RuleSet() {
   AddImplementationRule(new ImplementLimit());
 
   AddRewriteRule(RewriteRuleSetName::PREDICATE_PUSH_DOWN,
-                 new PushFilterThroughJoin());
+		 new PushFilterThroughJoin());
   AddRewriteRule(RewriteRuleSetName::PREDICATE_PUSH_DOWN,
                  new PushFilterThroughAggregation());
   AddRewriteRule(RewriteRuleSetName::PREDICATE_PUSH_DOWN,

src/optimizer/rule_impls.cpp

@@ -853,17 +853,22 @@ void PushFilterThroughJoin::Transform(
   std::vector<AnnotatedExpression> right_predicates;
   std::vector<AnnotatedExpression> join_predicates;
 
+  auto join_type = join_op_expr->Op().As<LogicalJoin>()->type;
+  bool outer_push = (join_type == JoinType::OUTER ||
+		     join_type == JoinType::LEFT ||
+		     join_type == JoinType::RIGHT);
+
   // Loop over all predicates, check each of them if they can be pushed down to
   // either the left child or the right child to be evaluated
   // All predicates in this loop follow conjunction relationship because we
   // already extract these predicates from the original.
   // E.g. An expression (test.a = test1.b and test.a = 5) would become
   // {test.a = test1.b, test.a = 5}
   for (auto &predicate : predicates) {
-    if (util::IsSubset(left_group_aliases_set, predicate.table_alias_set)) {
+    if (util::IsSubset(left_group_aliases_set, predicate.table_alias_set) && !outer_push) {
       left_predicates.emplace_back(predicate);
     } else if (util::IsSubset(right_group_aliases_set,
-                              predicate.table_alias_set)) {
+                              predicate.table_alias_set) && !outer_push) {
       right_predicates.emplace_back(predicate);
     } else {
       join_predicates.emplace_back(predicate);