Merge branch 'main' into draftwindows

Author: pashandor789

axiom/optimizer/DerivedTable.cpp

@@ -30,11 +30,15 @@ PlanObjectCP singleTable(PlanObjectCP object) {
   return nullptr;
 }
 
-} // namespace
-
-void DerivedTable::addJoinEquality(ExprCP left, ExprCP right) {
+// Adds an equijoin edge between 'left' and 'right'.
+void addJoinEquality(ExprCP left, ExprCP right, JoinEdgeVector& joins) {
   auto leftTable = singleTable(left);
   auto rightTable = singleTable(right);
+
+  VELOX_CHECK_NOT_NULL(leftTable);
+  VELOX_CHECK_NOT_NULL(rightTable);
+  VELOX_CHECK(leftTable != rightTable);
+
   for (auto& join : joins) {
     if (join->leftTable() == leftTable && join->rightTable() == rightTable) {
       join->addEquality(left, right);
@@ -52,26 +56,20 @@ void DerivedTable::addJoinEquality(ExprCP left, ExprCP right) {
   joins.push_back(join);
 }
 
-namespace {
-
+// Set of pairs of column IDs. Each pair represents a join equality condition.
+// Pairs are canonicalized so that first ID is < second ID.
 using EdgeSet = folly::F14FastSet<std::pair<int32_t, int32_t>>;
 
-void addEdge(EdgeSet& edges, int32_t id1, int32_t id2) {
-  if (id1 > id2) {
-    edges.insert(std::pair<int32_t, int32_t>(id2, id1));
-  } else {
-    edges.insert(std::pair<int32_t, int32_t>(id1, id2));
+bool addEdge(EdgeSet& edges, PlanObjectCP left, PlanObjectCP right) {
+  if (left->id() == right->id()) {
+    return false;
   }
-}
 
-bool hasEdge(const EdgeSet& edges, int32_t id1, int32_t id2) {
-  if (id1 == id2) {
-    return true;
+  if (left->id() < right->id()) {
+    return edges.emplace(left->id(), right->id()).second;
+  } else {
+    return edges.emplace(right->id(), left->id()).second;
   }
-  auto it = edges.find(
-      id1 > id2 ? std::pair<int32_t, int32_t>(id2, id1)
-                : std::pair<int32_t, int32_t>(id1, id2));
-  return it != edges.end();
 }
 
 void fillJoins(
@@ -80,9 +78,8 @@ void fillJoins(
     EdgeSet& edges,
     DerivedTableP dt) {
   for (auto& other : equivalence.columns) {
-    if (!hasEdge(edges, column->id(), other->id())) {
-      addEdge(edges, column->id(), other->id());
-      dt->addJoinEquality(column->as<Column>(), other->as<Column>());
+    if (addEdge(edges, column, other)) {
+      addJoinEquality(column->as<Column>(), other->as<Column>(), dt->joins);
     }
   }
 }
@@ -96,7 +93,7 @@ void DerivedTable::addImpliedJoins() {
         const auto* leftKey = join->leftKeys()[i];
         const auto* rightKey = join->rightKeys()[i];
         if (leftKey->isColumn() && rightKey->isColumn()) {
-          addEdge(edges, leftKey->id(), rightKey->id());
+          addEdge(edges, leftKey, rightKey);
         }
       }
     }

axiom/optimizer/DerivedTable.h

@@ -156,16 +156,18 @@ struct DerivedTable : public PlanObject {
   // Write.
   WritePlanCP write{nullptr};
 
-  /// Adds an equijoin edge between 'left' and 'right'.
-  void addJoinEquality(ExprCP left, ExprCP right);
+  /// Moves suitable elements of 'conjuncts' into join edges or single
+  /// table filters. May be called repeatedly if enclosing dt's add
+  /// more conjuncts. May call itself recursively on component dts.
+  void distributeConjuncts();
+
+  /// Completes 'joins' with edges implied by column equivalences.
+  void addImpliedJoins();
 
   /// After 'joins' is filled in, links tables to their direct and
   /// equivalence-implied joins.
   void linkTablesToJoins();
 
-  /// Completes 'joins' with edges implied by column equivalences.
-  void addImpliedJoins();
-
   /// Extracts implied conjuncts and removes duplicates from
   /// 'conjuncts' and updates 'conjuncts'. Extracted conjuncts may
   /// allow extra pushdown or allow create join edges. May be called
@@ -229,11 +231,6 @@ struct DerivedTable : public PlanObject {
 
   void addJoinedBy(JoinEdgeP join);
 
-  /// Moves suitable elements of 'conjuncts' into join edges or single
-  /// table filters. May be called repeatedly if enclosing dt's add
-  /// more conjuncts. May call itself recursively on component dts.
-  void distributeConjuncts();
-
   /// Memoizes plans for 'this' and fills in 'distribution_'. Needed
   /// before adding 'this' as a join side because join sides must have
   /// a cardinality guess.

axiom/optimizer/JoinSample.cpp

@@ -130,13 +130,7 @@ std::shared_ptr<runner::Runner> prepareSampleRunner(
 
   auto columns = sampleColumns.toObjects<Column>();
   auto index = base->chooseLeafIndex()[0];
-  auto* scan = make<TableScan>(
-      nullptr,
-      TableScan::outputDistribution(base, index, columns),
-      base,
-      index,
-      index->table->cardinality,
-      columns);
+  auto* scan = make<TableScan>(base, index, columns);
 
   ExprVector hashes;
   hashes.reserve(keys.size());

axiom/optimizer/Optimization.cpp

@@ -982,11 +982,10 @@ void Optimization::joinByIndex(
     // The number of keys is the prefix that matches index order.
     lookupKeys.resize(info.lookupKeys.size());
     state.columns.unionSet(availableColumns(rightTable, index));
+
     auto c = state.downstreamColumns();
     c.intersect(state.columns);
-    for (auto& filter : rightTable->filter) {
-      c.unionSet(filter->columns());
-    }
+    c.unionColumns(rightTable->filter);
 
     auto* scan = make<TableScan>(
         newPartition,
@@ -1102,8 +1101,7 @@ void Optimization::joinByHash(
   auto buildKeys = precomputeBuild.toColumns(build.keys);
   buildInput = std::move(precomputeBuild).maybeProject();
 
-  auto* buildOp =
-      make<HashBuild>(buildInput, ++buildCounter_, build.keys, buildPlan);
+  auto* buildOp = make<HashBuild>(buildInput, build.keys, buildPlan);
   buildState.addCost(*buildOp);
 
   const auto joinType = build.leftJoinType();
@@ -1222,8 +1220,7 @@ void Optimization::joinByHashRight(
   auto buildKeys = precomputeBuild.toColumns(build.keys);
   buildInput = std::move(precomputeBuild).maybeProject();
 
-  auto* buildOp =
-      make<HashBuild>(buildInput, ++buildCounter_, build.keys, nullptr);
+  auto* buildOp = make<HashBuild>(buildInput, build.keys, nullptr);
   state.addCost(*buildOp);
 
   PlanObjectSet buildColumns;
@@ -1756,15 +1753,7 @@ void Optimization::makeJoins(PlanState& state) {
         state.placed.add(table);
         state.columns.unionObjects(columns);
 
-        auto distribution =
-            TableScan::outputDistribution(table, index, columns);
-        auto* scan = make<TableScan>(
-            nullptr,
-            std::move(distribution),
-            table,
-            index,
-            index->table->cardinality * table->filterSelectivity,
-            std::move(columns));
+        auto* scan = make<TableScan>(table, index, columns);
         state.addCost(*scan);
         makeJoins(scan, state);
       }

axiom/optimizer/Optimization.h

@@ -340,9 +340,6 @@ class Optimization {
   // Controls tracing.
   int32_t traceFlags_{0};
 
-  // Generates unique ids for build sides.
-  int32_t buildCounter_{0};
-
   bool cnamesInExpr_{true};
 
   ToGraph toGraph_;

axiom/optimizer/RelationOp.cpp

@@ -51,13 +51,6 @@ const auto& relTypeNames() {
 
 AXIOM_DEFINE_ENUM_NAME(RelType, relTypeNames)
 
-const Value& RelationOp::value(ExprCP expr) const {
-  // Compute new Value by applying restrictions from operators
-  // between the place Expr is first defined and the output of
-  // 'this'. Memoize the result in 'this'.
-  return expr->value();
-}
-
 namespace {
 template <typename T>
 std::string itemsToString(const T* items, size_t n) {
@@ -106,10 +99,25 @@ float orderPrefixDistance(
 
 } // namespace
 
+TableScan::TableScan(
+    BaseTableCP table,
+    ColumnGroupCP index,
+    const ColumnVector& columns)
+    : TableScan(
+          /*input=*/nullptr,
+          TableScan::outputDistribution(table, index, columns),
+          table,
+          index,
+          /*fanout=*/index->table->cardinality * table->filterSelectivity,
+          columns,
+          /*lookupKeys=*/{},
+          velox::core::JoinType::kInner,
+          /*joinFilter=*/{}) {}
+
 TableScan::TableScan(
     RelationOpPtr input,
     Distribution distribution,
-    const BaseTable* table,
+    BaseTableCP table,
     ColumnGroupCP index,
     float fanout,
     ColumnVector columns,
@@ -676,13 +684,8 @@ void Aggregation::accept(
   visitor.visit(*this, context);
 }
 
-HashBuild::HashBuild(
-    RelationOpPtr input,
-    int32_t id,
-    ExprVector keysVector,
-    PlanP plan)
+HashBuild::HashBuild(RelationOpPtr input, ExprVector keysVector, PlanP plan)
     : RelationOp{RelType::kHashBuild, std::move(input)},
-      buildId{id},
       keys{std::move(keysVector)},
       plan{plan} {
   cost_.inputCardinality = inputCardinality();