diff --git a/query_optimizer/rules/StarSchemaHashJoinOrderOptimization.cpp b/query_optimizer/rules/StarSchemaHashJoinOrderOptimization.cpp
index 1007dd5..78c0caf 100644
--- a/query_optimizer/rules/StarSchemaHashJoinOrderOptimization.cpp
+++ b/query_optimizer/rules/StarSchemaHashJoinOrderOptimization.cpp
@@ -30,6 +30,7 @@
 
 #include "query_optimizer/cost_model/StarSchemaSimpleCostModel.hpp"
 #include "query_optimizer/expressions/AttributeReference.hpp"
+#include "query_optimizer/expressions/ExprId.hpp"
 #include "query_optimizer/expressions/NamedExpression.hpp"
 #include "query_optimizer/expressions/PatternMatcher.hpp"
 #include "query_optimizer/physical/Aggregate.hpp"
@@ -68,7 +69,7 @@
     bool is_valid_cascading_hash_join = false;
     if (hash_join->residual_predicate() == nullptr) {
       is_valid_cascading_hash_join = true;
-      for (const E::NamedExpressionPtr expr : hash_join->project_expressions()) {
+      for (const E::NamedExpressionPtr &expr : hash_join->project_expressions()) {
         if (!E::SomeAttributeReference::Matches(expr)) {
           is_valid_cascading_hash_join = false;
           break;
@@ -95,8 +96,8 @@
 
     // Gather join attribute pairs.
     for (std::size_t i = 0; i < hash_join->left_join_attributes().size(); ++i) {
-      const std::size_t left_attr_id = hash_join->left_join_attributes()[i]->id();
-      const std::size_t right_attr_id = hash_join->right_join_attributes()[i]->id();
+      const E::ExprId left_attr_id = hash_join->left_join_attributes()[i]->id();
+      const E::ExprId right_attr_id = hash_join->right_join_attributes()[i]->id();
 
       join_group->join_attribute_pairs.emplace_back(left_attr_id, right_attr_id);
     }
@@ -150,7 +151,7 @@
 
   std::vector<TableInfo> table_info_storage;
   const std::vector<P::PhysicalPtr> &tables = join_group.tables;
-  for (std::size_t i = 0; i < join_group.tables.size(); ++i) {
+  for (std::size_t i = 0; i < tables.size(); ++i) {
     table_info_storage.emplace_back(
         i,
         tables[i],
@@ -279,16 +280,8 @@
     remaining_tables.erase(selected_probe_table_info);
     remaining_tables.erase(selected_build_table_info);
 
-    // Figure out the output attributes.
     const P::PhysicalPtr &probe_child = selected_probe_table_info->table;
     const P::PhysicalPtr &build_child = selected_build_table_info->table;
-    std::vector<E::NamedExpressionPtr> output_attributes;
-    for (const E::AttributeReferencePtr &probe_attr : probe_child->getOutputAttributes()) {
-      output_attributes.emplace_back(probe_attr);
-    }
-    for (const E::AttributeReferencePtr &build_attr : build_child->getOutputAttributes()) {
-      output_attributes.emplace_back(build_attr);
-    }
 
     // Figure out the join attributes.
     std::vector<E::AttributeReferencePtr> probe_attributes;
@@ -311,6 +304,19 @@
     // the table pool. Return the last table in the table pool if there is only
     // one table left.
     if (remaining_tables.size() > 0) {
+      const auto probe_output_attributes = probe_child->getOutputAttributes();
+      const auto build_output_attributes = build_child->getOutputAttributes();
+
+      // Figure out the output attributes.
+      std::vector<E::NamedExpressionPtr> output_attributes;
+      output_attributes.reserve(probe_output_attributes.size() + build_output_attributes.size());
+      for (const E::AttributeReferencePtr &probe_attr : probe_output_attributes) {
+        output_attributes.emplace_back(probe_attr);
+      }
+      for (const E::AttributeReferencePtr &build_attr : build_output_attributes) {
+        output_attributes.emplace_back(build_attr);
+      }
+
       P::PhysicalPtr output =
           P::HashJoin::Create(probe_child,
                               build_child,
diff --git a/query_optimizer/rules/StarSchemaHashJoinOrderOptimization.hpp b/query_optimizer/rules/StarSchemaHashJoinOrderOptimization.hpp
index 64e2478..4dc9397 100644
--- a/query_optimizer/rules/StarSchemaHashJoinOrderOptimization.hpp
+++ b/query_optimizer/rules/StarSchemaHashJoinOrderOptimization.hpp
@@ -109,15 +109,20 @@
 
     inline bool isBetterThan(const JoinPair &rhs) const {
       const auto &lhs = *this;
+      const TableInfo &lhs_probe = *(lhs.probe);
+      const TableInfo &lhs_build = *(lhs.build);
+
+      const TableInfo &rhs_probe = *(rhs.probe);
+      const TableInfo &rhs_build = *(rhs.build);
 
       // Avoid carrying too many output attributes all the way through a long
       // chain of hash joins.
       const bool lhs_has_large_output =
-          lhs.build->estimated_num_output_attributes
-              + lhs.probe->estimated_num_output_attributes > 5;
+          lhs_build.estimated_num_output_attributes
+              + lhs_probe.estimated_num_output_attributes > 5;
       const bool rhs_has_large_output =
-          rhs.build->estimated_num_output_attributes
-              + rhs.probe->estimated_num_output_attributes > 5;
+          rhs_build.estimated_num_output_attributes
+              + rhs_probe.estimated_num_output_attributes > 5;
       if (lhs_has_large_output != rhs_has_large_output) {
         return rhs_has_large_output;
       }
@@ -127,33 +132,43 @@
         return lhs.build_side_unique;
       }
 
+      // Prefer hash joins where the build side table has no output attributes.
+      const bool lhs_build_has_no_output = lhs_build.estimated_num_output_attributes == 0u;
+      const bool rhs_build_has_no_output = rhs_build.estimated_num_output_attributes == 0u;
+      if (lhs_build_has_no_output != rhs_build_has_no_output) {
+        return lhs_build_has_no_output;
+      }
+
       // Prefer hash joins where the build side table is small.
-      const bool lhs_has_small_build = lhs.build->estimated_cardinality < 0x100;
-      const bool rhs_has_small_build = rhs.build->estimated_cardinality < 0x100;
+      const bool lhs_has_small_build = lhs_build.estimated_cardinality < 0x100;
+      const bool rhs_has_small_build = rhs_build.estimated_cardinality < 0x100;
       if (lhs_has_small_build != rhs_has_small_build) {
         return lhs_has_small_build;
       }
 
       // Prefer hash joins where the probe side table is small. This is effective
       // for TPCH style (snowflake schema) queries, with the help of LIPFilters.
-      if (lhs.probe->estimated_cardinality != rhs.probe->estimated_cardinality) {
-        return lhs.probe->estimated_cardinality < rhs.probe->estimated_cardinality;
+      if (lhs_probe.estimated_cardinality != rhs_probe.estimated_cardinality) {
+        return lhs_probe.estimated_cardinality < rhs_probe.estimated_cardinality;
       }
 
       // Prefer build side tables with better selectivity. This is effective
       // for SSB style queries.
-      if (lhs.build->estimated_selectivity != rhs.build->estimated_selectivity) {
-        return lhs.build->estimated_selectivity < rhs.build->estimated_selectivity;
+      if (lhs_build.estimated_selectivity != rhs_build.estimated_selectivity) {
+        return lhs_build.estimated_selectivity < rhs_build.estimated_selectivity;
       }
 
       // Residual rules that help provide a total order.
-      if (lhs.build->estimated_cardinality != rhs.build->estimated_cardinality) {
-        return lhs.build->estimated_cardinality < rhs.build->estimated_cardinality;
+      if (lhs_build.estimated_cardinality != rhs_build.estimated_cardinality) {
+        return lhs_build.estimated_cardinality < rhs_build.estimated_cardinality;
       }
-      if (lhs.probe->table != rhs.probe->table) {
-        return lhs.probe->table < rhs.probe->table;
+
+      const std::size_t lhs_probe_table_info_id = lhs_probe.table_info_id;
+      const std::size_t rhs_probe_table_info_id = rhs_probe.table_info_id;
+      if (lhs_probe_table_info_id != rhs_probe_table_info_id) {
+        return lhs_probe_table_info_id < rhs_probe_table_info_id;
       } else {
-        return lhs.build->table < rhs.build->table;
+        return lhs_build.table_info_id < rhs_build.table_info_id;
       }
     }