duckdb 0.8.2-dev2700.0 → 0.8.2-dev2842.0

package/src/duckdb/src/main/relation/aggregate_relation.cpp

@@ -13,11 +13,28 @@ AggregateRelation::AggregateRelation(shared_ptr<Relation> child_p,
 	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
+AggregateRelation::AggregateRelation(shared_ptr<Relation> child_p,
+                                     vector<unique_ptr<ParsedExpression>> parsed_expressions, GroupByNode groups_p)
+    : Relation(child_p->context, RelationType::AGGREGATE_RELATION), expressions(std::move(parsed_expressions)),
+      groups(std::move(groups_p)), child(std::move(child_p)) {
+	// bind the expressions
+	context.GetContext()->TryBindRelation(*this, this->columns);
+}
+
 AggregateRelation::AggregateRelation(shared_ptr<Relation> child_p,
                                      vector<unique_ptr<ParsedExpression>> parsed_expressions,
                                      vector<unique_ptr<ParsedExpression>> groups_p)
     : Relation(child_p->context, RelationType::AGGREGATE_RELATION), expressions(std::move(parsed_expressions)),
-      groups(std::move(groups_p)), child(std::move(child_p)) {
+      child(std::move(child_p)) {
+	if (!groups_p.empty()) {
+		// explicit groups provided: use standard handling
+		GroupingSet grouping_set;
+		for (idx_t i = 0; i < groups_p.size(); i++) {
+			groups.group_expressions.push_back(std::move(groups_p[i]));
+			grouping_set.insert(i);
+		}
+		groups.grouping_sets.push_back(std::move(grouping_set));
+	}
 	// bind the expressions
 	context.GetContext()->TryBindRelation(*this, this->columns);
 }
@@ -39,16 +56,9 @@ unique_ptr<QueryNode> AggregateRelation::GetQueryNode() {
 	}
 	D_ASSERT(result->type == QueryNodeType::SELECT_NODE);
 	auto &select_node = result->Cast<SelectNode>();
-	if (!groups.empty()) {
-		// explicit groups provided: use standard handling
+	if (!groups.group_expressions.empty()) {
 		select_node.aggregate_handling = AggregateHandling::STANDARD_HANDLING;
-		select_node.groups.group_expressions.clear();
-		GroupingSet grouping_set;
-		for (idx_t i = 0; i < groups.size(); i++) {
-			select_node.groups.group_expressions.push_back(groups[i]->Copy());
-			grouping_set.insert(i);
-		}
-		select_node.groups.grouping_sets.push_back(std::move(grouping_set));
+		select_node.groups = groups.Copy();
 	} else {
 		// no groups provided: automatically figure out groups (if any)
 		select_node.aggregate_handling = AggregateHandling::FORCE_AGGREGATES;

package/src/duckdb/src/main/relation.cpp

@@ -169,7 +169,7 @@ shared_ptr<Relation> Relation::Aggregate(const string &aggregate_list) {
 
 shared_ptr<Relation> Relation::Aggregate(const string &aggregate_list, const string &group_list) {
 	auto expression_list = Parser::ParseExpressionList(aggregate_list, context.GetContext()->GetParserOptions());
-	auto groups = Parser::ParseExpressionList(group_list, context.GetContext()->GetParserOptions());
+	auto groups = Parser::ParseGroupByList(group_list, context.GetContext()->GetParserOptions());
 	return make_shared<AggregateRelation>(shared_from_this(), std::move(expression_list), std::move(groups));
 }
 
@@ -179,9 +179,9 @@ shared_ptr<Relation> Relation::Aggregate(const vector<string> &aggregates) {
 }
 
 shared_ptr<Relation> Relation::Aggregate(const vector<string> &aggregates, const vector<string> &groups) {
-	auto aggregate_list = StringListToExpressionList(*context.GetContext(), aggregates);
-	auto group_list = StringListToExpressionList(*context.GetContext(), groups);
-	return make_shared<AggregateRelation>(shared_from_this(), std::move(aggregate_list), std::move(group_list));
+	auto aggregate_list = StringUtil::Join(aggregates, ", ");
+	auto group_list = StringUtil::Join(groups, ", ");
+	return this->Aggregate(aggregate_list, group_list);
 }
 
 string Relation::GetAlias() {

package/src/duckdb/src/optimizer/join_order/cardinality_estimator.cpp

@@ -2,22 +2,15 @@
 #include "duckdb/optimizer/join_order/join_node.hpp"
 #include "duckdb/optimizer/join_order/join_order_optimizer.hpp"
 #include "duckdb/planner/filter/conjunction_filter.hpp"
-#include "duckdb/planner/filter/constant_filter.hpp"
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
 #include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/storage/data_table.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-
-#include <cmath>
+#include "duckdb/common/printer.hpp"
+#include "duckdb/common/limits.hpp"
 
 namespace duckdb {
 
-static optional_ptr<TableCatalogEntry> GetCatalogTableEntry(LogicalOperator &op) {
-	D_ASSERT(op.type == LogicalOperatorType::LOGICAL_GET);
-	auto &get = op.Cast<LogicalGet>();
-	return get.GetTable();
-}
-
 // The filter was made on top of a logical sample or other projection,
 // but no specific columns are referenced. See issue 4978 number 4.
 bool CardinalityEstimator::EmptyFilter(FilterInfo &filter_info) {
@@ -36,8 +29,11 @@ void CardinalityEstimator::AddRelationTdom(FilterInfo &filter_info) {
 			return;
 		}
 	}
+
 	auto key = ColumnBinding(filter_info.left_binding.table_index, filter_info.left_binding.column_index);
-	relations_to_tdoms.emplace_back(column_binding_set_t({key}));
+	RelationsToTDom new_r2tdom(column_binding_set_t({key}));
+
+	relations_to_tdoms.emplace_back(new_r2tdom);
 }
 
 bool CardinalityEstimator::SingleColumnFilter(FilterInfo &filter_info) {
@@ -72,13 +68,17 @@ vector<idx_t> CardinalityEstimator::DetermineMatchingEquivalentSets(FilterInfo *
 void CardinalityEstimator::AddToEquivalenceSets(FilterInfo *filter_info, vector<idx_t> matching_equivalent_sets) {
 	D_ASSERT(matching_equivalent_sets.size() <= 2);
 	if (matching_equivalent_sets.size() > 1) {
-		// an equivalence relation is connecting to sets of equivalence relations
+		// an equivalence relation is connecting two sets of equivalence relations
 		// so push all relations from the second set into the first. Later we will delete
 		// the second set.
 		for (ColumnBinding i : relations_to_tdoms.at(matching_equivalent_sets[1]).equivalent_relations) {
 			relations_to_tdoms.at(matching_equivalent_sets[0]).equivalent_relations.insert(i);
 		}
+		for (auto &column_name : relations_to_tdoms.at(matching_equivalent_sets[1]).column_names) {
+			relations_to_tdoms.at(matching_equivalent_sets[0]).column_names.push_back(column_name);
+		}
 		relations_to_tdoms.at(matching_equivalent_sets[1]).equivalent_relations.clear();
+		relations_to_tdoms.at(matching_equivalent_sets[1]).column_names.clear();
 		relations_to_tdoms.at(matching_equivalent_sets[0]).filters.push_back(filter_info);
 		// add all values of one set to the other, delete the empty one
 	} else if (matching_equivalent_sets.size() == 1) {
@@ -95,22 +95,7 @@ void CardinalityEstimator::AddToEquivalenceSets(FilterInfo *filter_info, vector<
 	}
 }
 
-void CardinalityEstimator::AddRelationToColumnMapping(ColumnBinding key, ColumnBinding value) {
-	relation_column_to_original_column[key] = value;
-}
-
-void CardinalityEstimator::CopyRelationMap(column_binding_map_t<ColumnBinding> &child_binding_map) {
-	for (auto &binding_map : relation_column_to_original_column) {
-		D_ASSERT(child_binding_map.find(binding_map.first) == child_binding_map.end());
-		child_binding_map[binding_map.first] = binding_map.second;
-	}
-}
-
-void CardinalityEstimator::AddColumnToRelationMap(idx_t table_index, idx_t column_index) {
-	relation_attributes[table_index].columns.insert(column_index);
-}
-
-void CardinalityEstimator::InitEquivalentRelations(vector<unique_ptr<FilterInfo>> &filter_infos) {
+void CardinalityEstimator::InitEquivalentRelations(const vector<unique_ptr<FilterInfo>> &filter_infos) {
 	// For each filter, we fill keep track of the index of the equivalent relation set
 	// the left and right relation needs to be added to.
 	for (auto &filter : filter_infos) {
@@ -128,46 +113,15 @@ void CardinalityEstimator::InitEquivalentRelations(vector<unique_ptr<FilterInfo>
 		auto matching_equivalent_sets = DetermineMatchingEquivalentSets(filter.get());
 		AddToEquivalenceSets(filter.get(), matching_equivalent_sets);
 	}
+	RemoveEmptyTotalDomains();
 }
 
-void CardinalityEstimator::VerifySymmetry(JoinNode &result, JoinNode &entry) {
-	if (result.GetCardinality<double>() != entry.GetCardinality<double>()) {
-		// Currently it's possible that some entries are cartesian joins.
-		// When this is the case, you don't always have symmetry, but
-		// if the cost of the result is less, then just assure the cardinality
-		// is also less, then you have the same effect of symmetry.
-		D_ASSERT(ceil(result.GetCardinality<double>()) <= ceil(entry.GetCardinality<double>()) ||
-		         floor(result.GetCardinality<double>()) <= floor(entry.GetCardinality<double>()));
-	}
-}
-
-void CardinalityEstimator::InitTotalDomains() {
+void CardinalityEstimator::RemoveEmptyTotalDomains() {
 	auto remove_start = std::remove_if(relations_to_tdoms.begin(), relations_to_tdoms.end(),
 	                                   [](RelationsToTDom &r_2_tdom) { return r_2_tdom.equivalent_relations.empty(); });
 	relations_to_tdoms.erase(remove_start, relations_to_tdoms.end());
 }
 
-double CardinalityEstimator::ComputeCost(JoinNode &left, JoinNode &right, double expected_cardinality) {
-	return expected_cardinality + left.GetCost() + right.GetCost();
-}
-
-double CardinalityEstimator::EstimateCrossProduct(const JoinNode &left, const JoinNode &right) {
-	// need to explicity use double here, otherwise auto converts it to an int, then
-	// there is an autocast in the return.
-	if (left.GetCardinality<double>() >= (NumericLimits<double>::Maximum() / right.GetCardinality<double>())) {
-		return NumericLimits<double>::Maximum();
-	}
-	return left.GetCardinality<double>() * right.GetCardinality<double>();
-}
-
-void CardinalityEstimator::AddRelationColumnMapping(LogicalGet &get, idx_t relation_id) {
-	for (idx_t it = 0; it < get.column_ids.size(); it++) {
-		auto key = ColumnBinding(relation_id, it);
-		auto value = ColumnBinding(get.table_index, get.column_ids[it]);
-		AddRelationToColumnMapping(key, value);
-	}
-}
-
 void UpdateDenom(Subgraph2Denominator &relation_2_denom, RelationsToTDom &relation_to_tdom) {
 	relation_2_denom.denom *= relation_to_tdom.has_tdom_hll ? relation_to_tdom.tdom_hll : relation_to_tdom.tdom_no_hll;
 }
@@ -187,13 +141,22 @@ void FindSubgraphMatchAndMerge(Subgraph2Denominator &merge_to, idx_t find_me,
 	}
 }
 
+template <>
 double CardinalityEstimator::EstimateCardinalityWithSet(JoinRelationSet &new_set) {
+
+	if (relation_set_2_cardinality.find(new_set.ToString()) != relation_set_2_cardinality.end()) {
+		return relation_set_2_cardinality[new_set.ToString()].cardinality_before_filters;
+	}
 	double numerator = 1;
 	unordered_set<idx_t> actual_set;
+
 	for (idx_t i = 0; i < new_set.count; i++) {
-		numerator *= relation_attributes[new_set.relations[i]].cardinality;
+		auto &single_node_set = set_manager.GetJoinRelation(new_set.relations[i]);
+		auto card_helper = relation_set_2_cardinality[single_node_set.ToString()];
+		numerator *= card_helper.cardinality_before_filters;
 		actual_set.insert(new_set.relations[i]);
 	}
+
 	vector<Subgraph2Denominator> subgraphs;
 	bool done = false;
 	bool found_match = false;
@@ -279,77 +242,26 @@ double CardinalityEstimator::EstimateCardinalityWithSet(JoinRelationSet &new_set
 	// TODO: It's possible cross-products were added and are not present in the filters in the relation_2_tdom
 	//       structures. When that's the case, multiply the denom structures that have no intersection
 	for (auto &match : subgraphs) {
-		// It's possible that in production, one of the D_ASSERTS above will fail and not all subgraphs
-		// were connected. When this happens, just use the largest denominator of all the subgraphs.
-		if (match.denom > denom) {
-			denom = match.denom;
-		}
+		denom *= match.denom;
 	}
 	// can happen if a table has cardinality 0, or a tdom is set to 0
 	if (denom == 0) {
 		denom = 1;
 	}
-	return numerator / denom;
+	auto result = numerator / denom;
+	auto new_entry = CardinalityHelper((double)result, 1);
+	relation_set_2_cardinality[new_set.ToString()] = new_entry;
+	return result;
 }
 
-static bool IsLogicalFilter(LogicalOperator &op) {
-	return op.type == LogicalOperatorType::LOGICAL_FILTER;
-}
-
-static optional_ptr<LogicalGet> GetLogicalGet(LogicalOperator &op, idx_t table_index = DConstants::INVALID_INDEX) {
-	optional_ptr<LogicalGet> get;
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_GET:
-		get = &op.Cast<LogicalGet>();
-		break;
-	case LogicalOperatorType::LOGICAL_FILTER:
-		get = GetLogicalGet(*op.children.at(0), table_index);
-		break;
-	case LogicalOperatorType::LOGICAL_PROJECTION:
-		get = GetLogicalGet(*op.children.at(0), table_index);
-		break;
-	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
-	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
-		auto &join = op.Cast<LogicalComparisonJoin>();
-		// We should never be calling GetLogicalGet without a valid table_index.
-		// We are attempting to get the catalog table for a relation (for statistics/cardinality estimation)
-		// A logical join means there is a non-reorderable relation in the join plan. This means we need
-		// to know the exact table index to return.
-		D_ASSERT(table_index != DConstants::INVALID_INDEX);
-		if (join.join_type == JoinType::MARK || join.join_type == JoinType::LEFT) {
-			auto &left_child = *join.children.at(0);
-			get = GetLogicalGet(left_child, table_index);
-			if (get && get->table_index == table_index) {
-				return get;
-			}
-			auto &right_child = *join.children.at(1);
-			get = GetLogicalGet(right_child, table_index);
-			if (get && get->table_index == table_index) {
-				return get;
-			}
-		}
-		break;
-	}
-	default:
-		// return null pointer, maybe there is no logical get under this child
-		break;
-	}
-	return get;
-}
-
-void CardinalityEstimator::MergeBindings(idx_t binding_index, idx_t relation_id,
-                                         vector<column_binding_map_t<ColumnBinding>> &child_binding_maps) {
-	for (auto &map_set : child_binding_maps) {
-		for (auto &mapping : map_set) {
-			ColumnBinding relation_bindings = mapping.first;
-			ColumnBinding actual_bindings = mapping.second;
-
-			if (actual_bindings.table_index == binding_index) {
-				auto key = ColumnBinding(relation_id, relation_bindings.column_index);
-				AddRelationToColumnMapping(key, actual_bindings);
-			}
-		}
+template <>
+idx_t CardinalityEstimator::EstimateCardinalityWithSet(JoinRelationSet &new_set) {
+	auto cardinality_as_double = EstimateCardinalityWithSet<double>(new_set);
+	auto max = NumericLimits<idx_t>::Maximum();
+	if (cardinality_as_double > max) {
+		return max;
 	}
+	return (idx_t)cardinality_as_double;
 }
 
 bool SortTdoms(const RelationsToTDom &a, const RelationsToTDom &b) {
@@ -365,236 +277,78 @@ bool SortTdoms(const RelationsToTDom &a, const RelationsToTDom &b) {
 	return a.tdom_no_hll > b.tdom_no_hll;
 }
 
-void CardinalityEstimator::InitCardinalityEstimatorProps(vector<NodeOp> &node_ops,
-                                                         vector<unique_ptr<FilterInfo>> &filter_infos) {
-	InitEquivalentRelations(filter_infos);
-	InitTotalDomains();
-	for (idx_t i = 0; i < node_ops.size(); i++) {
-		auto &join_node = *node_ops[i].node;
-		auto &op = node_ops[i].op;
-		join_node.SetBaseTableCardinality(op.EstimateCardinality(context));
-		if (op.type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
-			auto &join = op.Cast<LogicalComparisonJoin>();
-			if (join.join_type == JoinType::LEFT) {
-				// If a base op is a Logical Comparison join it is probably a left join,
-				// so the cost of the larger table is a fine estimate.
-				// TODO: provide better estimates for cost of mark joins
-				// MARK joins are used for anti and semi joins, so the cost can conceivably be
-				// less than the base table cardinality.
-				join_node.SetCost(join_node.GetBaseTableCardinality());
-			}
-		} else if (op.type == LogicalOperatorType::LOGICAL_ASOF_JOIN) {
-			// AsOf joins have the cardinality of the LHS
-			join_node.SetCost(join_node.GetBaseTableCardinality());
-		}
-		// Total domains can be affected by filters. So we update base table cardinality first
-		EstimateBaseTableCardinality(join_node, op);
-		// Then update total domains.
-		UpdateTotalDomains(join_node, op);
-	}
+void CardinalityEstimator::InitCardinalityEstimatorProps(optional_ptr<JoinRelationSet> set, RelationStats &stats) {
+	// Get the join relation set
+	D_ASSERT(stats.stats_initialized);
+	auto relation_cardinality = stats.cardinality;
+	auto relation_filter = stats.filter_strength;
+
+	auto card_helper = CardinalityHelper(relation_cardinality, relation_filter);
+	relation_set_2_cardinality[set->ToString()] = card_helper;
+
+	UpdateTotalDomains(set, stats);
 
 	// sort relations from greatest tdom to lowest tdom.
 	std::sort(relations_to_tdoms.begin(), relations_to_tdoms.end(), SortTdoms);
 }
 
-void CardinalityEstimator::UpdateTotalDomains(JoinNode &node, LogicalOperator &op) {
-	auto relation_id = node.set.relations[0];
-	relation_attributes[relation_id].cardinality = node.GetCardinality<double>();
+void CardinalityEstimator::UpdateTotalDomains(optional_ptr<JoinRelationSet> set, RelationStats &stats) {
+	D_ASSERT(set->count == 1);
+	auto relation_id = set->relations[0];
 	//! Initialize the distinct count for all columns used in joins with the current relation.
-	idx_t distinct_count = node.GetBaseTableCardinality();
-	optional_ptr<TableCatalogEntry> catalog_table;
+	//	D_ASSERT(stats.column_distinct_count.size() >= 1);
 
-	optional_ptr<LogicalGet> get;
-	bool get_updated = true;
-	for (auto &column : relation_attributes[relation_id].columns) {
+	for (idx_t i = 0; i < stats.column_distinct_count.size(); i++) {
 		//! for every column used in a filter in the relation, get the distinct count via HLL, or assume it to be
 		//! the cardinality
-		ColumnBinding key = ColumnBinding(relation_id, column);
-		auto actual_binding = relation_column_to_original_column.find(key);
-		// each relation has columns that are either projected or used as filters
-		// In order to get column statistics we need to make sure the actual binding still
-		// refers to the same base table relation, as non-reorderable joins may involve 2+
-		// base table relations and therefore the columns may also refer to 2 different
-		// base table relations
-		if (actual_binding != relation_column_to_original_column.end() &&
-		    (!get || get->table_index != actual_binding->second.table_index)) {
-			get = GetLogicalGet(op, actual_binding->second.table_index);
-			get_updated = true;
-		} else {
-			get_updated = false;
-		}
-
-		if (get_updated) {
-			if (get) {
-				catalog_table = GetCatalogTableEntry(*get);
-			} else {
-				catalog_table = nullptr;
-			}
-		}
-
-		if (catalog_table && actual_binding != relation_column_to_original_column.end()) {
-			// Get HLL stats here
-			auto base_stats = catalog_table->GetStatistics(context, actual_binding->second.column_index);
-			if (base_stats) {
-				distinct_count = base_stats->GetDistinctCount();
-			}
-
-			// HLL has estimation error, distinct_count can't be greater than cardinality of the table before filters
-			if (distinct_count > node.GetBaseTableCardinality()) {
-				distinct_count = node.GetBaseTableCardinality();
-			}
-		} else {
-			distinct_count = node.GetBaseTableCardinality();
-		}
 		// Update the relation_to_tdom set with the estimated distinct count (or tdom) calculated above
+		auto key = ColumnBinding(relation_id, i);
 		for (auto &relation_to_tdom : relations_to_tdoms) {
 			column_binding_set_t i_set = relation_to_tdom.equivalent_relations;
-			if (i_set.count(key) != 1) {
+			if (i_set.find(key) == i_set.end()) {
 				continue;
 			}
-			if (catalog_table) {
-				if (relation_to_tdom.tdom_hll < distinct_count) {
-					relation_to_tdom.tdom_hll = distinct_count;
-					relation_to_tdom.has_tdom_hll = true;
-				}
-				if (relation_to_tdom.tdom_no_hll > distinct_count) {
-					relation_to_tdom.tdom_no_hll = distinct_count;
-				}
+			auto distinct_count = stats.column_distinct_count.at(i);
+			if (distinct_count.from_hll && relation_to_tdom.has_tdom_hll) {
+				relation_to_tdom.tdom_hll = MaxValue(relation_to_tdom.tdom_hll, distinct_count.distinct_count);
+			} else if (distinct_count.from_hll && !relation_to_tdom.has_tdom_hll) {
+				relation_to_tdom.has_tdom_hll = true;
+				relation_to_tdom.tdom_hll = distinct_count.distinct_count;
 			} else {
-				// Here we don't have catalog statistics, and the following is how we determine
-				// the tdom
-				// 1. If there is any hll data in the equivalence set, use that
-				// 2. Otherwise, use the table with the smallest cardinality
-				if (relation_to_tdom.tdom_no_hll > distinct_count && !relation_to_tdom.has_tdom_hll) {
-					relation_to_tdom.tdom_no_hll = distinct_count;
-				}
+				relation_to_tdom.tdom_no_hll = MinValue(distinct_count.distinct_count, relation_to_tdom.tdom_no_hll);
 			}
 			break;
 		}
 	}
 }
 
-optional_ptr<TableFilterSet> CardinalityEstimator::GetTableFilters(LogicalOperator &op, idx_t table_index) {
-	auto get = GetLogicalGet(op, table_index);
-	return get ? &get->table_filters : nullptr;
-}
+// LCOV_EXCL_START
 
-idx_t CardinalityEstimator::InspectConjunctionAND(idx_t cardinality, idx_t column_index, ConjunctionAndFilter &filter,
-                                                  unique_ptr<BaseStatistics> base_stats) {
-	auto has_equality_filter = false;
-	auto cardinality_after_filters = cardinality;
-	for (auto &child_filter : filter.child_filters) {
-		if (child_filter->filter_type != TableFilterType::CONSTANT_COMPARISON) {
-			continue;
-		}
-		auto &comparison_filter = child_filter->Cast<ConstantFilter>();
-		if (comparison_filter.comparison_type != ExpressionType::COMPARE_EQUAL) {
-			continue;
-		}
-		auto column_count = 0;
-		if (base_stats) {
-			column_count = base_stats->GetDistinctCount();
-		}
-		auto filtered_card = cardinality;
-		// column_count = 0 when there is no column count (i.e parquet scans)
-		if (column_count > 0) {
-			// we want the ceil of cardinality/column_count. We also want to avoid compiler errors
-			filtered_card = (cardinality + column_count - 1) / column_count;
-			cardinality_after_filters = filtered_card;
-		}
-		if (has_equality_filter) {
-			cardinality_after_filters = MinValue(filtered_card, cardinality_after_filters);
-		}
-		has_equality_filter = true;
-	}
-	return cardinality_after_filters;
-}
-
-idx_t CardinalityEstimator::InspectConjunctionOR(idx_t cardinality, idx_t column_index, ConjunctionOrFilter &filter,
-                                                 unique_ptr<BaseStatistics> base_stats) {
-	auto has_equality_filter = false;
-	auto cardinality_after_filters = cardinality;
-	for (auto &child_filter : filter.child_filters) {
-		if (child_filter->filter_type != TableFilterType::CONSTANT_COMPARISON) {
-			continue;
-		}
-		auto &comparison_filter = child_filter->Cast<ConstantFilter>();
-		if (comparison_filter.comparison_type == ExpressionType::COMPARE_EQUAL) {
-			auto column_count = cardinality_after_filters;
-			if (base_stats) {
-				column_count = base_stats->GetDistinctCount();
-			}
-			auto increment = MaxValue<idx_t>(((cardinality + column_count - 1) / column_count), 1);
-			if (has_equality_filter) {
-				cardinality_after_filters += increment;
-			} else {
-				cardinality_after_filters = increment;
-			}
-			has_equality_filter = true;
+void CardinalityEstimator::AddRelationNamesToTdoms(vector<RelationStats> &stats) {
+#ifdef DEBUG
+	for (auto &total_domain : relations_to_tdoms) {
+		for (auto &binding : total_domain.equivalent_relations) {
+			D_ASSERT(binding.table_index < stats.size());
+			D_ASSERT(binding.column_index < stats.at(binding.table_index).column_names.size());
+			string column_name = stats.at(binding.table_index).column_names.at(binding.column_index);
+			total_domain.column_names.push_back(column_name);
 		}
 	}
-	D_ASSERT(cardinality_after_filters > 0);
-	return cardinality_after_filters;
+#endif
 }
 
-idx_t CardinalityEstimator::InspectTableFilters(idx_t cardinality, LogicalOperator &op, TableFilterSet &table_filters,
-                                                idx_t table_index) {
-	idx_t cardinality_after_filters = cardinality;
-	auto get = GetLogicalGet(op, table_index);
-	unique_ptr<BaseStatistics> column_statistics;
-	for (auto &it : table_filters.filters) {
-		column_statistics = nullptr;
-		if (get->bind_data && get->function.name.compare("seq_scan") == 0) {
-			auto &table_scan_bind_data = get->bind_data->Cast<TableScanBindData>();
-			column_statistics = get->function.statistics(context, &table_scan_bind_data, it.first);
-		}
-		if (it.second->filter_type == TableFilterType::CONJUNCTION_AND) {
-			auto &filter = it.second->Cast<ConjunctionAndFilter>();
-			idx_t cardinality_with_and_filter =
-			    InspectConjunctionAND(cardinality, it.first, filter, std::move(column_statistics));
-			cardinality_after_filters = MinValue(cardinality_after_filters, cardinality_with_and_filter);
-		} else if (it.second->filter_type == TableFilterType::CONJUNCTION_OR) {
-			auto &filter = it.second->Cast<ConjunctionOrFilter>();
-			idx_t cardinality_with_or_filter =
-			    InspectConjunctionOR(cardinality, it.first, filter, std::move(column_statistics));
-			cardinality_after_filters = MinValue(cardinality_after_filters, cardinality_with_or_filter);
+void CardinalityEstimator::PrintRelationToTdomInfo() {
+	for (auto &total_domain : relations_to_tdoms) {
+		string domain = "Following columns have the same distinct count: ";
+		for (auto &column_name : total_domain.column_names) {
+			domain += column_name + ", ";
 		}
+		bool have_hll = total_domain.has_tdom_hll;
+		domain += "\n TOTAL DOMAIN = " + to_string(have_hll ? total_domain.tdom_hll : total_domain.tdom_no_hll);
+		Printer::Print(domain);
 	}
-	// if the above code didn't find an equality filter (i.e country_code = "[us]")
-	// and there are other table filters, use default selectivity.
-	bool has_equality_filter = (cardinality_after_filters != cardinality);
-	if (!has_equality_filter && !table_filters.filters.empty()) {
-		cardinality_after_filters = MaxValue<idx_t>(cardinality * DEFAULT_SELECTIVITY, 1);
-	}
-	return cardinality_after_filters;
 }
 
-void CardinalityEstimator::EstimateBaseTableCardinality(JoinNode &node, LogicalOperator &op) {
-	auto has_logical_filter = IsLogicalFilter(op);
-	D_ASSERT(node.set.count == 1);
-	auto relation_id = node.set.relations[0];
-
-	double lowest_card_found = node.GetBaseTableCardinality();
-	for (auto &column : relation_attributes[relation_id].columns) {
-		auto card_after_filters = node.GetBaseTableCardinality();
-		ColumnBinding key = ColumnBinding(relation_id, column);
-		optional_ptr<TableFilterSet> table_filters;
-		auto actual_binding = relation_column_to_original_column.find(key);
-		if (actual_binding != relation_column_to_original_column.end()) {
-			table_filters = GetTableFilters(op, actual_binding->second.table_index);
-		}
-
-		if (table_filters) {
-			double inspect_result =
-			    (double)InspectTableFilters(card_after_filters, op, *table_filters, actual_binding->second.table_index);
-			card_after_filters = MinValue(inspect_result, (double)card_after_filters);
-		}
-		if (has_logical_filter) {
-			card_after_filters *= DEFAULT_SELECTIVITY;
-		}
-		lowest_card_found = MinValue(card_after_filters, lowest_card_found);
-	}
-	node.SetEstimatedCardinality(lowest_card_found);
-}
+// LCOV_EXCL_STOP
 
 } // namespace duckdb

package/src/duckdb/src/optimizer/join_order/cost_model.cpp

@@ -0,0 +1,19 @@
+#include "duckdb/optimizer/join_order/join_node.hpp"
+#include "duckdb/optimizer/join_order/join_order_optimizer.hpp"
+#include "duckdb/optimizer/join_order/cost_model.hpp"
+#include <cmath>
+
+namespace duckdb {
+
+CostModel::CostModel(QueryGraphManager &query_graph_manager)
+    : query_graph_manager(query_graph_manager), cardinality_estimator() {
+}
+
+double CostModel::ComputeCost(JoinNode &left, JoinNode &right) {
+	auto &combination = query_graph_manager.set_manager.Union(left.set, right.set);
+	auto join_card = cardinality_estimator.EstimateCardinalityWithSet<double>(combination);
+	auto join_cost = join_card;
+	return join_cost + left.cost + right.cost;
+}
+
+} // namespace duckdb