quickstep-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jianq...@apache.org
Subject [2/2] incubator-quickstep git commit: QUICKSTEP-121: Added the self-join support.
Date Wed, 09 May 2018 23:10:59 GMT
QUICKSTEP-121: Added the self-join support.


Project: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/commit/8b7c3801
Tree: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/tree/8b7c3801
Diff: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/diff/8b7c3801

Branch: refs/heads/master
Commit: 8b7c38010e1505ef03e0b6de8c6ac16cceb04695
Parents: 42588d4
Author: Zuyu Zhang <zuyu@cs.wisc.edu>
Authored: Tue May 1 00:48:34 2018 -0500
Committer: Zuyu Zhang <zuyu@cs.wisc.edu>
Committed: Wed May 9 16:34:47 2018 -0500

----------------------------------------------------------------------
 expressions/ExpressionFactories.cpp             | 17 +++-
 expressions/Expressions.proto                   |  7 ++
 expressions/predicate/ComparisonPredicate.cpp   | 26 +++---
 expressions/predicate/ComparisonPredicate.hpp   |  2 -
 expressions/predicate/ConjunctionPredicate.cpp  |  4 -
 expressions/predicate/ConjunctionPredicate.hpp  |  2 -
 expressions/predicate/DisjunctionPredicate.cpp  |  4 -
 expressions/predicate/DisjunctionPredicate.hpp  |  2 -
 expressions/predicate/NegationPredicate.cpp     |  4 -
 expressions/predicate/NegationPredicate.hpp     |  2 -
 expressions/predicate/Predicate.hpp             |  6 --
 expressions/predicate/TrivialPredicates.hpp     |  4 -
 expressions/scalar/Scalar.hpp                   | 50 +++++------
 expressions/scalar/ScalarAttribute.cpp          | 58 +++++++++----
 expressions/scalar/ScalarAttribute.hpp          | 10 +--
 expressions/scalar/ScalarBinaryExpression.cpp   | 80 +++++------------
 expressions/scalar/ScalarBinaryExpression.hpp   |  4 -
 expressions/scalar/ScalarCaseExpression.cpp     | 62 +++-----------
 expressions/scalar/ScalarCaseExpression.hpp     |  4 -
 expressions/scalar/ScalarLiteral.cpp            |  2 -
 expressions/scalar/ScalarLiteral.hpp            |  4 -
 expressions/scalar/ScalarSharedExpression.cpp   | 14 +--
 expressions/scalar/ScalarSharedExpression.hpp   |  4 -
 expressions/scalar/ScalarUnaryExpression.cpp    | 18 +---
 expressions/scalar/ScalarUnaryExpression.hpp    |  4 -
 .../tests/ScalarCaseExpression_unittest.cpp     | 58 ++++++-------
 query_optimizer/ExecutionGenerator.cpp          | 88 ++++++++++++-------
 query_optimizer/ExecutionGenerator.hpp          | 21 +++--
 query_optimizer/expressions/Alias.cpp           |  5 +-
 query_optimizer/expressions/Alias.hpp           |  5 +-
 .../expressions/AttributeReference.cpp          | 19 ++++-
 .../expressions/AttributeReference.hpp          |  5 +-
 .../expressions/BinaryExpression.cpp            |  9 +-
 .../expressions/BinaryExpression.hpp            |  5 +-
 query_optimizer/expressions/CMakeLists.txt      |  1 +
 query_optimizer/expressions/Cast.cpp            | 10 ++-
 query_optimizer/expressions/Cast.hpp            |  5 +-
 .../expressions/CommonSubexpression.cpp         |  7 +-
 .../expressions/CommonSubexpression.hpp         |  5 +-
 .../expressions/ComparisonExpression.cpp        |  9 +-
 .../expressions/ComparisonExpression.hpp        |  5 +-
 query_optimizer/expressions/Exists.cpp          |  5 +-
 query_optimizer/expressions/Exists.hpp          |  5 +-
 query_optimizer/expressions/InTableQuery.cpp    |  5 +-
 query_optimizer/expressions/InTableQuery.hpp    |  5 +-
 query_optimizer/expressions/InValueList.cpp     |  7 +-
 query_optimizer/expressions/InValueList.hpp     |  5 +-
 query_optimizer/expressions/LogicalAnd.cpp      |  9 +-
 query_optimizer/expressions/LogicalAnd.hpp      |  5 +-
 query_optimizer/expressions/LogicalNot.cpp      |  7 +-
 query_optimizer/expressions/LogicalNot.hpp      |  5 +-
 query_optimizer/expressions/LogicalOr.cpp       |  9 +-
 query_optimizer/expressions/LogicalOr.hpp       |  5 +-
 query_optimizer/expressions/Predicate.hpp       |  7 +-
 .../expressions/PredicateLiteral.cpp            |  5 +-
 .../expressions/PredicateLiteral.hpp            |  5 +-
 query_optimizer/expressions/Scalar.hpp          |  8 +-
 query_optimizer/expressions/ScalarLiteral.cpp   |  5 +-
 query_optimizer/expressions/ScalarLiteral.hpp   |  5 +-
 query_optimizer/expressions/SearchedCase.cpp    | 17 ++--
 query_optimizer/expressions/SearchedCase.hpp    |  5 +-
 query_optimizer/expressions/SimpleCase.cpp      |  7 +-
 query_optimizer/expressions/SimpleCase.hpp      |  5 +-
 .../expressions/SubqueryExpression.cpp          |  5 +-
 .../expressions/SubqueryExpression.hpp          |  5 +-
 query_optimizer/expressions/UnaryExpression.cpp |  7 +-
 query_optimizer/expressions/UnaryExpression.hpp |  5 +-
 .../tests/execution_generator/Select.test       | 56 +++++++++++-
 relational_operators/HashJoinOperator.cpp       | 90 +++++++-------------
 .../NestedLoopsJoinOperator.cpp                 |  9 +-
 .../tests/HashJoinOperator_unittest.cpp         | 34 ++++----
 71 files changed, 536 insertions(+), 467 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/8b7c3801/expressions/ExpressionFactories.cpp
----------------------------------------------------------------------
diff --git a/expressions/ExpressionFactories.cpp b/expressions/ExpressionFactories.cpp
index 871db50..cab99fd 100644
--- a/expressions/ExpressionFactories.cpp
+++ b/expressions/ExpressionFactories.cpp
@@ -52,6 +52,8 @@
 
 namespace quickstep {
 
+namespace S = serialization;
+
 class Type;
 
 Predicate* PredicateFactory::ReconstructFromProto(const serialization::Predicate &proto,
@@ -163,9 +165,22 @@ Scalar* ScalarFactory::ReconstructFromProto(const serialization::Scalar &proto,
     case serialization::Scalar::ATTRIBUTE: {
       const relation_id rel_id = proto.GetExtension(serialization::ScalarAttribute::relation_id);
 
+      Scalar::JoinSide join_side;
+      switch (proto.GetExtension(S::ScalarAttribute::join_side)) {
+        case S::ScalarAttribute::NONE:
+          join_side = Scalar::kNone;
+          break;
+        case S::ScalarAttribute::LEFT_SIDE:
+          join_side = Scalar::kLeftSide;
+          break;
+        case S::ScalarAttribute::RIGHT_SIDE:
+          join_side = Scalar::kRightSide;
+          break;
+      }
+
       DCHECK(database.hasRelationWithId(rel_id));
       return new ScalarAttribute(*database.getRelationSchemaById(rel_id).getAttributeById(
-          proto.GetExtension(serialization::ScalarAttribute::attribute_id)));
+          proto.GetExtension(serialization::ScalarAttribute::attribute_id)), join_side);
     }
     case serialization::Scalar::UNARY_EXPRESSION: {
       return new ScalarUnaryExpression(

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/8b7c3801/expressions/Expressions.proto
----------------------------------------------------------------------
diff --git a/expressions/Expressions.proto b/expressions/Expressions.proto
index 8b4611e..aabb707 100644
--- a/expressions/Expressions.proto
+++ b/expressions/Expressions.proto
@@ -95,9 +95,16 @@ message ScalarLiteral {
 }
 
 message ScalarAttribute {
+  enum JoinSide {
+    NONE = 0;
+    LEFT_SIDE = 1;
+    RIGHT_SIDE = 2;
+  }
+
   extend Scalar {
     optional int32 relation_id = 64;
     optional int32 attribute_id = 65;
+    optional JoinSide join_side = 66;
   }
 }
 

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/8b7c3801/expressions/predicate/ComparisonPredicate.cpp
----------------------------------------------------------------------
diff --git a/expressions/predicate/ComparisonPredicate.cpp b/expressions/predicate/ComparisonPredicate.cpp
index 2f7b84b..0417170 100644
--- a/expressions/predicate/ComparisonPredicate.cpp
+++ b/expressions/predicate/ComparisonPredicate.cpp
@@ -94,28 +94,22 @@ bool ComparisonPredicate::matchesForSingleTuple(const ValueAccessor &accessor,
 
 bool ComparisonPredicate::matchesForJoinedTuples(
     const ValueAccessor &left_accessor,
-    const relation_id left_relation_id,
     const tuple_id left_tuple_id,
     const ValueAccessor &right_accessor,
-    const relation_id right_relation_id,
     const tuple_id right_tuple_id) const {
   if (fast_comparator_.get() == nullptr) {
     return static_result_;
-  } else {
-    return fast_comparator_->compareTypedValues(
-        left_operand_->getValueForJoinedTuples(left_accessor,
-                                               left_relation_id,
-                                               left_tuple_id,
-                                               right_accessor,
-                                               right_relation_id,
-                                               right_tuple_id),
-        right_operand_->getValueForJoinedTuples(left_accessor,
-                                                left_relation_id,
-                                                left_tuple_id,
-                                                right_accessor,
-                                                right_relation_id,
-                                                right_tuple_id));
   }
+
+  return fast_comparator_->compareTypedValues(
+      left_operand_->getValueForJoinedTuples(left_accessor,
+                                             left_tuple_id,
+                                             right_accessor,
+                                             right_tuple_id),
+      right_operand_->getValueForJoinedTuples(left_accessor,
+                                              left_tuple_id,
+                                              right_accessor,
+                                              right_tuple_id));
 }
 
 TupleIdSequence* ComparisonPredicate::getAllMatches(

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/8b7c3801/expressions/predicate/ComparisonPredicate.hpp
----------------------------------------------------------------------
diff --git a/expressions/predicate/ComparisonPredicate.hpp b/expressions/predicate/ComparisonPredicate.hpp
index 1ef2cb1..014e378 100644
--- a/expressions/predicate/ComparisonPredicate.hpp
+++ b/expressions/predicate/ComparisonPredicate.hpp
@@ -83,10 +83,8 @@ class ComparisonPredicate : public Predicate {
 
   bool matchesForJoinedTuples(
       const ValueAccessor &left_accessor,
-      const relation_id left_relation_id,
       const tuple_id left_tuple_id,
       const ValueAccessor &right_accessor,
-      const relation_id right_relation_id,
       const tuple_id right_tuple_id) const override;
 
   TupleIdSequence* getAllMatches(ValueAccessor *accessor,

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/8b7c3801/expressions/predicate/ConjunctionPredicate.cpp
----------------------------------------------------------------------
diff --git a/expressions/predicate/ConjunctionPredicate.cpp b/expressions/predicate/ConjunctionPredicate.cpp
index 4f5cc77..39d9e58 100644
--- a/expressions/predicate/ConjunctionPredicate.cpp
+++ b/expressions/predicate/ConjunctionPredicate.cpp
@@ -85,10 +85,8 @@ bool ConjunctionPredicate::matchesForSingleTuple(const ValueAccessor &accessor,
 
 bool ConjunctionPredicate::matchesForJoinedTuples(
     const ValueAccessor &left_accessor,
-    const relation_id left_relation_id,
     const tuple_id left_tuple_id,
     const ValueAccessor &right_accessor,
-    const relation_id right_relation_id,
     const tuple_id right_tuple_id) const {
   if (has_static_result_) {
     return static_result_;
@@ -97,10 +95,8 @@ bool ConjunctionPredicate::matchesForJoinedTuples(
          it != dynamic_operand_list_.end();
          ++it) {
       if (!it->matchesForJoinedTuples(left_accessor,
-                                      left_relation_id,
                                       left_tuple_id,
                                       right_accessor,
-                                      right_relation_id,
                                       right_tuple_id)) {
         return false;
       }

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/8b7c3801/expressions/predicate/ConjunctionPredicate.hpp
----------------------------------------------------------------------
diff --git a/expressions/predicate/ConjunctionPredicate.hpp b/expressions/predicate/ConjunctionPredicate.hpp
index b24036a..07148a7 100644
--- a/expressions/predicate/ConjunctionPredicate.hpp
+++ b/expressions/predicate/ConjunctionPredicate.hpp
@@ -63,10 +63,8 @@ class ConjunctionPredicate : public PredicateWithList {
 
   bool matchesForJoinedTuples(
       const ValueAccessor &left_accessor,
-      const relation_id left_relation_id,
       const tuple_id left_tuple_id,
       const ValueAccessor &right_accessor,
-      const relation_id right_relation_id,
       const tuple_id right_tuple_id) const override;
 
   TupleIdSequence* getAllMatches(ValueAccessor *accessor,

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/8b7c3801/expressions/predicate/DisjunctionPredicate.cpp
----------------------------------------------------------------------
diff --git a/expressions/predicate/DisjunctionPredicate.cpp b/expressions/predicate/DisjunctionPredicate.cpp
index e117c99..4ac3bd7 100644
--- a/expressions/predicate/DisjunctionPredicate.cpp
+++ b/expressions/predicate/DisjunctionPredicate.cpp
@@ -85,10 +85,8 @@ bool DisjunctionPredicate::matchesForSingleTuple(const ValueAccessor &accessor,
 
 bool DisjunctionPredicate::matchesForJoinedTuples(
     const ValueAccessor &left_accessor,
-    const relation_id left_relation_id,
     const tuple_id left_tuple_id,
     const ValueAccessor &right_accessor,
-    const relation_id right_relation_id,
     const tuple_id right_tuple_id) const {
   if (has_static_result_) {
     return static_result_;
@@ -97,10 +95,8 @@ bool DisjunctionPredicate::matchesForJoinedTuples(
          it != dynamic_operand_list_.end();
          ++it) {
       if (it->matchesForJoinedTuples(left_accessor,
-                                     left_relation_id,
                                      left_tuple_id,
                                      right_accessor,
-                                     right_relation_id,
                                      right_tuple_id)) {
         return true;
       }

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/8b7c3801/expressions/predicate/DisjunctionPredicate.hpp
----------------------------------------------------------------------
diff --git a/expressions/predicate/DisjunctionPredicate.hpp b/expressions/predicate/DisjunctionPredicate.hpp
index 2127573..2b237e6 100644
--- a/expressions/predicate/DisjunctionPredicate.hpp
+++ b/expressions/predicate/DisjunctionPredicate.hpp
@@ -63,10 +63,8 @@ class DisjunctionPredicate : public PredicateWithList {
 
   bool matchesForJoinedTuples(
       const ValueAccessor &left_accessor,
-      const relation_id left_relation_id,
       const tuple_id left_tuple_id,
       const ValueAccessor &right_accessor,
-      const relation_id right_relation_id,
       const tuple_id right_tuple_id) const override;
 
   TupleIdSequence* getAllMatches(ValueAccessor *accessor,

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/8b7c3801/expressions/predicate/NegationPredicate.cpp
----------------------------------------------------------------------
diff --git a/expressions/predicate/NegationPredicate.cpp b/expressions/predicate/NegationPredicate.cpp
index 92a8411..ad3238a 100644
--- a/expressions/predicate/NegationPredicate.cpp
+++ b/expressions/predicate/NegationPredicate.cpp
@@ -54,19 +54,15 @@ bool NegationPredicate::matchesForSingleTuple(const ValueAccessor &accessor,
 
 bool NegationPredicate::matchesForJoinedTuples(
     const ValueAccessor &left_accessor,
-    const relation_id left_relation_id,
     const tuple_id left_tuple_id,
     const ValueAccessor &right_accessor,
-    const relation_id right_relation_id,
     const tuple_id right_tuple_id) const {
   if (has_static_result_) {
     return static_result_;
   } else {
     return !(operand_->matchesForJoinedTuples(left_accessor,
-                                              left_relation_id,
                                               left_tuple_id,
                                               right_accessor,
-                                              right_relation_id,
                                               right_tuple_id));
   }
 }

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/8b7c3801/expressions/predicate/NegationPredicate.hpp
----------------------------------------------------------------------
diff --git a/expressions/predicate/NegationPredicate.hpp b/expressions/predicate/NegationPredicate.hpp
index ec005ea..7afcf1c 100644
--- a/expressions/predicate/NegationPredicate.hpp
+++ b/expressions/predicate/NegationPredicate.hpp
@@ -91,10 +91,8 @@ class NegationPredicate : public Predicate {
 
   bool matchesForJoinedTuples(
       const ValueAccessor &left_accessor,
-      const relation_id left_relation_id,
       const tuple_id left_tuple_id,
       const ValueAccessor &right_accessor,
-      const relation_id right_relation_id,
       const tuple_id right_tuple_id) const override;
 
   TupleIdSequence* getAllMatches(ValueAccessor *accessor,

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/8b7c3801/expressions/predicate/Predicate.hpp
----------------------------------------------------------------------
diff --git a/expressions/predicate/Predicate.hpp b/expressions/predicate/Predicate.hpp
index df04644..31fbb9a 100644
--- a/expressions/predicate/Predicate.hpp
+++ b/expressions/predicate/Predicate.hpp
@@ -123,15 +123,11 @@ class Predicate : public Expression {
    * @param left_accessor The ValueAccessor that the first of the joined tuples
    *        will be read from (this does NOT necessarily correspond to the left
    *        operand of a binary operation).
-   * @param left_relation_id The ID of the relation that left_accessor provides
-   *        access to.
    * @param left_tuple_id The ID of the tuple (the absolute position) from
    *        left_accessor to evaluate this Predicate for.
    * @param right_accessor The ValueAccessor that the second of the joined
    *        tuples will be read from (this does NOT necessarily correspond to
    *        the right operand of a binary operation).
-   * @param right_relation_id The ID of the relation that right_accessor
-   *        provides access to.
    * @param right_tuple_id The ID of the tuple (the absolute position) from
    *        right_accessor to evaluate this Predicate for.
    * @return Whether this predicate is true for the given tuples.
@@ -144,10 +140,8 @@ class Predicate : public Expression {
   // a smallish set of matches from a hash-join by a residual predicate).
   virtual bool matchesForJoinedTuples(
       const ValueAccessor &left_accessor,
-      const relation_id left_relation_id,
       const tuple_id left_tuple_id,
       const ValueAccessor &right_accessor,
-      const relation_id right_relation_id,
       const tuple_id right_tuple_id) const = 0;
 
   /**

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/8b7c3801/expressions/predicate/TrivialPredicates.hpp
----------------------------------------------------------------------
diff --git a/expressions/predicate/TrivialPredicates.hpp b/expressions/predicate/TrivialPredicates.hpp
index 4e44976..e313cd5 100644
--- a/expressions/predicate/TrivialPredicates.hpp
+++ b/expressions/predicate/TrivialPredicates.hpp
@@ -84,10 +84,8 @@ class TruePredicate : public TrivialPredicate {
 
   bool matchesForJoinedTuples(
       const ValueAccessor &left_accessor,
-      const relation_id left_relation_id,
       const tuple_id left_tuple_id,
       const ValueAccessor &right_accessor,
-      const relation_id right_relation_id,
       const tuple_id right_tuple_id) const override {
     return true;
   }
@@ -137,10 +135,8 @@ class FalsePredicate : public TrivialPredicate {
 
   bool matchesForJoinedTuples(
       const ValueAccessor &left_accessor,
-      const relation_id left_relation_id,
       const tuple_id left_tuple_id,
       const ValueAccessor &right_accessor,
-      const relation_id right_relation_id,
       const tuple_id right_tuple_id) const override {
     return false;
   }

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/8b7c3801/expressions/scalar/Scalar.hpp
----------------------------------------------------------------------
diff --git a/expressions/scalar/Scalar.hpp b/expressions/scalar/Scalar.hpp
index 6e482c2..0c1cba1 100644
--- a/expressions/scalar/Scalar.hpp
+++ b/expressions/scalar/Scalar.hpp
@@ -51,6 +51,15 @@ struct SubBlocksReference;
 class Scalar : public Expression {
  public:
   /**
+   * @brief The possible binary join side of Scalar values.
+   **/
+  enum JoinSide {
+    kNone = 0,
+    kLeftSide,
+    kRightSide
+  };
+
+  /**
    * @brief The possible provenance of Scalar values.
    **/
   enum ScalarDataSource {
@@ -128,28 +137,35 @@ class Scalar : public Expression {
    * @param left_accessor The ValueAccessor that the first of the joined
    *        tuples can be read from (this does NOT necessarily correspond to
    *        the left operand of a binary operation).
-   * @param left_relation_id The ID of the relation that left_tuple_store
-   *        belongs to.
    * @param left_tuple_id The ID of the tuple in left_tuple_store to evaluate
    *        this Scalar for.
    * @param right_accessor The ValueAccessor that the second of the joined
    *        tuples can be read from (this does NOT necessarily correspond to
    *        the right operand of a binary operation).
-   * @param right_relation_id The ID of the relation that right_tuple_store
-   *        belongs to.
    * @param right_tuple_id The ID of the tuple in right_tuple_store to evaluate
    *        this Scalar for.
    * @return The value of this scalar for the given tuples.
    **/
   virtual TypedValue getValueForJoinedTuples(
       const ValueAccessor &left_accessor,
-      const relation_id left_relation_id,
       const tuple_id left_tuple_id,
       const ValueAccessor &right_accessor,
-      const relation_id right_relation_id,
       const tuple_id right_tuple_id) const = 0;
 
   /**
+   * @brief If it is possible to get this Scalar's values directly from a
+   *        ValueAccessor, return the binary join side of the ValueAccessor
+   *        should belong to.
+   *
+   * @return The binary join side for ValueAccessors that can directly produce
+   *         this Scalar's values, or kNone if values can not be obtained
+   *         directly from a ValueAccessor.
+   **/
+  JoinSide join_side() const {
+    return join_side_;
+  }
+
+  /**
    * @brief Determine whether this Scalar's value is static (i.e. whether it is
    *        the same regardless of tuple).
    *
@@ -181,19 +197,6 @@ class Scalar : public Expression {
   }
 
   /**
-   * @brief If it is possible to get this Scalar's values directly from a
-   *        ValueAccessor, return the ID of the relation that such a
-   *        ValueAccessor should belong to.
-   *
-   * @return The relation_id for ValueAccessors that can directly produce this
-   *         Scalar's values, or -1 if values can not be obtained directly from
-   *         a ValueAccessor.
-   **/
-  virtual relation_id getRelationIdForValueAccessor() const {
-    return -1;
-  }
-
-  /**
    * @brief Get this Scalar's values for all tuples accesible via a
    *        ValueAccessor.
    *
@@ -217,10 +220,8 @@ class Scalar : public Expression {
    * @brief Get this Scalar's value for all specified joined tuples from two
    *        ValueAccessors.
    *
-   * @param left_relation_id The ID of the left relation in the join.
    * @param left_accessor A ValueAccessor which will be used to access tuples
    *        from the left relation.
-   * @param right_relation_id The ID of the right relation in the join.
    * @param right_accessor A ValueAccessor which will be used to access tuples
    *        from the right relation.
    * @param joined_tuple_ids A series of pairs of tuple ids from the left and
@@ -231,9 +232,7 @@ class Scalar : public Expression {
    *         specified by joined_tuple_ids.
    **/
   virtual ColumnVectorPtr getAllValuesForJoin(
-      const relation_id left_relation_id,
       ValueAccessor *left_accessor,
-      const relation_id right_relation_id,
       ValueAccessor *right_accessor,
       const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids,
       ColumnVectorCache *cv_cache) const = 0;
@@ -247,10 +246,11 @@ class Scalar : public Expression {
       std::vector<std::string> *container_child_field_names,
       std::vector<std::vector<const Expression*>> *container_child_fields) const override;
 
-  explicit Scalar(const Type &type)
-      : Expression(), type_(type) {}
+  explicit Scalar(const Type &type, const JoinSide join_side = kNone)
+      : Expression(), type_(type), join_side_(join_side) {}
 
   const Type &type_;
+  const JoinSide join_side_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Scalar);

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/8b7c3801/expressions/scalar/ScalarAttribute.cpp
----------------------------------------------------------------------
diff --git a/expressions/scalar/ScalarAttribute.cpp b/expressions/scalar/ScalarAttribute.cpp
index 944dc35..8a75bb0 100644
--- a/expressions/scalar/ScalarAttribute.cpp
+++ b/expressions/scalar/ScalarAttribute.cpp
@@ -28,6 +28,7 @@
 #include "catalog/CatalogRelationSchema.hpp"
 #include "catalog/CatalogTypedefs.hpp"
 #include "expressions/Expressions.pb.h"
+#include "expressions/scalar/Scalar.hpp"
 #include "storage/StorageBlockInfo.hpp"
 #include "storage/ValueAccessor.hpp"
 #include "storage/ValueAccessorUtil.hpp"
@@ -40,8 +41,11 @@
 
 namespace quickstep {
 
-ScalarAttribute::ScalarAttribute(const CatalogAttribute &attribute)
-    : Scalar(attribute.getType()),
+namespace S = serialization;
+
+ScalarAttribute::ScalarAttribute(const CatalogAttribute &attribute,
+                                 const JoinSide join_side)
+    : Scalar(attribute.getType(), join_side),
       attribute_(attribute) {
 }
 
@@ -51,11 +55,25 @@ serialization::Scalar ScalarAttribute::getProto() const {
   proto.SetExtension(serialization::ScalarAttribute::relation_id, attribute_.getParent().getID());
   proto.SetExtension(serialization::ScalarAttribute::attribute_id, attribute_.getID());
 
+  S::ScalarAttribute::JoinSide join_side_proto;
+  switch (join_side_) {
+    case kNone:
+      join_side_proto = S::ScalarAttribute::NONE;
+      break;
+    case kLeftSide:
+      join_side_proto = S::ScalarAttribute::LEFT_SIDE;
+      break;
+    case kRightSide:
+      join_side_proto = S::ScalarAttribute::RIGHT_SIDE;
+      break;
+  }
+  proto.SetExtension(S::ScalarAttribute::join_side, join_side_proto);
+
   return proto;
 }
 
 Scalar* ScalarAttribute::clone() const {
-  return new ScalarAttribute(attribute_);
+  return new ScalarAttribute(attribute_, join_side_);
 }
 
 TypedValue ScalarAttribute::getValueForSingleTuple(const ValueAccessor &accessor,
@@ -65,18 +83,16 @@ TypedValue ScalarAttribute::getValueForSingleTuple(const ValueAccessor &accessor
 
 TypedValue ScalarAttribute::getValueForJoinedTuples(
     const ValueAccessor &left_accessor,
-    const relation_id left_relation_id,
     const tuple_id left_tuple_id,
     const ValueAccessor &right_accessor,
-    const relation_id right_relation_id,
     const tuple_id right_tuple_id) const {
-  // FIXME(chasseur): This can get confused and break for self-joins.
-  DCHECK((attribute_.getParent().getID() == left_relation_id)
-         || (attribute_.getParent().getID() == right_relation_id));
-  if (attribute_.getParent().getID() == left_relation_id) {
+  DCHECK(join_side_ != kNone);
+
+  if (join_side_ == kLeftSide) {
     return left_accessor.getTypedValueAtAbsolutePositionVirtual(attribute_.getID(),
                                                                 left_tuple_id);
   } else {
+    DCHECK(join_side_ == kRightSide);
     return right_accessor.getTypedValueAtAbsolutePositionVirtual(attribute_.getID(),
                                                                  right_tuple_id);
   }
@@ -86,10 +102,6 @@ attribute_id ScalarAttribute::getAttributeIdForValueAccessor() const {
   return attribute_.getID();
 }
 
-relation_id ScalarAttribute::getRelationIdForValueAccessor() const {
-  return attribute_.getParent().getID();
-}
-
 ColumnVectorPtr ScalarAttribute::getAllValues(
     ValueAccessor *accessor,
     const SubBlocksReference *sub_blocks_ref,
@@ -157,19 +169,16 @@ ColumnVectorPtr ScalarAttribute::getAllValues(
 }
 
 ColumnVectorPtr ScalarAttribute::getAllValuesForJoin(
-    const relation_id left_relation_id,
     ValueAccessor *left_accessor,
-    const relation_id right_relation_id,
     ValueAccessor *right_accessor,
     const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids,
     ColumnVectorCache *cv_cache) const {
-  DCHECK((attribute_.getParent().getID() == left_relation_id)
-         || (attribute_.getParent().getID() == right_relation_id));
+  DCHECK(join_side_ != kNone);
 
   const attribute_id attr_id = attribute_.getID();
   const Type &result_type = attribute_.getType();
 
-  const bool using_left_relation = (attribute_.getParent().getID() == left_relation_id);
+  const bool using_left_relation = (join_side_ == kLeftSide);
   ValueAccessor *accessor = using_left_relation ? left_accessor
                                                 : right_accessor;
 
@@ -232,6 +241,19 @@ void ScalarAttribute::getFieldStringItems(
 
   inline_field_names->emplace_back("attribute");
   inline_field_values->emplace_back(std::to_string(attribute_.getID()));
+
+  switch (join_side_) {
+    case kNone:
+      break;
+    case kLeftSide:
+      inline_field_names->emplace_back("join_side");
+      inline_field_values->push_back("left_side");
+      break;
+    case kRightSide:
+      inline_field_names->emplace_back("join_side");
+      inline_field_values->push_back("right_side");
+      break;
+  }
 }
 
 }  // namespace quickstep

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/8b7c3801/expressions/scalar/ScalarAttribute.hpp
----------------------------------------------------------------------
diff --git a/expressions/scalar/ScalarAttribute.hpp b/expressions/scalar/ScalarAttribute.hpp
index 4d30fe9..cd718c8 100644
--- a/expressions/scalar/ScalarAttribute.hpp
+++ b/expressions/scalar/ScalarAttribute.hpp
@@ -53,8 +53,10 @@ class ScalarAttribute : public Scalar {
    * @brief Constructor.
    *
    * @param attribute The attribute to use.
+   * @param join_side The join side of which this attribute belongs to.
    **/
-  explicit ScalarAttribute(const CatalogAttribute &attribute);
+  explicit ScalarAttribute(const CatalogAttribute &attribute,
+                           const JoinSide join_side = kNone);
 
   serialization::Scalar getProto() const override;
 
@@ -69,24 +71,18 @@ class ScalarAttribute : public Scalar {
 
   TypedValue getValueForJoinedTuples(
       const ValueAccessor &left_accessor,
-      const relation_id left_relation_id,
       const tuple_id left_tuple_id,
       const ValueAccessor &right_accessor,
-      const relation_id right_relation_id,
       const tuple_id right_tuple_id) const override;
 
   attribute_id getAttributeIdForValueAccessor() const override;
 
-  relation_id getRelationIdForValueAccessor() const override;
-
   ColumnVectorPtr getAllValues(ValueAccessor *accessor,
                                const SubBlocksReference *sub_blocks_ref,
                                ColumnVectorCache *cv_cache) const override;
 
   ColumnVectorPtr getAllValuesForJoin(
-      const relation_id left_relation_id,
       ValueAccessor *left_accessor,
-      const relation_id right_relation_id,
       ValueAccessor *right_accessor,
       const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids,
       ColumnVectorCache *cv_cache) const override;

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/8b7c3801/expressions/scalar/ScalarBinaryExpression.cpp
----------------------------------------------------------------------
diff --git a/expressions/scalar/ScalarBinaryExpression.cpp b/expressions/scalar/ScalarBinaryExpression.cpp
index b3568f8..ecbe84f 100644
--- a/expressions/scalar/ScalarBinaryExpression.cpp
+++ b/expressions/scalar/ScalarBinaryExpression.cpp
@@ -79,26 +79,20 @@ TypedValue ScalarBinaryExpression::getValueForSingleTuple(const ValueAccessor &a
 
 TypedValue ScalarBinaryExpression::getValueForJoinedTuples(
     const ValueAccessor &left_accessor,
-    const relation_id left_relation_id,
     const tuple_id left_tuple_id,
     const ValueAccessor &right_accessor,
-    const relation_id right_relation_id,
     const tuple_id right_tuple_id) const {
   if (fast_operator_.get() == nullptr) {
     return static_value_.makeReferenceToThis();
   } else {
     return fast_operator_->applyToTypedValues(
         left_operand_->getValueForJoinedTuples(left_accessor,
-                                               left_relation_id,
                                                left_tuple_id,
                                                right_accessor,
-                                               right_relation_id,
                                                right_tuple_id),
         right_operand_->getValueForJoinedTuples(left_accessor,
-                                                left_relation_id,
                                                 left_tuple_id,
                                                 right_accessor,
-                                                right_relation_id,
                                                 right_tuple_id));
   }
 }
@@ -199,9 +193,7 @@ ColumnVectorPtr ScalarBinaryExpression::getAllValues(
 }
 
 ColumnVectorPtr ScalarBinaryExpression::getAllValuesForJoin(
-    const relation_id left_relation_id,
     ValueAccessor *left_accessor,
-    const relation_id right_relation_id,
     ValueAccessor *right_accessor,
     const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids,
     ColumnVectorCache *cv_cache) const {
@@ -216,12 +208,9 @@ ColumnVectorPtr ScalarBinaryExpression::getAllValuesForJoin(
       const attribute_id right_operand_attr_id
           = right_operand_->getAttributeIdForValueAccessor();
       if (right_operand_attr_id != -1) {
-        const relation_id right_operand_relation_id
-            = right_operand_->getRelationIdForValueAccessor();
-        DCHECK_NE(right_operand_relation_id, -1);
-        DCHECK((right_operand_relation_id == left_relation_id)
-               || (right_operand_relation_id == right_relation_id));
-        const bool using_left_relation = (right_operand_relation_id == left_relation_id);
+        const JoinSide join_side = right_operand_->join_side();
+        DCHECK(join_side != kNone);
+        const bool using_left_relation = (join_side == kLeftSide);
         ValueAccessor *right_operand_accessor = using_left_relation ? left_accessor
                                                                     : right_accessor;
         return ColumnVectorPtr(
@@ -235,9 +224,7 @@ ColumnVectorPtr ScalarBinaryExpression::getAllValuesForJoin(
 #endif  // QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_JOIN
 
       ColumnVectorPtr right_result(
-          right_operand_->getAllValuesForJoin(left_relation_id,
-                                              left_accessor,
-                                              right_relation_id,
+          right_operand_->getAllValuesForJoin(left_accessor,
                                               right_accessor,
                                               joined_tuple_ids,
                                               cv_cache));
@@ -250,12 +237,9 @@ ColumnVectorPtr ScalarBinaryExpression::getAllValuesForJoin(
       const attribute_id left_operand_attr_id
           = left_operand_->getAttributeIdForValueAccessor();
       if (left_operand_attr_id != -1) {
-        const relation_id left_operand_relation_id
-            = left_operand_->getRelationIdForValueAccessor();
-        DCHECK_NE(left_operand_relation_id, -1);
-        DCHECK((left_operand_relation_id == left_relation_id)
-               || (left_operand_relation_id == right_relation_id));
-        const bool using_left_relation = (left_operand_relation_id == left_relation_id);
+        const JoinSide join_side = left_operand_->join_side();
+        DCHECK(join_side != kNone);
+        const bool using_left_relation = (join_side == kLeftSide);
         ValueAccessor *left_operand_accessor = using_left_relation ? left_accessor
                                                                    : right_accessor;
         return ColumnVectorPtr(
@@ -269,9 +253,7 @@ ColumnVectorPtr ScalarBinaryExpression::getAllValuesForJoin(
 #endif  // QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_JOIN
 
       ColumnVectorPtr left_result(
-          left_operand_->getAllValuesForJoin(left_relation_id,
-                                             left_accessor,
-                                             right_relation_id,
+          left_operand_->getAllValuesForJoin(left_accessor,
                                              right_accessor,
                                              joined_tuple_ids,
                                              cv_cache));
@@ -286,25 +268,17 @@ ColumnVectorPtr ScalarBinaryExpression::getAllValuesForJoin(
       const attribute_id right_operand_attr_id
           = right_operand_->getAttributeIdForValueAccessor();
       if (left_operand_attr_id != -1) {
-        const relation_id left_operand_relation_id
-            = left_operand_->getRelationIdForValueAccessor();
-        DCHECK_NE(left_operand_relation_id, -1);
-        DCHECK((left_operand_relation_id == left_relation_id)
-               || (left_operand_relation_id == right_relation_id));
-        const bool using_left_relation_for_left_operand
-            = (left_operand_relation_id == left_relation_id);
+        const JoinSide join_side = left_operand_->join_side();
+        DCHECK(join_side != kNone);
+        const bool using_left_relation_for_left_operand = (join_side == kLeftSide);
         ValueAccessor *left_operand_accessor = using_left_relation_for_left_operand ? left_accessor
                                                                                     : right_accessor;
 
 #ifdef QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_JOIN_WITH_BINARY_EXPRESSIONS
         if (right_operand_attr_id != -1) {
-          const relation_id right_operand_relation_id
-              = right_operand_->getRelationIdForValueAccessor();
-          DCHECK_NE(right_operand_relation_id, -1);
-          DCHECK((right_operand_relation_id == left_relation_id)
-                 || (right_operand_relation_id == right_relation_id));
-          const bool using_left_relation_for_right_operand
-              = (right_operand_relation_id == left_relation_id);
+          const JoinSide join_side = right_operand_->join_side();
+          DCHECK(join_side != kNone);
+          const bool using_left_relation_for_right_operand = (join_side == kLeftSide);
           ValueAccessor *right_operand_accessor = using_left_relation_for_right_operand ? left_accessor
                                                                                         : right_accessor;
           return ColumnVectorPtr(
@@ -318,9 +292,7 @@ ColumnVectorPtr ScalarBinaryExpression::getAllValuesForJoin(
         }
 #endif  // QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_JOIN_WITH_BINARY_EXPRESSIONS
         ColumnVectorPtr right_result(
-            right_operand_->getAllValuesForJoin(left_relation_id,
-                                                left_accessor,
-                                                right_relation_id,
+            right_operand_->getAllValuesForJoin(left_accessor,
                                                 right_accessor,
                                                 joined_tuple_ids,
                                                 cv_cache));
@@ -333,20 +305,14 @@ ColumnVectorPtr ScalarBinaryExpression::getAllValuesForJoin(
                 *right_result,
                 joined_tuple_ids));
       } else if (right_operand_attr_id != -1) {
-        const relation_id right_operand_relation_id
-            = right_operand_->getRelationIdForValueAccessor();
-        DCHECK_NE(right_operand_relation_id, -1);
-        DCHECK((right_operand_relation_id == left_relation_id)
-               || (right_operand_relation_id == right_relation_id));
-        const bool using_left_relation_for_right_operand
-            = (right_operand_relation_id == left_relation_id);
+        const JoinSide join_side = right_operand_->join_side();
+        DCHECK(join_side != kNone);
+        const bool using_left_relation_for_right_operand = (join_side == kLeftSide);
         ValueAccessor *right_operand_accessor = using_left_relation_for_right_operand ? left_accessor
                                                                                       : right_accessor;
 
         ColumnVectorPtr left_result(
-            left_operand_->getAllValuesForJoin(left_relation_id,
-                                               left_accessor,
-                                               right_relation_id,
+            left_operand_->getAllValuesForJoin(left_accessor,
                                                right_accessor,
                                                joined_tuple_ids,
                                                cv_cache));
@@ -361,16 +327,12 @@ ColumnVectorPtr ScalarBinaryExpression::getAllValuesForJoin(
 #endif  // QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_JOIN
 
       ColumnVectorPtr left_result(
-          left_operand_->getAllValuesForJoin(left_relation_id,
-                                             left_accessor,
-                                             right_relation_id,
+          left_operand_->getAllValuesForJoin(left_accessor,
                                              right_accessor,
                                              joined_tuple_ids,
                                              cv_cache));
       ColumnVectorPtr right_result(
-          right_operand_->getAllValuesForJoin(left_relation_id,
-                                              left_accessor,
-                                              right_relation_id,
+          right_operand_->getAllValuesForJoin(left_accessor,
                                               right_accessor,
                                               joined_tuple_ids,
                                               cv_cache));

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/8b7c3801/expressions/scalar/ScalarBinaryExpression.hpp
----------------------------------------------------------------------
diff --git a/expressions/scalar/ScalarBinaryExpression.hpp b/expressions/scalar/ScalarBinaryExpression.hpp
index 4ac1f62..6f9c41d 100644
--- a/expressions/scalar/ScalarBinaryExpression.hpp
+++ b/expressions/scalar/ScalarBinaryExpression.hpp
@@ -84,10 +84,8 @@ class ScalarBinaryExpression : public Scalar {
 
   TypedValue getValueForJoinedTuples(
       const ValueAccessor &left_accessor,
-      const relation_id left_relation_id,
       const tuple_id left_tuple_id,
       const ValueAccessor &right_accessor,
-      const relation_id right_relation_id,
       const tuple_id right_tuple_id) const override;
 
   bool hasStaticValue() const override {
@@ -104,9 +102,7 @@ class ScalarBinaryExpression : public Scalar {
                                ColumnVectorCache *cv_cache) const override;
 
   ColumnVectorPtr getAllValuesForJoin(
-      const relation_id left_relation_id,
       ValueAccessor *left_accessor,
-      const relation_id right_relation_id,
       ValueAccessor *right_accessor,
       const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids,
       ColumnVectorCache *cv_cache) const override;

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/8b7c3801/expressions/scalar/ScalarCaseExpression.cpp
----------------------------------------------------------------------
diff --git a/expressions/scalar/ScalarCaseExpression.cpp b/expressions/scalar/ScalarCaseExpression.cpp
index c2af83b..39e19c6 100644
--- a/expressions/scalar/ScalarCaseExpression.cpp
+++ b/expressions/scalar/ScalarCaseExpression.cpp
@@ -247,47 +247,27 @@ TypedValue ScalarCaseExpression::getValueForSingleTuple(
 
 TypedValue ScalarCaseExpression::getValueForJoinedTuples(
     const ValueAccessor &left_accessor,
-    const relation_id left_relation_id,
     const tuple_id left_tuple_id,
     const ValueAccessor &right_accessor,
-    const relation_id right_relation_id,
     const tuple_id right_tuple_id) const {
   if (has_static_value_) {
     return static_value_.makeReferenceToThis();
   } else if (fixed_result_expression_ != nullptr) {
-    return fixed_result_expression_->getValueForJoinedTuples(left_accessor,
-                                                             left_relation_id,
-                                                             left_tuple_id,
-                                                             right_accessor,
-                                                             right_relation_id,
-                                                             right_tuple_id);
+    return fixed_result_expression_->getValueForJoinedTuples(
+        left_accessor, left_tuple_id, right_accessor, right_tuple_id);
   }
 
   for (std::vector<std::unique_ptr<Predicate>>::size_type case_idx = 0;
        case_idx < when_predicates_.size();
        ++case_idx) {
-    if (when_predicates_[case_idx]->matchesForJoinedTuples(left_accessor,
-                                                           left_relation_id,
-                                                           left_tuple_id,
-                                                           right_accessor,
-                                                           right_relation_id,
-                                                           right_tuple_id)) {
+    if (when_predicates_[case_idx]->matchesForJoinedTuples(
+            left_accessor, left_tuple_id, right_accessor, right_tuple_id)) {
       return result_expressions_[case_idx]->getValueForJoinedTuples(
-          left_accessor,
-          left_relation_id,
-          left_tuple_id,
-          right_accessor,
-          right_relation_id,
-          right_tuple_id);
+          left_accessor, left_tuple_id, right_accessor, right_tuple_id);
     }
   }
   return else_result_expression_->getValueForJoinedTuples(
-      left_accessor,
-      left_relation_id,
-      left_tuple_id,
-      right_accessor,
-      right_relation_id,
-      right_tuple_id);
+      left_accessor, left_tuple_id, right_accessor, right_tuple_id);
 }
 
 ColumnVectorPtr ScalarCaseExpression::getAllValues(
@@ -370,9 +350,7 @@ ColumnVectorPtr ScalarCaseExpression::getAllValues(
 }
 
 ColumnVectorPtr ScalarCaseExpression::getAllValuesForJoin(
-    const relation_id left_relation_id,
     ValueAccessor *left_accessor,
-    const relation_id right_relation_id,
     ValueAccessor *right_accessor,
     const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids,
     ColumnVectorCache *cv_cache) const {
@@ -381,9 +359,7 @@ ColumnVectorPtr ScalarCaseExpression::getAllValuesForJoin(
         ColumnVector::MakeVectorOfValue(type_, static_value_, joined_tuple_ids.size()));
   } else if (fixed_result_expression_) {
     return fixed_result_expression_->getAllValuesForJoin(
-        left_relation_id, left_accessor,
-        right_relation_id, right_accessor,
-        joined_tuple_ids, cv_cache);
+        left_accessor, right_accessor, joined_tuple_ids, cv_cache);
   }
 
   // Slice 'joined_tuple_ids' apart by case.
@@ -418,13 +394,9 @@ ColumnVectorPtr ScalarCaseExpression::getAllValuesForJoin(
 
     const Predicate &case_predicate = *when_predicates_[case_idx];
     for (tuple_id pos : else_positions) {
-      const std::pair<tuple_id, tuple_id> check_pair = joined_tuple_ids[pos];
-      if (case_predicate.matchesForJoinedTuples(*left_accessor,
-                                                left_relation_id,
-                                                check_pair.first,
-                                                *right_accessor,
-                                                right_relation_id,
-                                                check_pair.second)) {
+      const std::pair<tuple_id, tuple_id> &check_pair = joined_tuple_ids[pos];
+      if (case_predicate.matchesForJoinedTuples(
+              *left_accessor, check_pair.first, *right_accessor, check_pair.second)) {
         current_case_positions->set(pos);
         current_case_matches.emplace_back(check_pair);
       }
@@ -439,12 +411,7 @@ ColumnVectorPtr ScalarCaseExpression::getAllValuesForJoin(
        case_idx < case_matches.size();
        ++case_idx) {
     case_results.emplace_back(result_expressions_[case_idx]->getAllValuesForJoin(
-        left_relation_id,
-        left_accessor,
-        right_relation_id,
-        right_accessor,
-        case_matches[case_idx],
-        cv_cache));
+        left_accessor, right_accessor, case_matches[case_idx], cv_cache));
   }
 
   ColumnVectorPtr else_results;
@@ -455,12 +422,7 @@ ColumnVectorPtr ScalarCaseExpression::getAllValuesForJoin(
     }
 
     else_results = else_result_expression_->getAllValuesForJoin(
-        left_relation_id,
-        left_accessor,
-        right_relation_id,
-        right_accessor,
-        else_matches,
-        cv_cache);
+        left_accessor, right_accessor, else_matches, cv_cache);
   }
 
   // Multiplex per-case results into a single ColumnVector with values in the

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/8b7c3801/expressions/scalar/ScalarCaseExpression.hpp
----------------------------------------------------------------------
diff --git a/expressions/scalar/ScalarCaseExpression.hpp b/expressions/scalar/ScalarCaseExpression.hpp
index 22acfa8..14a2666 100644
--- a/expressions/scalar/ScalarCaseExpression.hpp
+++ b/expressions/scalar/ScalarCaseExpression.hpp
@@ -101,10 +101,8 @@ class ScalarCaseExpression : public Scalar {
 
   TypedValue getValueForJoinedTuples(
       const ValueAccessor &left_accessor,
-      const relation_id left_relation_id,
       const tuple_id left_tuple_id,
       const ValueAccessor &right_accessor,
-      const relation_id right_relation_id,
       const tuple_id right_tuple_id) const override;
 
   bool hasStaticValue() const override {
@@ -129,9 +127,7 @@ class ScalarCaseExpression : public Scalar {
                                ColumnVectorCache *cv_cache) const override;
 
   ColumnVectorPtr getAllValuesForJoin(
-      const relation_id left_relation_id,
       ValueAccessor *left_accessor,
-      const relation_id right_relation_id,
       ValueAccessor *right_accessor,
       const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids,
       ColumnVectorCache *cv_cache) const override;

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/8b7c3801/expressions/scalar/ScalarLiteral.cpp
----------------------------------------------------------------------
diff --git a/expressions/scalar/ScalarLiteral.cpp b/expressions/scalar/ScalarLiteral.cpp
index 808953d..b5f5d17 100644
--- a/expressions/scalar/ScalarLiteral.cpp
+++ b/expressions/scalar/ScalarLiteral.cpp
@@ -59,9 +59,7 @@ ColumnVectorPtr ScalarLiteral::getAllValues(
 }
 
 ColumnVectorPtr ScalarLiteral::getAllValuesForJoin(
-    const relation_id left_relation_id,
     ValueAccessor *left_accessor,
-    const relation_id right_relation_id,
     ValueAccessor *right_accessor,
     const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids,
     ColumnVectorCache *cv_cache) const {

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/8b7c3801/expressions/scalar/ScalarLiteral.hpp
----------------------------------------------------------------------
diff --git a/expressions/scalar/ScalarLiteral.hpp b/expressions/scalar/ScalarLiteral.hpp
index 2a4c396..3b3b994 100644
--- a/expressions/scalar/ScalarLiteral.hpp
+++ b/expressions/scalar/ScalarLiteral.hpp
@@ -87,10 +87,8 @@ class ScalarLiteral : public Scalar {
 
   TypedValue getValueForJoinedTuples(
       const ValueAccessor &left_accessor,
-      const relation_id left_relation_id,
       const tuple_id left_tuple_id,
       const ValueAccessor &right_accessor,
-      const relation_id right_relation_id,
       const tuple_id right_tuple_id) const override {
     return internal_literal_.makeReferenceToThis();
   }
@@ -108,9 +106,7 @@ class ScalarLiteral : public Scalar {
                                ColumnVectorCache *cv_cache) const override;
 
   ColumnVectorPtr getAllValuesForJoin(
-      const relation_id left_relation_id,
       ValueAccessor *left_accessor,
-      const relation_id right_relation_id,
       ValueAccessor *right_accessor,
       const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids,
       ColumnVectorCache *cv_cache) const override;

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/8b7c3801/expressions/scalar/ScalarSharedExpression.cpp
----------------------------------------------------------------------
diff --git a/expressions/scalar/ScalarSharedExpression.cpp b/expressions/scalar/ScalarSharedExpression.cpp
index e301116..64bfb3f 100644
--- a/expressions/scalar/ScalarSharedExpression.cpp
+++ b/expressions/scalar/ScalarSharedExpression.cpp
@@ -55,16 +55,12 @@ TypedValue ScalarSharedExpression::getValueForSingleTuple(const ValueAccessor &a
 
 TypedValue ScalarSharedExpression::getValueForJoinedTuples(
     const ValueAccessor &left_accessor,
-    const relation_id left_relation_id,
     const tuple_id left_tuple_id,
     const ValueAccessor &right_accessor,
-    const relation_id right_relation_id,
     const tuple_id right_tuple_id) const {
   return operand_->getValueForJoinedTuples(left_accessor,
-                                           left_relation_id,
                                            left_tuple_id,
                                            right_accessor,
-                                           right_relation_id,
                                            right_tuple_id);
 }
 
@@ -87,16 +83,12 @@ ColumnVectorPtr ScalarSharedExpression::getAllValues(
 }
 
 ColumnVectorPtr ScalarSharedExpression::getAllValuesForJoin(
-    const relation_id left_relation_id,
     ValueAccessor *left_accessor,
-    const relation_id right_relation_id,
     ValueAccessor *right_accessor,
     const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids,
     ColumnVectorCache *cv_cache) const {
   if (cv_cache == nullptr) {
-    return operand_->getAllValuesForJoin(left_relation_id,
-                                         left_accessor,
-                                         right_relation_id,
+    return operand_->getAllValuesForJoin(left_accessor,
                                          right_accessor,
                                          joined_tuple_ids,
                                          cv_cache);
@@ -106,9 +98,7 @@ ColumnVectorPtr ScalarSharedExpression::getAllValuesForJoin(
   if (cv_cache->contains(share_id_)) {
     result = cv_cache->get(share_id_);
   } else {
-    result = operand_->getAllValuesForJoin(left_relation_id,
-                                           left_accessor,
-                                           right_relation_id,
+    result = operand_->getAllValuesForJoin(left_accessor,
                                            right_accessor,
                                            joined_tuple_ids,
                                            cv_cache);

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/8b7c3801/expressions/scalar/ScalarSharedExpression.hpp
----------------------------------------------------------------------
diff --git a/expressions/scalar/ScalarSharedExpression.hpp b/expressions/scalar/ScalarSharedExpression.hpp
index f39c45b..ba9f32e 100644
--- a/expressions/scalar/ScalarSharedExpression.hpp
+++ b/expressions/scalar/ScalarSharedExpression.hpp
@@ -83,10 +83,8 @@ class ScalarSharedExpression : public Scalar {
 
   TypedValue getValueForJoinedTuples(
       const ValueAccessor &left_accessor,
-      const relation_id left_relation_id,
       const tuple_id left_tuple_id,
       const ValueAccessor &right_accessor,
-      const relation_id right_relation_id,
       const tuple_id right_tuple_id) const override;
 
   bool hasStaticValue() const override {
@@ -102,9 +100,7 @@ class ScalarSharedExpression : public Scalar {
                                ColumnVectorCache *cv_cache) const override;
 
   ColumnVectorPtr getAllValuesForJoin(
-      const relation_id left_relation_id,
       ValueAccessor *left_accessor,
-      const relation_id right_relation_id,
       ValueAccessor *right_accessor,
       const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids,
       ColumnVectorCache *cv_cache) const override;

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/8b7c3801/expressions/scalar/ScalarUnaryExpression.cpp
----------------------------------------------------------------------
diff --git a/expressions/scalar/ScalarUnaryExpression.cpp b/expressions/scalar/ScalarUnaryExpression.cpp
index c51e38f..be47d43 100644
--- a/expressions/scalar/ScalarUnaryExpression.cpp
+++ b/expressions/scalar/ScalarUnaryExpression.cpp
@@ -76,19 +76,15 @@ TypedValue ScalarUnaryExpression::getValueForSingleTuple(const ValueAccessor &ac
 
 TypedValue ScalarUnaryExpression::getValueForJoinedTuples(
     const ValueAccessor &left_accessor,
-    const relation_id left_relation_id,
     const tuple_id left_tuple_id,
     const ValueAccessor &right_accessor,
-    const relation_id right_relation_id,
     const tuple_id right_tuple_id) const {
   if (fast_operator_.get() == nullptr) {
     return static_value_.makeReferenceToThis();
   } else {
     return fast_operator_->applyToTypedValue(operand_->getValueForJoinedTuples(left_accessor,
-                                                                               left_relation_id,
                                                                                left_tuple_id,
                                                                                right_accessor,
-                                                                               right_relation_id,
                                                                                right_tuple_id));
   }
 }
@@ -119,9 +115,7 @@ ColumnVectorPtr ScalarUnaryExpression::getAllValues(
 }
 
 ColumnVectorPtr ScalarUnaryExpression::getAllValuesForJoin(
-    const relation_id left_relation_id,
     ValueAccessor *left_accessor,
-    const relation_id right_relation_id,
     ValueAccessor *right_accessor,
     const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids,
     ColumnVectorCache *cv_cache) const {
@@ -134,11 +128,9 @@ ColumnVectorPtr ScalarUnaryExpression::getAllValuesForJoin(
 #ifdef QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_JOIN
     const attribute_id operand_attr_id = operand_->getAttributeIdForValueAccessor();
     if (operand_attr_id != -1) {
-      const relation_id operand_relation_id = operand_->getRelationIdForValueAccessor();
-      DCHECK_NE(operand_relation_id, -1);
-      DCHECK((operand_relation_id == left_relation_id)
-             || (operand_relation_id == right_relation_id));
-      const bool using_left_relation = (operand_relation_id == left_relation_id);
+      const JoinSide join_side = operand_->join_side();
+      DCHECK(join_side != kNone);
+      const bool using_left_relation = (join_side == kLeftSide);
       ValueAccessor *operand_accessor = using_left_relation ? left_accessor
                                                             : right_accessor;
       return ColumnVectorPtr(
@@ -150,9 +142,7 @@ ColumnVectorPtr ScalarUnaryExpression::getAllValuesForJoin(
 #endif  // QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_JOIN
 
     ColumnVectorPtr operand_result(
-        operand_->getAllValuesForJoin(left_relation_id,
-                                      left_accessor,
-                                      right_relation_id,
+        operand_->getAllValuesForJoin(left_accessor,
                                       right_accessor,
                                       joined_tuple_ids,
                                       cv_cache));

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/8b7c3801/expressions/scalar/ScalarUnaryExpression.hpp
----------------------------------------------------------------------
diff --git a/expressions/scalar/ScalarUnaryExpression.hpp b/expressions/scalar/ScalarUnaryExpression.hpp
index 52edea7..a628bd0 100644
--- a/expressions/scalar/ScalarUnaryExpression.hpp
+++ b/expressions/scalar/ScalarUnaryExpression.hpp
@@ -79,10 +79,8 @@ class ScalarUnaryExpression : public Scalar {
 
   TypedValue getValueForJoinedTuples(
       const ValueAccessor &left_accessor,
-      const relation_id left_relation_id,
       const tuple_id left_tuple_id,
       const ValueAccessor &right_accessor,
-      const relation_id right_relation_id,
       const tuple_id right_tuple_id) const override;
 
   bool hasStaticValue() const override {
@@ -99,9 +97,7 @@ class ScalarUnaryExpression : public Scalar {
                                ColumnVectorCache *cv_cache) const override;
 
   ColumnVectorPtr getAllValuesForJoin(
-      const relation_id left_relation_id,
       ValueAccessor *left_accessor,
-      const relation_id right_relation_id,
       ValueAccessor *right_accessor,
       const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids,
       ColumnVectorCache *cv_cache) const override;

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/8b7c3801/expressions/scalar/tests/ScalarCaseExpression_unittest.cpp
----------------------------------------------------------------------
diff --git a/expressions/scalar/tests/ScalarCaseExpression_unittest.cpp b/expressions/scalar/tests/ScalarCaseExpression_unittest.cpp
index f385b74..b9b2b38 100644
--- a/expressions/scalar/tests/ScalarCaseExpression_unittest.cpp
+++ b/expressions/scalar/tests/ScalarCaseExpression_unittest.cpp
@@ -916,8 +916,8 @@ TEST_F(ScalarCaseExpressionTest, JoinStaticBranchConstantTest) {
       new ScalarLiteral(TypedValue(static_cast<int>(2)), int_type)));
   result_expressions.emplace_back(new ScalarBinaryExpression(
       BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kAdd),
-      new ScalarAttribute(*sample_relation_->getAttributeById(0)),
-      new ScalarAttribute(*other_relation.getAttributeById(1))));
+      new ScalarAttribute(*sample_relation_->getAttributeById(0), Scalar::kLeftSide),
+      new ScalarAttribute(*other_relation.getAttributeById(1), Scalar::kRightSide)));
 
   const int kConstant = 72;
   // WHEN 1 < 2 THEN kConstant
@@ -931,8 +931,8 @@ TEST_F(ScalarCaseExpressionTest, JoinStaticBranchConstantTest) {
   // WHEN double_attr = other_double THEN 0
   when_predicates.emplace_back(new ComparisonPredicate(
       ComparisonFactory::GetComparison(ComparisonID::kEqual),
-      new ScalarAttribute(*sample_relation_->getAttributeById(1)),
-      new ScalarAttribute(*other_relation.getAttributeById(0))));
+      new ScalarAttribute(*sample_relation_->getAttributeById(1), Scalar::kLeftSide),
+      new ScalarAttribute(*other_relation.getAttributeById(0), Scalar::kRightSide)));
   result_expressions.emplace_back(new ScalarLiteral(TypedValue(0), TypeFactory::GetType(kInt)));
 
   const Type &int_nullable_type = TypeFactory::GetType(kInt, true);
@@ -947,14 +947,13 @@ TEST_F(ScalarCaseExpressionTest, JoinStaticBranchConstantTest) {
   // Create a list of joined tuple-id pairs (just the cross-product of tuples).
   std::vector<std::pair<tuple_id, tuple_id>> joined_tuple_ids;
   for (std::size_t tuple_num = 0; tuple_num < kNumSampleTuples; ++tuple_num) {
+    // <LeftSide-tid, RightSide-tid>.
     joined_tuple_ids.emplace_back(tuple_num, 0);
     joined_tuple_ids.emplace_back(tuple_num, 1);
   }
 
   ColumnVectorPtr result_cv(case_expr.getAllValuesForJoin(
-      0,
       &sample_data_value_accessor_,
-      1,
       &other_accessor,
       joined_tuple_ids,
       nullptr /* cv_cache */));
@@ -1012,8 +1011,8 @@ TEST_F(ScalarCaseExpressionTest, JoinStaticBranchOnScalarAttributeTest) {
       new ScalarLiteral(TypedValue(static_cast<int>(2)), int_type)));
   result_expressions.emplace_back(new ScalarBinaryExpression(
       BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kAdd),
-      new ScalarAttribute(*sample_relation_->getAttributeById(0)),
-      new ScalarAttribute(*other_relation.getAttributeById(1))));
+      new ScalarAttribute(*sample_relation_->getAttributeById(0), Scalar::kLeftSide),
+      new ScalarAttribute(*other_relation.getAttributeById(1), Scalar::kRightSide)));
 
   // WHEN 1 < 2 THEN int_attr
   when_predicates.emplace_back(new ComparisonPredicate(
@@ -1021,13 +1020,13 @@ TEST_F(ScalarCaseExpressionTest, JoinStaticBranchOnScalarAttributeTest) {
       new ScalarLiteral(TypedValue(static_cast<int>(1)), int_type),
       new ScalarLiteral(TypedValue(static_cast<int>(2)), int_type)));
   result_expressions.emplace_back(
-      new ScalarAttribute(*sample_relation_->getAttributeById(0)));
+      new ScalarAttribute(*sample_relation_->getAttributeById(0), Scalar::kLeftSide));
 
   // WHEN double_attr = other_double THEN 0
   when_predicates.emplace_back(new ComparisonPredicate(
       ComparisonFactory::GetComparison(ComparisonID::kEqual),
-      new ScalarAttribute(*sample_relation_->getAttributeById(1)),
-      new ScalarAttribute(*other_relation.getAttributeById(0))));
+      new ScalarAttribute(*sample_relation_->getAttributeById(1), Scalar::kLeftSide),
+      new ScalarAttribute(*other_relation.getAttributeById(0), Scalar::kRightSide)));
   result_expressions.emplace_back(new ScalarLiteral(TypedValue(0), TypeFactory::GetType(kInt)));
 
   const Type &int_nullable_type = TypeFactory::GetType(kInt, true);
@@ -1042,14 +1041,13 @@ TEST_F(ScalarCaseExpressionTest, JoinStaticBranchOnScalarAttributeTest) {
   // Create a list of joined tuple-id pairs (just the cross-product of tuples).
   std::vector<std::pair<tuple_id, tuple_id>> joined_tuple_ids;
   for (std::size_t tuple_num = 0; tuple_num < kNumSampleTuples; ++tuple_num) {
+    // <LeftSide-tid, RightSide-tid>.
     joined_tuple_ids.emplace_back(tuple_num, 0);
     joined_tuple_ids.emplace_back(tuple_num, 1);
   }
 
   ColumnVectorPtr result_cv(case_expr.getAllValuesForJoin(
-      0,
       &sample_data_value_accessor_,
-      1,
       &other_accessor,
       joined_tuple_ids,
       nullptr /* cv_cache */));
@@ -1116,8 +1114,8 @@ TEST_F(ScalarCaseExpressionTest, JoinStaticBranchTest) {
       new ScalarLiteral(TypedValue(static_cast<int>(2)), int_type)));
   result_expressions.emplace_back(new ScalarBinaryExpression(
       BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kAdd),
-      new ScalarAttribute(*sample_relation_->getAttributeById(0)),
-      new ScalarAttribute(*other_relation.getAttributeById(1))));
+      new ScalarAttribute(*sample_relation_->getAttributeById(0), Scalar::kLeftSide),
+      new ScalarAttribute(*other_relation.getAttributeById(1), Scalar::kRightSide)));
 
   // WHEN 1 < 2 THEN int_attr * other_int
   when_predicates.emplace_back(new ComparisonPredicate(
@@ -1126,14 +1124,14 @@ TEST_F(ScalarCaseExpressionTest, JoinStaticBranchTest) {
       new ScalarLiteral(TypedValue(static_cast<int>(2)), int_type)));
   result_expressions.emplace_back(new ScalarBinaryExpression(
       BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kMultiply),
-      new ScalarAttribute(*sample_relation_->getAttributeById(0)),
-      new ScalarAttribute(*other_relation.getAttributeById(1))));
+      new ScalarAttribute(*sample_relation_->getAttributeById(0), Scalar::kLeftSide),
+      new ScalarAttribute(*other_relation.getAttributeById(1), Scalar::kRightSide)));
 
   // WHEN double_attr = other_double THEN 0
   when_predicates.emplace_back(new ComparisonPredicate(
       ComparisonFactory::GetComparison(ComparisonID::kEqual),
-      new ScalarAttribute(*sample_relation_->getAttributeById(1)),
-      new ScalarAttribute(*other_relation.getAttributeById(0))));
+      new ScalarAttribute(*sample_relation_->getAttributeById(1), Scalar::kLeftSide),
+      new ScalarAttribute(*other_relation.getAttributeById(0), Scalar::kRightSide)));
   result_expressions.emplace_back(new ScalarLiteral(TypedValue(0), TypeFactory::GetType(kInt)));
 
   const Type &int_nullable_type = TypeFactory::GetType(kInt, true);
@@ -1148,14 +1146,13 @@ TEST_F(ScalarCaseExpressionTest, JoinStaticBranchTest) {
   // Create a list of joined tuple-id pairs (just the cross-product of tuples).
   std::vector<std::pair<tuple_id, tuple_id>> joined_tuple_ids;
   for (std::size_t tuple_num = 0; tuple_num < kNumSampleTuples; ++tuple_num) {
+    // <LeftSide-tid, RightSide-tid>.
     joined_tuple_ids.emplace_back(tuple_num, 0);
     joined_tuple_ids.emplace_back(tuple_num, 1);
   }
 
   ColumnVectorPtr result_cv(case_expr.getAllValuesForJoin(
-      0,
       &sample_data_value_accessor_,
-      1,
       &other_accessor,
       joined_tuple_ids,
       nullptr /* cv_cache */));
@@ -1217,22 +1214,22 @@ TEST_F(ScalarCaseExpressionTest, JoinTest) {
   // WHEN double_attr > other_double THEN int_attr + other_int
   when_predicates.emplace_back(new ComparisonPredicate(
       ComparisonFactory::GetComparison(ComparisonID::kGreater),
-      new ScalarAttribute(*sample_relation_->getAttributeById(1)),
-      new ScalarAttribute(*other_relation.getAttributeById(0))));
+      new ScalarAttribute(*sample_relation_->getAttributeById(1), Scalar::kLeftSide),
+      new ScalarAttribute(*other_relation.getAttributeById(0), Scalar::kRightSide)));
   result_expressions.emplace_back(new ScalarBinaryExpression(
       BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kAdd),
-      new ScalarAttribute(*sample_relation_->getAttributeById(0)),
-      new ScalarAttribute(*other_relation.getAttributeById(1))));
+      new ScalarAttribute(*sample_relation_->getAttributeById(0), Scalar::kLeftSide),
+      new ScalarAttribute(*other_relation.getAttributeById(1), Scalar::kRightSide)));
 
   // WHEN double_attr < other_double THEN int_attr * other_int
   when_predicates.emplace_back(new ComparisonPredicate(
       ComparisonFactory::GetComparison(ComparisonID::kLess),
-      new ScalarAttribute(*sample_relation_->getAttributeById(1)),
-      new ScalarAttribute(*other_relation.getAttributeById(0))));
+      new ScalarAttribute(*sample_relation_->getAttributeById(1), Scalar::kLeftSide),
+      new ScalarAttribute(*other_relation.getAttributeById(0), Scalar::kRightSide)));
   result_expressions.emplace_back(new ScalarBinaryExpression(
       BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kMultiply),
-      new ScalarAttribute(*sample_relation_->getAttributeById(0)),
-      new ScalarAttribute(*other_relation.getAttributeById(1))));
+      new ScalarAttribute(*sample_relation_->getAttributeById(0), Scalar::kLeftSide),
+      new ScalarAttribute(*other_relation.getAttributeById(1), Scalar::kRightSide)));
 
   // ELSE 0
   ScalarCaseExpression case_expr(
@@ -1244,14 +1241,13 @@ TEST_F(ScalarCaseExpressionTest, JoinTest) {
   // Create a list of joined tuple-id pairs (just the cross-product of tuples).
   std::vector<std::pair<tuple_id, tuple_id>> joined_tuple_ids;
   for (std::size_t tuple_num = 0; tuple_num < kNumSampleTuples; ++tuple_num) {
+    // <LeftSide-tid, RightSide-tid>.
     joined_tuple_ids.emplace_back(tuple_num, 0);
     joined_tuple_ids.emplace_back(tuple_num, 1);
   }
 
   ColumnVectorPtr result_cv(case_expr.getAllValuesForJoin(
-      0,
       &sample_data_value_accessor_,
-      1,
       &other_accessor,
       joined_tuple_ids,
       nullptr /* cv_cache */));

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/8b7c3801/query_optimizer/ExecutionGenerator.cpp
----------------------------------------------------------------------
diff --git a/query_optimizer/ExecutionGenerator.cpp b/query_optimizer/ExecutionGenerator.cpp
index cc1319c..b413a97 100644
--- a/query_optimizer/ExecutionGenerator.cpp
+++ b/query_optimizer/ExecutionGenerator.cpp
@@ -29,16 +29,12 @@
 #include <string>
 #include <type_traits>
 #include <unordered_map>
-
-#include "query_optimizer/QueryOptimizerConfig.h"  // For QUICKSTEP_DISTRIBUTED.
-
-#ifdef QUICKSTEP_DISTRIBUTED
 #include <unordered_set>
-#endif
-
 #include <utility>
 #include <vector>
 
+#include "query_optimizer/QueryOptimizerConfig.h"  // For QUICKSTEP_DISTRIBUTED.
+
 #ifdef QUICKSTEP_DISTRIBUTED
 #include "catalog/Catalog.pb.h"
 #endif
@@ -72,6 +68,7 @@
 #include "query_optimizer/expressions/Alias.hpp"
 #include "query_optimizer/expressions/AttributeReference.hpp"
 #include "query_optimizer/expressions/ComparisonExpression.hpp"
+#include "query_optimizer/expressions/ExprId.hpp"
 #include "query_optimizer/expressions/ExpressionType.hpp"
 #include "query_optimizer/expressions/PatternMatcher.hpp"
 #include "query_optimizer/expressions/Scalar.hpp"
@@ -573,7 +570,9 @@ void ExecutionGenerator::dropAllTemporaryRelations() {
 
 void ExecutionGenerator::convertNamedExpressions(
     const std::vector<E::NamedExpressionPtr> &named_expressions,
-    S::QueryContext::ScalarGroup *scalar_group_proto) {
+    S::QueryContext::ScalarGroup *scalar_group_proto,
+    const std::unordered_set<E::ExprId> &left_expr_ids,
+    const std::unordered_set<E::ExprId> &right_expr_ids) {
   for (const E::NamedExpressionPtr &project_expression : named_expressions) {
     unique_ptr<const Scalar> execution_scalar;
     E::AliasPtr alias;
@@ -583,9 +582,11 @@ void ExecutionGenerator::convertNamedExpressions(
       // so all child expressions of an Alias should be a Scalar.
       CHECK(E::SomeScalar::MatchesWithConditionalCast(alias->expression(), &scalar))
           << alias->toString();
-      execution_scalar.reset(scalar->concretize(attribute_substitution_map_));
+      execution_scalar.reset(
+          scalar->concretize(attribute_substitution_map_, left_expr_ids, right_expr_ids));
     } else {
-      execution_scalar.reset(project_expression->concretize(attribute_substitution_map_));
+      execution_scalar.reset(
+          project_expression->concretize(attribute_substitution_map_, left_expr_ids, right_expr_ids));
     }
 
     scalar_group_proto->add_scalars()->MergeFrom(execution_scalar->getProto());
@@ -593,8 +594,10 @@ void ExecutionGenerator::convertNamedExpressions(
 }
 
 Predicate* ExecutionGenerator::convertPredicate(
-    const expressions::PredicatePtr &optimizer_predicate) const {
-  return optimizer_predicate->concretize(attribute_substitution_map_);
+    const expressions::PredicatePtr &optimizer_predicate,
+    const std::unordered_set<E::ExprId> &left_expr_ids,
+    const std::unordered_set<E::ExprId> &right_expr_ids) const {
+  return optimizer_predicate->concretize(attribute_substitution_map_, left_expr_ids, right_expr_ids);
 }
 
 void ExecutionGenerator::convertTableReference(
@@ -941,12 +944,27 @@ void ExecutionGenerator::convertHashJoin(const P::HashJoinPtr &physical_plan) {
     key_types.push_back(&left_attribute_type);
   }
 
+  std::unordered_set<E::ExprId> probe_expr_ids;
+  const auto probe_output_attributes = probe_physical->getOutputAttributes();
+  probe_expr_ids.reserve(probe_output_attributes.size());
+  for (const auto &probe_output_attribute : probe_output_attributes) {
+    probe_expr_ids.insert(probe_output_attribute->id());
+  }
+
+  std::unordered_set<E::ExprId> build_expr_ids;
+  const auto build_output_attributes = build_physical->getOutputAttributes();
+  build_expr_ids.reserve(build_output_attributes.size());
+  for (const auto &build_output_attribute : build_output_attributes) {
+    build_expr_ids.insert(build_output_attribute->id());
+  }
+
   // Convert the residual predicate proto.
   QueryContext::predicate_id residual_predicate_index = QueryContext::kInvalidPredicateId;
   if (physical_plan->residual_predicate()) {
     residual_predicate_index = query_context_proto_->predicates_size();
 
-    unique_ptr<const Predicate> residual_predicate(convertPredicate(physical_plan->residual_predicate()));
+    unique_ptr<const Predicate> residual_predicate(
+        convertPredicate(physical_plan->residual_predicate(), probe_expr_ids, build_expr_ids));
     query_context_proto_->add_predicates()->MergeFrom(residual_predicate->getProto());
   }
 
@@ -955,7 +973,8 @@ void ExecutionGenerator::convertHashJoin(const P::HashJoinPtr &physical_plan) {
   if (physical_plan->build_predicate()) {
     build_predicate_index = query_context_proto_->predicates_size();
 
-    unique_ptr<const Predicate> build_predicate(convertPredicate(physical_plan->build_predicate()));
+    unique_ptr<const Predicate> build_predicate(
+        convertPredicate(physical_plan->build_predicate(), probe_expr_ids, build_expr_ids));
     query_context_proto_->add_predicates()->MergeFrom(build_predicate->getProto());
   }
 
@@ -963,7 +982,7 @@ void ExecutionGenerator::convertHashJoin(const P::HashJoinPtr &physical_plan) {
   const QueryContext::scalar_group_id project_expressions_group_index =
       query_context_proto_->scalar_groups_size();
   convertNamedExpressions(physical_plan->project_expressions(),
-                          query_context_proto_->add_scalar_groups());
+                          query_context_proto_->add_scalar_groups(), probe_expr_ids, build_expr_ids);
 
   const CatalogRelationInfo *build_relation_info =
       findRelationInfoOutputByPhysical(build_physical);
@@ -979,19 +998,12 @@ void ExecutionGenerator::convertHashJoin(const P::HashJoinPtr &physical_plan) {
         new std::vector<bool>(
             E::MarkExpressionsReferingAnyAttribute(
                 physical_plan->project_expressions(),
-                build_physical->getOutputAttributes())));
+                build_output_attributes)));
   }
 
   const CatalogRelation *build_relation = build_relation_info->relation;
   const CatalogRelation *probe_relation = probe_relation_info->relation;
 
-  // FIXME(quickstep-team): Add support for self-join.
-  // We check to see if the build_predicate is null as certain queries that
-  // support hash-select fuse will result in the first check being true.
-  if (build_relation == probe_relation && physical_plan->build_predicate() == nullptr) {
-    THROW_SQL_ERROR() << "Self-join is not supported";
-  }
-
   // Create join hash table proto.
   const QueryContext::join_hash_table_id join_hash_table_index =
       query_context_proto_->join_hash_tables_size();
@@ -1129,10 +1141,28 @@ void ExecutionGenerator::convertNestedLoopsJoin(
     const P::NestedLoopsJoinPtr &physical_plan) {
   // NestedLoopsJoin is converted to a NestedLoopsJoin operator.
 
+  const P::PhysicalPtr &left_physical = physical_plan->left();
+  const P::PhysicalPtr &right_physical = physical_plan->right();
+
+  std::unordered_set<E::ExprId> left_expr_ids;
+  const auto left_output_attributes = left_physical->getOutputAttributes();
+  left_expr_ids.reserve(left_output_attributes.size());
+  for (const auto &left_output_attribute : left_output_attributes) {
+    left_expr_ids.insert(left_output_attribute->id());
+  }
+
+  std::unordered_set<E::ExprId> right_expr_ids;
+  const auto right_output_attributes = right_physical->getOutputAttributes();
+  right_expr_ids.reserve(right_output_attributes.size());
+  for (const auto &right_output_attribute : right_output_attributes) {
+    right_expr_ids.insert(right_output_attribute->id());
+  }
+
   // Convert the join predicate proto.
   const QueryContext::predicate_id execution_join_predicate_index = query_context_proto_->predicates_size();
   if (physical_plan->join_predicate()) {
-    unique_ptr<const Predicate> execution_join_predicate(convertPredicate(physical_plan->join_predicate()));
+    unique_ptr<const Predicate> execution_join_predicate(
+        convertPredicate(physical_plan->join_predicate(), left_expr_ids, right_expr_ids));
     query_context_proto_->add_predicates()->MergeFrom(execution_join_predicate->getProto());
   } else {
     query_context_proto_->add_predicates()->set_predicate_type(S::Predicate::TRUE);
@@ -1142,20 +1172,16 @@ void ExecutionGenerator::convertNestedLoopsJoin(
   const QueryContext::scalar_group_id project_expressions_group_index =
       query_context_proto_->scalar_groups_size();
   convertNamedExpressions(physical_plan->project_expressions(),
-                          query_context_proto_->add_scalar_groups());
+                          query_context_proto_->add_scalar_groups(),
+                          left_expr_ids, right_expr_ids);
 
   const CatalogRelationInfo *left_relation_info =
-      findRelationInfoOutputByPhysical(physical_plan->left());
+      findRelationInfoOutputByPhysical(left_physical);
   const CatalogRelation &left_relation = *left_relation_info->relation;
   const CatalogRelationInfo *right_relation_info =
-      findRelationInfoOutputByPhysical(physical_plan->right());
+      findRelationInfoOutputByPhysical(right_physical);
   const CatalogRelation &right_relation = *right_relation_info->relation;
 
-  // FIXME(quickstep-team): Add support for self-join.
-  if (left_relation.getID() == right_relation.getID()) {
-    THROW_SQL_ERROR() << "NestedLoopsJoin does not support self-join yet";
-  }
-
   const std::size_t num_partitions = left_relation.getNumPartitions();
 
 #ifdef QUICKSTEP_DEBUG

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/8b7c3801/query_optimizer/ExecutionGenerator.hpp
----------------------------------------------------------------------
diff --git a/query_optimizer/ExecutionGenerator.hpp b/query_optimizer/ExecutionGenerator.hpp
index bc9f88b..1385757 100644
--- a/query_optimizer/ExecutionGenerator.hpp
+++ b/query_optimizer/ExecutionGenerator.hpp
@@ -24,11 +24,7 @@
 #include <memory>
 #include <string>
 #include <unordered_map>
-
-#ifdef QUICKSTEP_DISTRIBUTED
 #include <unordered_set>
-#endif
-
 #include <vector>
 
 #include "catalog/CatalogTypedefs.hpp"
@@ -388,10 +384,16 @@ class ExecutionGenerator {
    * @param named_expressions The list of NamedExpressions to be converted.
    * @param scalar_group_proto The corresponding scalars proto in QueryContext
    *        proto.
+   * @param left_expr_ids The ExprIds from the left hand side.
+   * @param right_expr_ids The ExprIds from the right hand side.
    */
   void convertNamedExpressions(
       const std::vector<expressions::NamedExpressionPtr> &named_expressions,
-      serialization::QueryContext::ScalarGroup *scalar_group_proto);
+      serialization::QueryContext::ScalarGroup *scalar_group_proto,
+      const std::unordered_set<expressions::ExprId> &left_expr_ids =
+          std::unordered_set<expressions::ExprId>(),
+      const std::unordered_set<expressions::ExprId> &right_expr_ids =
+          std::unordered_set<expressions::ExprId>());
 
   /**
    * @brief Converts a Predicate in the optimizer expression system to a
@@ -399,9 +401,16 @@ class ExecutionGenerator {
    *        takes ownership of the returned pointer.
    *
    * @param optimizer_predicate The Predicate to be converted.
+   * @param left_expr_ids The ExprIds from the left hand side.
+   * @param right_expr_ids The ExprIds from the right hand side.
    * @return The corresponding Predicate in the execution expression system.
    */
-  Predicate* convertPredicate(const expressions::PredicatePtr &optimizer_predicate) const;
+  Predicate* convertPredicate(
+      const expressions::PredicatePtr &optimizer_predicate,
+      const std::unordered_set<expressions::ExprId> &left_expr_ids =
+          std::unordered_set<expressions::ExprId>(),
+      const std::unordered_set<expressions::ExprId> &right_expr_ids =
+          std::unordered_set<expressions::ExprId>()) const;
 
   /**
    * @brief Drops all temporary relations created by the generator

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/8b7c3801/query_optimizer/expressions/Alias.cpp
----------------------------------------------------------------------
diff --git a/query_optimizer/expressions/Alias.cpp b/query_optimizer/expressions/Alias.cpp
index f2b2795..0e3541d 100644
--- a/query_optimizer/expressions/Alias.cpp
+++ b/query_optimizer/expressions/Alias.cpp
@@ -21,6 +21,7 @@
 
 #include <string>
 #include <unordered_map>
+#include <unordered_set>
 #include <vector>
 
 #include "catalog/CatalogTypedefs.hpp"
@@ -65,7 +66,9 @@ ExpressionPtr Alias::copyWithNewChildren(
 }
 
 ::quickstep::Scalar *Alias::concretize(
-    const std::unordered_map<ExprId, const CatalogAttribute*> &substitution_map) const {
+    const std::unordered_map<ExprId, const CatalogAttribute*> &substitution_map,
+    const std::unordered_set<ExprId> &left_expr_ids,
+    const std::unordered_set<ExprId> &right_expr_ids) const {
   // Alias should be converted to a CatalogAttribute.
   LOG(FATAL) << "Cannot concretize Alias to a scalar for evaluation";
 }

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/8b7c3801/query_optimizer/expressions/Alias.hpp
----------------------------------------------------------------------
diff --git a/query_optimizer/expressions/Alias.hpp b/query_optimizer/expressions/Alias.hpp
index e0ee959..16d3715 100644
--- a/query_optimizer/expressions/Alias.hpp
+++ b/query_optimizer/expressions/Alias.hpp
@@ -23,6 +23,7 @@
 #include <memory>
 #include <string>
 #include <unordered_map>
+#include <unordered_set>
 #include <vector>
 
 #include "query_optimizer/OptimizerTree.hpp"
@@ -81,7 +82,9 @@ class Alias : public NamedExpression {
   }
 
   ::quickstep::Scalar *concretize(
-      const std::unordered_map<ExprId, const CatalogAttribute*> &substitution_map) const override;
+      const std::unordered_map<ExprId, const CatalogAttribute*> &substitution_map,
+      const std::unordered_set<ExprId> &left_expr_ids = std::unordered_set<ExprId>(),
+      const std::unordered_set<ExprId> &right_expr_ids = std::unordered_set<ExprId>()) const override;
 
   /**
    * @brief Creates an immutable Alias. If \p expression is also an Alias,

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/8b7c3801/query_optimizer/expressions/AttributeReference.cpp
----------------------------------------------------------------------
diff --git a/query_optimizer/expressions/AttributeReference.cpp b/query_optimizer/expressions/AttributeReference.cpp
index facfb39..86a1711 100644
--- a/query_optimizer/expressions/AttributeReference.cpp
+++ b/query_optimizer/expressions/AttributeReference.cpp
@@ -23,8 +23,10 @@
 #include <functional>
 #include <string>
 #include <unordered_map>
+#include <unordered_set>
 #include <vector>
 
+#include "expressions/scalar/Scalar.hpp"
 #include "expressions/scalar/ScalarAttribute.hpp"
 #include "query_optimizer/expressions/ExprId.hpp"
 #include "query_optimizer/expressions/Expression.hpp"
@@ -53,11 +55,22 @@ std::vector<AttributeReferencePtr> AttributeReference::getReferencedAttributes()
 }
 
 ::quickstep::Scalar *AttributeReference::concretize(
-    const std::unordered_map<ExprId, const CatalogAttribute*> &substitution_map) const {
+    const std::unordered_map<ExprId, const CatalogAttribute*> &substitution_map,
+    const std::unordered_set<ExprId> &left_expr_ids,
+    const std::unordered_set<ExprId> &right_expr_ids) const {
+  const ExprId expr_id = id();
   const std::unordered_map<ExprId, const CatalogAttribute*>::const_iterator found_it =
-      substitution_map.find(id());
+      substitution_map.find(expr_id);
   DCHECK(found_it != substitution_map.end()) << toString();
-  return new ::quickstep::ScalarAttribute(*found_it->second);
+
+  ::quickstep::Scalar::JoinSide join_side = ::quickstep::Scalar::kNone;
+  if (left_expr_ids.find(expr_id) != left_expr_ids.end()) {
+    join_side = ::quickstep::Scalar::kLeftSide;
+  } else if (right_expr_ids.find(expr_id) != right_expr_ids.end()) {
+    join_side = ::quickstep::Scalar::kRightSide;
+  }
+
+  return new ::quickstep::ScalarAttribute(*found_it->second, join_side);
 }
 
 std::size_t AttributeReference::computeHash() const {

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/8b7c3801/query_optimizer/expressions/AttributeReference.hpp
----------------------------------------------------------------------
diff --git a/query_optimizer/expressions/AttributeReference.hpp b/query_optimizer/expressions/AttributeReference.hpp
index ca796ba..0a8b855 100644
--- a/query_optimizer/expressions/AttributeReference.hpp
+++ b/query_optimizer/expressions/AttributeReference.hpp
@@ -24,6 +24,7 @@
 #include <memory>
 #include <string>
 #include <unordered_map>
+#include <unordered_set>
 #include <vector>
 
 #include "catalog/CatalogTypedefs.hpp"
@@ -88,7 +89,9 @@ class AttributeReference : public NamedExpression {
   std::vector<AttributeReferencePtr> getReferencedAttributes() const override;
 
   ::quickstep::Scalar* concretize(
-      const std::unordered_map<ExprId, const CatalogAttribute*> &substitution_map) const override;
+      const std::unordered_map<ExprId, const CatalogAttribute*> &substitution_map,
+      const std::unordered_set<ExprId> &left_expr_ids = std::unordered_set<ExprId>(),
+      const std::unordered_set<ExprId> &right_expr_ids = std::unordered_set<ExprId>()) const override;
 
   bool equals(const ScalarPtr &other) const override;
 



Mime
View raw message