duckdb 0.7.2-dev314.0 → 0.7.2-dev3154.0

package/src/duckdb/src/optimizer/filter_pullup.cpp

@@ -14,6 +14,7 @@ unique_ptr<LogicalOperator> FilterPullup::Rewrite(unique_ptr<LogicalOperator> op
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
 	case LogicalOperatorType::LOGICAL_ANY_JOIN:
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
+	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
 		return PullupJoin(std::move(op));
 	case LogicalOperatorType::LOGICAL_INTERSECT:
 	case LogicalOperatorType::LOGICAL_EXCEPT:
@@ -31,8 +32,9 @@ unique_ptr<LogicalOperator> FilterPullup::Rewrite(unique_ptr<LogicalOperator> op
 
 unique_ptr<LogicalOperator> FilterPullup::PullupJoin(unique_ptr<LogicalOperator> op) {
 	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
-	         op->type == LogicalOperatorType::LOGICAL_ANY_JOIN || op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN);
-	auto &join = (LogicalJoin &)*op;
+	         op->type == LogicalOperatorType::LOGICAL_ASOF_JOIN || op->type == LogicalOperatorType::LOGICAL_ANY_JOIN ||
+	         op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN);
+	auto &join = op->Cast<LogicalJoin>();
 
 	switch (join.join_type) {
 	case JoinType::INNER:
@@ -49,7 +51,7 @@ unique_ptr<LogicalOperator> FilterPullup::PullupJoin(unique_ptr<LogicalOperator>
 }
 
 unique_ptr<LogicalOperator> FilterPullup::PullupInnerJoin(unique_ptr<LogicalOperator> op) {
-	D_ASSERT(((LogicalJoin &)*op).join_type == JoinType::INNER);
+	D_ASSERT(op->Cast<LogicalJoin>().join_type == JoinType::INNER);
 	if (op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
 		return op;
 	}
@@ -63,7 +65,7 @@ unique_ptr<LogicalOperator> FilterPullup::PullupCrossProduct(unique_ptr<LogicalO
 
 unique_ptr<LogicalOperator> FilterPullup::GeneratePullupFilter(unique_ptr<LogicalOperator> child,
                                                                vector<unique_ptr<Expression>> &expressions) {
-	unique_ptr<LogicalFilter> filter = make_unique<LogicalFilter>();
+	unique_ptr<LogicalFilter> filter = make_uniq<LogicalFilter>();
 	for (idx_t i = 0; i < expressions.size(); ++i) {
 		filter->expressions.push_back(std::move(expressions[i]));
 	}

package/src/duckdb/src/optimizer/filter_pushdown.cpp

@@ -23,6 +23,7 @@ unique_ptr<LogicalOperator> FilterPushdown::Rewrite(unique_ptr<LogicalOperator>
 		return PushdownCrossProduct(std::move(op));
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
 	case LogicalOperatorType::LOGICAL_ANY_JOIN:
+	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
 		return PushdownJoin(std::move(op));
 	case LogicalOperatorType::LOGICAL_PROJECTION:
@@ -48,8 +49,9 @@ unique_ptr<LogicalOperator> FilterPushdown::Rewrite(unique_ptr<LogicalOperator>
 
 unique_ptr<LogicalOperator> FilterPushdown::PushdownJoin(unique_ptr<LogicalOperator> op) {
 	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
-	         op->type == LogicalOperatorType::LOGICAL_ANY_JOIN || op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN);
-	auto &join = (LogicalJoin &)*op;
+	         op->type == LogicalOperatorType::LOGICAL_ASOF_JOIN || op->type == LogicalOperatorType::LOGICAL_ANY_JOIN ||
+	         op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN);
+	auto &join = op->Cast<LogicalJoin>();
 	unordered_set<idx_t> left_bindings, right_bindings;
 	LogicalJoin::GetTableReferences(*op->children[0], left_bindings);
 	LogicalJoin::GetTableReferences(*op->children[1], right_bindings);
@@ -98,25 +100,19 @@ void FilterPushdown::GenerateFilters() {
 		return;
 	}
 	combiner.GenerateFilters([&](unique_ptr<Expression> filter) {
-		auto f = make_unique<Filter>();
+		auto f = make_uniq<Filter>();
 		f->filter = std::move(filter);
 		f->ExtractBindings();
 		filters.push_back(std::move(f));
 	});
 }
 
-unique_ptr<LogicalOperator> FilterPushdown::FinishPushdown(unique_ptr<LogicalOperator> op) {
-	// unhandled type, first perform filter pushdown in its children
-	for (auto &child : op->children) {
-		FilterPushdown pushdown(optimizer);
-		child = pushdown.Rewrite(std::move(child));
-	}
-	// now push any existing filters
+unique_ptr<LogicalOperator> FilterPushdown::PushFinalFilters(unique_ptr<LogicalOperator> op) {
 	if (filters.empty()) {
 		// no filters to push
 		return op;
 	}
-	auto filter = make_unique<LogicalFilter>();
+	auto filter = make_uniq<LogicalFilter>();
 	for (auto &f : filters) {
 		filter->expressions.push_back(std::move(f->filter));
 	}
@@ -124,6 +120,16 @@ unique_ptr<LogicalOperator> FilterPushdown::FinishPushdown(unique_ptr<LogicalOpe
 	return std::move(filter);
 }
 
+unique_ptr<LogicalOperator> FilterPushdown::FinishPushdown(unique_ptr<LogicalOperator> op) {
+	// unhandled type, first perform filter pushdown in its children
+	for (auto &child : op->children) {
+		FilterPushdown pushdown(optimizer);
+		child = pushdown.Rewrite(std::move(child));
+	}
+	// now push any existing filters
+	return PushFinalFilters(std::move(op));
+}
+
 void FilterPushdown::Filter::ExtractBindings() {
 	bindings.clear();
 	LogicalJoin::GetExpressionBindings(*filter, bindings);

package/src/duckdb/src/optimizer/in_clause_rewriter.cpp

@@ -43,18 +43,18 @@ unique_ptr<Expression> InClauseRewriter::VisitReplace(BoundOperatorExpression &e
 		// only one child
 		// IN: turn into X = 1
 		// NOT IN: turn into X <> 1
-		return make_unique<BoundComparisonExpression>(is_regular_in ? ExpressionType::COMPARE_EQUAL
-		                                                            : ExpressionType::COMPARE_NOTEQUAL,
-		                                              std::move(expr.children[0]), std::move(expr.children[1]));
+		return make_uniq<BoundComparisonExpression>(is_regular_in ? ExpressionType::COMPARE_EQUAL
+		                                                          : ExpressionType::COMPARE_NOTEQUAL,
+		                                            std::move(expr.children[0]), std::move(expr.children[1]));
 	}
 	if (expr.children.size() < 6 || !all_scalar) {
 		// low amount of children or not all scalar
 		// IN: turn into (X = 1 OR X = 2 OR X = 3...)
 		// NOT IN: turn into (X <> 1 AND X <> 2 AND X <> 3 ...)
-		auto conjunction = make_unique<BoundConjunctionExpression>(is_regular_in ? ExpressionType::CONJUNCTION_OR
-		                                                                         : ExpressionType::CONJUNCTION_AND);
+		auto conjunction = make_uniq<BoundConjunctionExpression>(is_regular_in ? ExpressionType::CONJUNCTION_OR
+		                                                                       : ExpressionType::CONJUNCTION_AND);
 		for (idx_t i = 1; i < expr.children.size(); i++) {
-			conjunction->children.push_back(make_unique<BoundComparisonExpression>(
+			conjunction->children.push_back(make_uniq<BoundComparisonExpression>(
 			    is_regular_in ? ExpressionType::COMPARE_EQUAL : ExpressionType::COMPARE_NOTEQUAL,
 			    expr.children[0]->Copy(), std::move(expr.children[i])));
 		}
@@ -64,7 +64,7 @@ unique_ptr<Expression> InClauseRewriter::VisitReplace(BoundOperatorExpression &e
 	// generate a mark join that replaces this IN expression
 	// first generate a ColumnDataCollection from the set of expressions
 	vector<LogicalType> types = {in_type};
-	auto collection = make_unique<ColumnDataCollection>(context, types);
+	auto collection = make_uniq<ColumnDataCollection>(context, types);
 	ColumnDataAppendState append_state;
 	collection->InitializeAppend(append_state);
 
@@ -84,10 +84,10 @@ unique_ptr<Expression> InClauseRewriter::VisitReplace(BoundOperatorExpression &e
 	}
 	// now generate a ChunkGet that scans this collection
 	auto chunk_index = optimizer.binder.GenerateTableIndex();
-	auto chunk_scan = make_unique<LogicalColumnDataGet>(chunk_index, types, std::move(collection));
+	auto chunk_scan = make_uniq<LogicalColumnDataGet>(chunk_index, types, std::move(collection));
 
 	// then we generate the MARK join with the chunk scan on the RHS
-	auto join = make_unique<LogicalComparisonJoin>(JoinType::MARK);
+	auto join = make_uniq<LogicalComparisonJoin>(JoinType::MARK);
 	join->mark_index = chunk_index;
 	join->AddChild(std::move(root));
 	join->AddChild(std::move(chunk_scan));
@@ -95,17 +95,17 @@ unique_ptr<Expression> InClauseRewriter::VisitReplace(BoundOperatorExpression &e
 	JoinCondition cond;
 	cond.left = std::move(expr.children[0]);
 
-	cond.right = make_unique<BoundColumnRefExpression>(in_type, ColumnBinding(chunk_index, 0));
+	cond.right = make_uniq<BoundColumnRefExpression>(in_type, ColumnBinding(chunk_index, 0));
 	cond.comparison = ExpressionType::COMPARE_EQUAL;
 	join->conditions.push_back(std::move(cond));
 	root = std::move(join);
 
 	// we replace the original subquery with a BoundColumnRefExpression referring to the mark column
 	unique_ptr<Expression> result =
-	    make_unique<BoundColumnRefExpression>("IN (...)", LogicalType::BOOLEAN, ColumnBinding(chunk_index, 0));
+	    make_uniq<BoundColumnRefExpression>("IN (...)", LogicalType::BOOLEAN, ColumnBinding(chunk_index, 0));
 	if (!is_regular_in) {
 		// NOT IN: invert
-		auto invert = make_unique<BoundOperatorExpression>(ExpressionType::OPERATOR_NOT, LogicalType::BOOLEAN);
+		auto invert = make_uniq<BoundOperatorExpression>(ExpressionType::OPERATOR_NOT, LogicalType::BOOLEAN);
 		invert->children.push_back(std::move(result));
 		result = std::move(invert);
 	}

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

@@ -8,43 +8,40 @@
 #include "duckdb/storage/data_table.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 
+#include <cmath>
+
 namespace duckdb {
 
-static TableCatalogEntry *GetCatalogTableEntry(LogicalOperator *op) {
-	if (!op) {
-		return nullptr;
-	}
-	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_GET);
-	auto get = (LogicalGet *)op;
-	TableCatalogEntry *entry = get->GetTable();
-	return entry;
+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) {
-	if (!filter_info->left_set && !filter_info->right_set) {
+bool CardinalityEstimator::EmptyFilter(FilterInfo &filter_info) {
+	if (!filter_info.left_set && !filter_info.right_set) {
 		return true;
 	}
 	return false;
 }
 
-void CardinalityEstimator::AddRelationTdom(FilterInfo *filter_info) {
-	D_ASSERT(filter_info->set->count >= 1);
+void CardinalityEstimator::AddRelationTdom(FilterInfo &filter_info) {
+	D_ASSERT(filter_info.set.count >= 1);
 	for (const RelationsToTDom &r2tdom : relations_to_tdoms) {
 		auto &i_set = r2tdom.equivalent_relations;
-		if (i_set.find(filter_info->left_binding) != i_set.end()) {
+		if (i_set.find(filter_info.left_binding) != i_set.end()) {
 			// found an equivalent filter
 			return;
 		}
 	}
-	auto key = ColumnBinding(filter_info->left_binding.table_index, filter_info->left_binding.column_index);
-	column_binding_set_t tmp({key});
-	relations_to_tdoms.emplace_back(RelationsToTDom(tmp));
+	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}));
 }
 
-bool CardinalityEstimator::SingleColumnFilter(FilterInfo *filter_info) {
-	if (filter_info->left_set && filter_info->right_set) {
+bool CardinalityEstimator::SingleColumnFilter(FilterInfo &filter_info) {
+	if (filter_info.left_set && filter_info.right_set) {
 		// Both set
 		return false;
 	}
@@ -93,7 +90,7 @@ void CardinalityEstimator::AddToEquivalenceSets(FilterInfo *filter_info, vector<
 		column_binding_set_t tmp;
 		tmp.insert(filter_info->left_binding);
 		tmp.insert(filter_info->right_binding);
-		relations_to_tdoms.emplace_back(RelationsToTDom(tmp));
+		relations_to_tdoms.emplace_back(tmp);
 		relations_to_tdoms.back().filters.push_back(filter_info);
 	}
 }
@@ -104,6 +101,7 @@ void CardinalityEstimator::AddRelationToColumnMapping(ColumnBinding key, ColumnB
 
 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;
 	}
 }
@@ -112,16 +110,16 @@ void CardinalityEstimator::AddColumnToRelationMap(idx_t table_index, idx_t colum
 	relation_attributes[table_index].columns.insert(column_index);
 }
 
-void CardinalityEstimator::InitEquivalentRelations(vector<unique_ptr<FilterInfo>> *filter_infos) {
+void CardinalityEstimator::InitEquivalentRelations(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) {
-		if (SingleColumnFilter(filter.get())) {
+	for (auto &filter : filter_infos) {
+		if (SingleColumnFilter(*filter)) {
 			// Filter on one relation, (i.e string or range filter on a column).
 			// Grab the first relation and add it to  the equivalence_relations
-			AddRelationTdom(filter.get());
+			AddRelationTdom(*filter);
 			continue;
-		} else if (EmptyFilter(filter.get())) {
+		} else if (EmptyFilter(*filter)) {
 			continue;
 		}
 		D_ASSERT(filter->left_set->count >= 1);
@@ -132,14 +130,14 @@ void CardinalityEstimator::InitEquivalentRelations(vector<unique_ptr<FilterInfo>
 	}
 }
 
-void CardinalityEstimator::VerifySymmetry(JoinNode *result, JoinNode *entry) {
-	if (result->GetCardinality<double>() != entry->GetCardinality<double>()) {
+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>()));
+		D_ASSERT(ceil(result.GetCardinality<double>()) <= ceil(entry.GetCardinality<double>()) ||
+		         floor(result.GetCardinality<double>()) <= floor(entry.GetCardinality<double>()));
 	}
 }
 
@@ -149,29 +147,29 @@ void CardinalityEstimator::InitTotalDomains() {
 	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::ComputeCost(JoinNode &left, JoinNode &right, double expected_cardinality) {
+	return expected_cardinality + left.GetCost() + right.GetCost();
 }
 
-double CardinalityEstimator::EstimateCrossProduct(const JoinNode *left, const JoinNode *right) {
+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.
-	return left->GetCardinality<double>() >= (NumericLimits<double>::Maximum() / right->GetCardinality<double>())
-	           ? NumericLimits<double>::Maximum()
-	           : left->GetCardinality<double>() * right->GetCardinality<double>();
+	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++) {
+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]);
+		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;
+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;
 }
 
 void FindSubgraphMatchAndMerge(Subgraph2Denominator &merge_to, idx_t find_me,
@@ -189,12 +187,12 @@ void FindSubgraphMatchAndMerge(Subgraph2Denominator &merge_to, idx_t find_me,
 	}
 }
 
-double CardinalityEstimator::EstimateCardinalityWithSet(JoinRelationSet *new_set) {
+double CardinalityEstimator::EstimateCardinalityWithSet(JoinRelationSet &new_set) {
 	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;
-		actual_set.insert(new_set->relations[i]);
+	for (idx_t i = 0; i < new_set.count; i++) {
+		numerator *= relation_attributes[new_set.relations[i]].cardinality;
+		actual_set.insert(new_set.relations[i]);
 	}
 	vector<Subgraph2Denominator> subgraphs;
 	bool done = false;
@@ -251,7 +249,7 @@ double CardinalityEstimator::EstimateCardinalityWithSet(JoinRelationSet *new_set
 				// Now insert the right binding and update denominator with the
 				// tdom of the filter
 				it->relations.insert(find_table);
-				UpdateDenom(&(*it), &relation_2_tdom);
+				UpdateDenom(*it, relation_2_tdom);
 				found_match = true;
 				break;
 			}
@@ -259,17 +257,17 @@ double CardinalityEstimator::EstimateCardinalityWithSet(JoinRelationSet *new_set
 			// connection to any subgraph in subgraphs. Add a new subgraph, and maybe later there will be
 			// a connection.
 			if (!found_match) {
-				subgraphs.emplace_back(Subgraph2Denominator());
-				auto subgraph = &subgraphs.back();
-				subgraph->relations.insert(filter->left_binding.table_index);
-				subgraph->relations.insert(filter->right_binding.table_index);
-				UpdateDenom(subgraph, &relation_2_tdom);
+				subgraphs.emplace_back();
+				auto &subgraph = subgraphs.back();
+				subgraph.relations.insert(filter->left_binding.table_index);
+				subgraph.relations.insert(filter->right_binding.table_index);
+				UpdateDenom(subgraph, relation_2_tdom);
 			}
 			auto remove_start = std::remove_if(subgraphs.begin(), subgraphs.end(),
 			                                   [](Subgraph2Denominator &s) { return s.relations.empty(); });
 			subgraphs.erase(remove_start, subgraphs.end());
 
-			if (subgraphs.size() == 1 && subgraphs.at(0).relations.size() == new_set->count) {
+			if (subgraphs.size() == 1 && subgraphs.at(0).relations.size() == new_set.count) {
 				// You have found enough filters to connect the relations. These are guaranteed
 				// to be the filters with the highest Tdoms.
 				done = true;
@@ -294,37 +292,38 @@ double CardinalityEstimator::EstimateCardinalityWithSet(JoinRelationSet *new_set
 	return numerator / denom;
 }
 
-static bool IsLogicalFilter(LogicalOperator *op) {
-	return op->type == LogicalOperatorType::LOGICAL_FILTER;
+static bool IsLogicalFilter(LogicalOperator &op) {
+	return op.type == LogicalOperatorType::LOGICAL_FILTER;
 }
 
-static LogicalGet *GetLogicalGet(LogicalOperator *op, idx_t table_index = DConstants::INVALID_INDEX) {
-	LogicalGet *get = nullptr;
-	switch (op->type) {
+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 = (LogicalGet *)op;
+		get = &op.Cast<LogicalGet>();
 		break;
 	case LogicalOperatorType::LOGICAL_FILTER:
-		get = GetLogicalGet(op->children.at(0).get(), table_index);
+		get = GetLogicalGet(*op.children.at(0), table_index);
 		break;
 	case LogicalOperatorType::LOGICAL_PROJECTION:
-		get = GetLogicalGet(op->children.at(0).get(), table_index);
+		get = GetLogicalGet(*op.children.at(0), table_index);
 		break;
+	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
-		LogicalComparisonJoin *join = (LogicalComparisonJoin *)op;
+		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 child = join->children.at(0).get();
-			get = GetLogicalGet(child, table_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;
 			}
-			child = join->children.at(1).get();
-			get = GetLogicalGet(child, table_index);
+			auto &right_child = *join.children.at(1);
+			get = GetLogicalGet(right_child, table_index);
 			if (get && get->table_index == table_index) {
 				return get;
 			}
@@ -366,24 +365,27 @@ 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) {
+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.get();
-		auto op = (*node_ops)[i].op;
-		join_node->SetBaseTableCardinality(op->EstimateCardinality(context));
-		if (op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
-			auto &join = (LogicalComparisonJoin &)*op;
+	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());
+				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);
@@ -395,15 +397,14 @@ void CardinalityEstimator::InitCardinalityEstimatorProps(vector<NodeOp> *node_op
 	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(JoinNode &node, LogicalOperator &op) {
+	auto relation_id = node.set.relations[0];
+	relation_attributes[relation_id].cardinality = node.GetCardinality<double>();
 	//! Initialize the distinct count for all columns used in joins with the current relation.
-	idx_t distinct_count = node->GetBaseTableCardinality();
-	TableCatalogEntry *catalog_table = nullptr;
+	idx_t distinct_count = node.GetBaseTableCardinality();
+	optional_ptr<TableCatalogEntry> catalog_table;
 
-	bool direct_filter = false;
-	LogicalGet *get = nullptr;
+	optional_ptr<LogicalGet> get;
 	bool get_updated = true;
 	for (auto &column : relation_attributes[relation_id].columns) {
 		//! for every column used in a filter in the relation, get the distinct count via HLL, or assume it to be
@@ -424,7 +425,11 @@ void CardinalityEstimator::UpdateTotalDomains(JoinNode *node, LogicalOperator *o
 		}
 
 		if (get_updated) {
-			catalog_table = GetCatalogTableEntry(get);
+			if (get) {
+				catalog_table = GetCatalogTableEntry(*get);
+			} else {
+				catalog_table = nullptr;
+			}
 		}
 
 		if (catalog_table && actual_binding != relation_column_to_original_column.end()) {
@@ -434,26 +439,12 @@ void CardinalityEstimator::UpdateTotalDomains(JoinNode *node, LogicalOperator *o
 				distinct_count = base_stats->GetDistinctCount();
 			}
 
-			// means you have a direct filter on a column. The distinct_count/total domain for the column
-			// should be decreased to match the predicted total domain matching the filter.
-			// We decrease the total domain for all columns in the equivalence set because filter pushdown
-			// will mean all columns are affected.
-			if (direct_filter) {
-				distinct_count = node->GetCardinality<idx_t>();
-			}
-
 			// 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();
+			if (distinct_count > node.GetBaseTableCardinality()) {
+				distinct_count = node.GetBaseTableCardinality();
 			}
 		} else {
-			// No HLL. So if we know there is a direct filter, reduce the distinct count to the cardinality
-			// with filter effects. Otherwise assume the distinct count is still the cardinality
-			if (direct_filter) {
-				distinct_count = node->GetCardinality<idx_t>();
-			} else {
-				distinct_count = node->GetBaseTableCardinality();
-			}
+			distinct_count = node.GetBaseTableCardinality();
 		}
 		// Update the relation_to_tdom set with the estimated distinct count (or tdom) calculated above
 		for (auto &relation_to_tdom : relations_to_tdoms) {
@@ -483,7 +474,7 @@ void CardinalityEstimator::UpdateTotalDomains(JoinNode *node, LogicalOperator *o
 	}
 }
 
-TableFilterSet *CardinalityEstimator::GetTableFilters(LogicalOperator *op, idx_t table_index) {
+optional_ptr<TableFilterSet> CardinalityEstimator::GetTableFilters(LogicalOperator &op, idx_t table_index) {
 	auto get = GetLogicalGet(op, table_index);
 	return get ? &get->table_filters : nullptr;
 }
@@ -546,15 +537,15 @@ idx_t CardinalityEstimator::InspectConjunctionOR(idx_t cardinality, idx_t column
 	return cardinality_after_filters;
 }
 
-idx_t CardinalityEstimator::InspectTableFilters(idx_t cardinality, LogicalOperator *op, TableFilterSet *table_filters,
+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) {
+	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 = (TableScanBindData &)*get->bind_data;
+			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) {
@@ -572,22 +563,22 @@ idx_t CardinalityEstimator::InspectTableFilters(idx_t cardinality, LogicalOperat
 	// 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()) {
+	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) {
+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];
+	D_ASSERT(node.set.count == 1);
+	auto relation_id = node.set.relations[0];
 
 	double lowest_card_found = NumericLimits<double>::Maximum();
 	for (auto &column : relation_attributes[relation_id].columns) {
-		auto card_after_filters = node->GetBaseTableCardinality();
+		auto card_after_filters = node.GetBaseTableCardinality();
 		ColumnBinding key = ColumnBinding(relation_id, column);
-		TableFilterSet *table_filters = nullptr;
+		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);
@@ -595,7 +586,7 @@ void CardinalityEstimator::EstimateBaseTableCardinality(JoinNode *node, LogicalO
 
 		if (table_filters) {
 			double inspect_result =
-			    (double)InspectTableFilters(card_after_filters, op, table_filters, actual_binding->second.table_index);
+			    (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) {
@@ -603,7 +594,7 @@ void CardinalityEstimator::EstimateBaseTableCardinality(JoinNode *node, LogicalO
 		}
 		lowest_card_found = MinValue(card_after_filters, lowest_card_found);
 	}
-	node->SetEstimatedCardinality(lowest_card_found);
+	node.SetEstimatedCardinality(lowest_card_found);
 }
 
 } // namespace duckdb

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

@@ -6,19 +6,19 @@
 
 namespace duckdb {
 
-JoinNode::JoinNode(JoinRelationSet *set, const double base_cardinality)
+JoinNode::JoinNode(JoinRelationSet &set, const double base_cardinality)
     : set(set), info(nullptr), has_filter(false), left(nullptr), right(nullptr), base_cardinality(base_cardinality) {
-	estimated_props = make_unique<EstimatedProperties>(base_cardinality, 0);
+	estimated_props = make_uniq<EstimatedProperties>(base_cardinality, 0);
 }
 
-JoinNode::JoinNode(JoinRelationSet *set, NeighborInfo *info, JoinNode *left, JoinNode *right,
+JoinNode::JoinNode(JoinRelationSet &set, optional_ptr<NeighborInfo> info, JoinNode &left, JoinNode &right,
                    const double base_cardinality, double cost)
-    : set(set), info(info), has_filter(false), left(left), right(right), base_cardinality(base_cardinality) {
-	estimated_props = make_unique<EstimatedProperties>(base_cardinality, cost);
+    : set(set), info(info), has_filter(false), left(&left), right(&right), base_cardinality(base_cardinality) {
+	estimated_props = make_uniq<EstimatedProperties>(base_cardinality, cost);
 }
 
 unique_ptr<EstimatedProperties> EstimatedProperties::Copy() {
-	auto result = make_unique<EstimatedProperties>(cardinality, cost);
+	auto result = make_uniq<EstimatedProperties>(cardinality, cost);
 	return result;
 }
 
@@ -31,7 +31,7 @@ void JoinNode::SetCost(double cost) {
 }
 
 double JoinNode::GetBaseTableCardinality() {
-	if (set->count > 1) {
+	if (set.count > 1) {
 		throw InvalidInputException("Cannot call get base table cardinality on intermediate join node");
 	}
 	return base_cardinality;
@@ -46,11 +46,8 @@ void JoinNode::SetEstimatedCardinality(double estimated_card) {
 }
 
 string JoinNode::ToString() {
-	if (!set) {
-		return "";
-	}
 	string result = "-------------------------------\n";
-	result += set->ToString() + "\n";
+	result += set.ToString() + "\n";
 	result += "card = " + to_string(GetCardinality<double>()) + "\n";
 	bool is_cartesian = false;
 	if (left && right) {