duckdb 0.7.2-dev1803.0 → 0.7.2-dev1867.0

package/src/duckdb/src/optimizer/filter_combiner.cpp

@@ -27,23 +27,23 @@ FilterCombiner::FilterCombiner(ClientContext &context) : context(context) {
 FilterCombiner::FilterCombiner(Optimizer &optimizer) : FilterCombiner(optimizer.context) {
 }
 
-Expression *FilterCombiner::GetNode(Expression *expr) {
+Expression &FilterCombiner::GetNode(Expression &expr) {
 	auto entry = stored_expressions.find(expr);
 	if (entry != stored_expressions.end()) {
 		// expression already exists: return a reference to the stored expression
-		return entry->second.get();
+		return *entry->second;
 	}
 	// expression does not exist yet: create a copy and store it
-	auto copy = expr->Copy();
-	auto pointer_copy = copy.get();
-	D_ASSERT(stored_expressions.find(pointer_copy) == stored_expressions.end());
-	stored_expressions.insert(make_pair(pointer_copy, std::move(copy)));
-	return pointer_copy;
+	auto copy = expr.Copy();
+	auto &copy_ref = *copy;
+	D_ASSERT(stored_expressions.find(copy_ref) == stored_expressions.end());
+	stored_expressions[copy_ref] = std::move(copy);
+	return copy_ref;
 }
 
-idx_t FilterCombiner::GetEquivalenceSet(Expression *expr) {
+idx_t FilterCombiner::GetEquivalenceSet(Expression &expr) {
 	D_ASSERT(stored_expressions.find(expr) != stored_expressions.end());
-	D_ASSERT(stored_expressions.find(expr)->second.get() == expr);
+	D_ASSERT(stored_expressions.find(expr)->second.get() == &expr);
 	auto entry = equivalence_set_map.find(expr);
 	if (entry == equivalence_set_map.end()) {
 		idx_t index = set_index++;
@@ -88,7 +88,7 @@ FilterResult FilterCombiner::AddConstantComparison(vector<ExpressionValueInforma
 FilterResult FilterCombiner::AddFilter(unique_ptr<Expression> expr) {
 	//	LookUpConjunctions(expr.get());
 	// try to push the filter into the combiner
-	auto result = AddFilter(expr.get());
+	auto result = AddFilter(*expr);
 	if (result == FilterResult::UNSUPPORTED) {
 		// unsupported filter, push into remaining filters
 		remaining_filters.push_back(std::move(expr));
@@ -111,8 +111,8 @@ void FilterCombiner::GenerateFilters(const std::function<void(unique_ptr<Express
 		// for each entry generate an equality expression comparing to each other
 		for (idx_t i = 0; i < entries.size(); i++) {
 			for (idx_t k = i + 1; k < entries.size(); k++) {
-				auto comparison = make_uniq<BoundComparisonExpression>(ExpressionType::COMPARE_EQUAL,
-				                                                       entries[i]->Copy(), entries[k]->Copy());
+				auto comparison = make_uniq<BoundComparisonExpression>(
+				    ExpressionType::COMPARE_EQUAL, entries[i].get().Copy(), entries[k].get().Copy());
 				callback(std::move(comparison));
 			}
 			// for each entry also create a comparison with each constant
@@ -132,8 +132,8 @@ void FilterCombiner::GenerateFilters(const std::function<void(unique_ptr<Express
 					upper_inclusive = info.comparison_type == ExpressionType::COMPARE_LESSTHANOREQUALTO;
 				} else {
 					auto constant = make_uniq<BoundConstantExpression>(info.constant);
-					auto comparison = make_uniq<BoundComparisonExpression>(info.comparison_type, entries[i]->Copy(),
-					                                                       std::move(constant));
+					auto comparison = make_uniq<BoundComparisonExpression>(
+					    info.comparison_type, entries[i].get().Copy(), std::move(constant));
 					callback(std::move(comparison));
 				}
 			}
@@ -142,20 +142,20 @@ void FilterCombiner::GenerateFilters(const std::function<void(unique_ptr<Express
 				auto lower_constant = make_uniq<BoundConstantExpression>(constant_list[lower_index].constant);
 				auto upper_constant = make_uniq<BoundConstantExpression>(constant_list[upper_index].constant);
 				auto between =
-				    make_uniq<BoundBetweenExpression>(entries[i]->Copy(), std::move(lower_constant),
+				    make_uniq<BoundBetweenExpression>(entries[i].get().Copy(), std::move(lower_constant),
 				                                      std::move(upper_constant), lower_inclusive, upper_inclusive);
 				callback(std::move(between));
 			} else if (lower_index >= 0) {
 				// only lower index found, create simple comparison expression
 				auto constant = make_uniq<BoundConstantExpression>(constant_list[lower_index].constant);
 				auto comparison = make_uniq<BoundComparisonExpression>(constant_list[lower_index].comparison_type,
-				                                                       entries[i]->Copy(), std::move(constant));
+				                                                       entries[i].get().Copy(), std::move(constant));
 				callback(std::move(comparison));
 			} else if (upper_index >= 0) {
 				// only upper index found, create simple comparison expression
 				auto constant = make_uniq<BoundConstantExpression>(constant_list[upper_index].constant);
 				auto comparison = make_uniq<BoundComparisonExpression>(constant_list[upper_index].comparison_type,
-				                                                       entries[i]->Copy(), std::move(constant));
+				                                                       entries[i].get().Copy(), std::move(constant));
 				callback(std::move(comparison));
 			}
 		}
@@ -407,9 +407,10 @@ TableFilterSet FilterCombiner::GenerateTableScanFilters(vector<idx_t> &column_id
 			     constant_value.second[0].constant.type().InternalType() == PhysicalType::BOOL)) {
 				//! Here we check if these filters are column references
 				filter_exp = equivalence_map.find(constant_value.first);
-				if (filter_exp->second.size() == 1 && filter_exp->second[0]->type == ExpressionType::BOUND_COLUMN_REF) {
-					auto filter_col_exp = static_cast<BoundColumnRefExpression *>(filter_exp->second[0]);
-					auto column_index = column_ids[filter_col_exp->binding.column_index];
+				if (filter_exp->second.size() == 1 &&
+				    filter_exp->second[0].get().type == ExpressionType::BOUND_COLUMN_REF) {
+					auto &filter_col_exp = filter_exp->second[0].get().Cast<BoundColumnRefExpression>();
+					auto column_index = column_ids[filter_col_exp.binding.column_index];
 					if (column_index == COLUMN_IDENTIFIER_ROW_ID) {
 						break;
 					}
@@ -572,8 +573,8 @@ static bool IsLessThan(ExpressionType type) {
 	return type == ExpressionType::COMPARE_LESSTHAN || type == ExpressionType::COMPARE_LESSTHANOREQUALTO;
 }
 
-FilterResult FilterCombiner::AddBoundComparisonFilter(Expression *expr) {
-	auto &comparison = expr->Cast<BoundComparisonExpression>();
+FilterResult FilterCombiner::AddBoundComparisonFilter(Expression &expr) {
+	auto &comparison = expr.Cast<BoundComparisonExpression>();
 	if (comparison.type != ExpressionType::COMPARE_LESSTHAN &&
 	    comparison.type != ExpressionType::COMPARE_LESSTHANOREQUALTO &&
 	    comparison.type != ExpressionType::COMPARE_GREATERTHAN &&
@@ -587,9 +588,9 @@ FilterResult FilterCombiner::AddBoundComparisonFilter(Expression *expr) {
 	bool right_is_scalar = comparison.right->IsFoldable();
 	if (left_is_scalar || right_is_scalar) {
 		// comparison with scalar
-		auto node = GetNode(left_is_scalar ? comparison.right.get() : comparison.left.get());
+		auto &node = GetNode(left_is_scalar ? *comparison.right : *comparison.left);
 		idx_t equivalence_set = GetEquivalenceSet(node);
-		auto scalar = left_is_scalar ? comparison.left.get() : comparison.right.get();
+		auto &scalar = left_is_scalar ? comparison.left : comparison.right;
 		Value constant_value;
 		if (!ExpressionExecutor::TryEvaluateScalar(context, *scalar, constant_value)) {
 			return FilterResult::UNSATISFIABLE;
@@ -607,11 +608,11 @@ FilterResult FilterCombiner::AddBoundComparisonFilter(Expression *expr) {
 		// get the current bucket of constant values
 		D_ASSERT(constant_values.find(equivalence_set) != constant_values.end());
 		auto &info_list = constant_values.find(equivalence_set)->second;
-		D_ASSERT(node->return_type == info.constant.type());
+		D_ASSERT(node.return_type == info.constant.type());
 		// check the existing constant comparisons to see if we can do any pruning
 		auto ret = AddConstantComparison(info_list, info);
 
-		auto non_scalar = left_is_scalar ? comparison.right.get() : comparison.left.get();
+		auto &non_scalar = left_is_scalar ? *comparison.right : *comparison.left;
 		auto transitive_filter = FindTransitiveFilter(non_scalar);
 		if (transitive_filter != nullptr) {
 			// try to add transitive filters
@@ -625,16 +626,16 @@ FilterResult FilterCombiner::AddBoundComparisonFilter(Expression *expr) {
 	} else {
 		// comparison between two non-scalars
 		// only handle comparisons for now
-		if (expr->type != ExpressionType::COMPARE_EQUAL) {
-			if (IsGreaterThan(expr->type) || IsLessThan(expr->type)) {
+		if (expr.type != ExpressionType::COMPARE_EQUAL) {
+			if (IsGreaterThan(expr.type) || IsLessThan(expr.type)) {
 				return AddTransitiveFilters(comparison);
 			}
 			return FilterResult::UNSUPPORTED;
 		}
 		// get the LHS and RHS nodes
-		auto left_node = GetNode(comparison.left.get());
-		auto right_node = GetNode(comparison.right.get());
-		if (BaseExpression::Equals(left_node, right_node)) {
+		auto &left_node = GetNode(*comparison.left);
+		auto &right_node = GetNode(*comparison.right);
+		if (left_node.Equals(&right_node)) {
 			return FilterResult::UNSUPPORTED;
 		}
 		// get the equivalence sets of the LHS and RHS
@@ -650,19 +651,19 @@ FilterResult FilterCombiner::AddBoundComparisonFilter(Expression *expr) {
 
 		auto &left_bucket = equivalence_map.find(left_equivalence_set)->second;
 		auto &right_bucket = equivalence_map.find(right_equivalence_set)->second;
-		for (auto &i : right_bucket) {
+		for (auto &right_expr : right_bucket) {
 			// rewrite the equivalence set mapping for this node
-			equivalence_set_map[i] = left_equivalence_set;
+			equivalence_set_map[right_expr] = left_equivalence_set;
 			// add the node to the left bucket
-			left_bucket.push_back(i);
+			left_bucket.push_back(right_expr);
 		}
 		// now add all constant values from the right bucket to the left bucket
 		D_ASSERT(constant_values.find(left_equivalence_set) != constant_values.end());
 		D_ASSERT(constant_values.find(right_equivalence_set) != constant_values.end());
 		auto &left_constant_bucket = constant_values.find(left_equivalence_set)->second;
 		auto &right_constant_bucket = constant_values.find(right_equivalence_set)->second;
-		for (auto &i : right_constant_bucket) {
-			if (AddConstantComparison(left_constant_bucket, i) == FilterResult::UNSATISFIABLE) {
+		for (auto &right_constant : right_constant_bucket) {
+			if (AddConstantComparison(left_constant_bucket, right_constant) == FilterResult::UNSATISFIABLE) {
 				return FilterResult::UNSATISFIABLE;
 			}
 		}
@@ -670,14 +671,14 @@ FilterResult FilterCombiner::AddBoundComparisonFilter(Expression *expr) {
 	return FilterResult::SUCCESS;
 }
 
-FilterResult FilterCombiner::AddFilter(Expression *expr) {
-	if (expr->HasParameter()) {
+FilterResult FilterCombiner::AddFilter(Expression &expr) {
+	if (expr.HasParameter()) {
 		return FilterResult::UNSUPPORTED;
 	}
-	if (expr->IsFoldable()) {
+	if (expr.IsFoldable()) {
 		// scalar condition, evaluate it
 		Value result;
-		if (!ExpressionExecutor::TryEvaluateScalar(context, *expr, result)) {
+		if (!ExpressionExecutor::TryEvaluateScalar(context, expr, result)) {
 			return FilterResult::UNSUPPORTED;
 		}
 		result = result.DefaultCastAs(LogicalType::BOOLEAN);
@@ -690,15 +691,15 @@ FilterResult FilterCombiner::AddFilter(Expression *expr) {
 			return FilterResult::SUCCESS;
 		}
 	}
-	D_ASSERT(!expr->IsFoldable());
-	if (expr->GetExpressionClass() == ExpressionClass::BOUND_BETWEEN) {
-		auto &comparison = expr->Cast<BoundBetweenExpression>();
+	D_ASSERT(!expr.IsFoldable());
+	if (expr.GetExpressionClass() == ExpressionClass::BOUND_BETWEEN) {
+		auto &comparison = expr.Cast<BoundBetweenExpression>();
 		//! check if one of the sides is a scalar value
 		bool lower_is_scalar = comparison.lower->IsFoldable();
 		bool upper_is_scalar = comparison.upper->IsFoldable();
 		if (lower_is_scalar || upper_is_scalar) {
 			//! comparison with scalar - break apart
-			auto node = GetNode(comparison.input.get());
+			auto &node = GetNode(*comparison.input);
 			idx_t equivalence_set = GetEquivalenceSet(node);
 			auto result = FilterResult::UNSATISFIABLE;
 
@@ -730,7 +731,7 @@ FilterResult FilterCombiner::AddFilter(Expression *expr) {
 				auto left = comparison.lower->Copy();
 				auto right = comparison.input->Copy();
 				auto lower_comp = make_uniq<BoundComparisonExpression>(type, std::move(left), std::move(right));
-				result = AddBoundComparisonFilter(lower_comp.get());
+				result = AddBoundComparisonFilter(*lower_comp);
 			}
 
 			//	 Stop if we failed
@@ -765,12 +766,12 @@ FilterResult FilterCombiner::AddFilter(Expression *expr) {
 				auto left = comparison.input->Copy();
 				auto right = comparison.upper->Copy();
 				auto upper_comp = make_uniq<BoundComparisonExpression>(type, std::move(left), std::move(right));
-				result = AddBoundComparisonFilter(upper_comp.get());
+				result = AddBoundComparisonFilter(*upper_comp);
 			}
 
 			return result;
 		}
-	} else if (expr->GetExpressionClass() == ExpressionClass::BOUND_COMPARISON) {
+	} else if (expr.GetExpressionClass() == ExpressionClass::BOUND_COMPARISON) {
 		return AddBoundComparisonFilter(expr);
 	}
 	// only comparisons supported for now
@@ -784,20 +785,20 @@ FilterResult FilterCombiner::AddFilter(Expression *expr) {
 FilterResult FilterCombiner::AddTransitiveFilters(BoundComparisonExpression &comparison) {
 	D_ASSERT(IsGreaterThan(comparison.type) || IsLessThan(comparison.type));
 	// get the LHS and RHS nodes
-	Expression *left_node = GetNode(comparison.left.get());
-	Expression *right_node = GetNode(comparison.right.get());
+	auto &left_node = GetNode(*comparison.left);
+	reference<Expression> right_node = GetNode(*comparison.right);
 	// In case with filters like CAST(i) = j and i = 5 we replace the COLUMN_REF i with the constant 5
-	if (right_node->type == ExpressionType::OPERATOR_CAST) {
-		auto &bound_cast_expr = right_node->Cast<BoundCastExpression>();
+	if (right_node.get().type == ExpressionType::OPERATOR_CAST) {
+		auto &bound_cast_expr = right_node.get().Cast<BoundCastExpression>();
 		if (bound_cast_expr.child->type == ExpressionType::BOUND_COLUMN_REF) {
 			auto &col_ref = bound_cast_expr.child->Cast<BoundColumnRefExpression>();
 			for (auto &stored_exp : stored_expressions) {
-				if (stored_exp.first->type == ExpressionType::BOUND_COLUMN_REF) {
+				if (stored_exp.first.get().type == ExpressionType::BOUND_COLUMN_REF) {
 					auto &st_col_ref = stored_exp.second->Cast<BoundColumnRefExpression>();
 					if (st_col_ref.binding == col_ref.binding &&
 					    bound_cast_expr.return_type == stored_exp.second->return_type) {
 						bound_cast_expr.child = stored_exp.second->Copy();
-						right_node = GetNode(bound_cast_expr.child.get());
+						right_node = GetNode(*bound_cast_expr.child);
 						break;
 					}
 				}
@@ -805,7 +806,7 @@ FilterResult FilterCombiner::AddTransitiveFilters(BoundComparisonExpression &com
 		}
 	}
 
-	if (BaseExpression::Equals(left_node, right_node)) {
+	if (left_node.Equals(&right_node.get())) {
 		return FilterResult::UNSUPPORTED;
 	}
 	// get the equivalence sets of the LHS and RHS
@@ -874,7 +875,7 @@ FilterResult FilterCombiner::AddTransitiveFilters(BoundComparisonExpression &com
 	}
 	if (is_successful) {
 		// now check for remaining trasitive filters from the left column
-		auto transitive_filter = FindTransitiveFilter(comparison.left.get());
+		auto transitive_filter = FindTransitiveFilter(*comparison.left);
 		if (transitive_filter != nullptr) {
 			// try to add transitive filters
 			if (AddTransitiveFilters(transitive_filter->Cast<BoundComparisonExpression>()) ==
@@ -894,17 +895,18 @@ FilterResult FilterCombiner::AddTransitiveFilters(BoundComparisonExpression &com
  * Check for a match between the right column of bound comparisons and the expression,
  * then removes the bound comparison from the remaining filters and returns it
  */
-unique_ptr<Expression> FilterCombiner::FindTransitiveFilter(Expression *expr) {
+unique_ptr<Expression> FilterCombiner::FindTransitiveFilter(Expression &expr) {
 	// We only check for bound column ref
-	if (expr->type == ExpressionType::BOUND_COLUMN_REF) {
-		for (idx_t i = 0; i < remaining_filters.size(); i++) {
-			if (remaining_filters[i]->GetExpressionClass() == ExpressionClass::BOUND_COMPARISON) {
-				auto &comparison = remaining_filters[i]->Cast<BoundComparisonExpression>();
-				if (expr->Equals(comparison.right.get()) && comparison.type != ExpressionType::COMPARE_NOTEQUAL) {
-					auto filter = std::move(remaining_filters[i]);
-					remaining_filters.erase(remaining_filters.begin() + i);
-					return filter;
-				}
+	if (expr.type != ExpressionType::BOUND_COLUMN_REF) {
+		return nullptr;
+	}
+	for (idx_t i = 0; i < remaining_filters.size(); i++) {
+		if (remaining_filters[i]->GetExpressionClass() == ExpressionClass::BOUND_COMPARISON) {
+			auto &comparison = remaining_filters[i]->Cast<BoundComparisonExpression>();
+			if (expr.Equals(comparison.right.get()) && comparison.type != ExpressionType::COMPARE_NOTEQUAL) {
+				auto filter = std::move(remaining_filters[i]);
+				remaining_filters.erase(remaining_filters.begin() + i);
+				return filter;
 			}
 		}
 	}

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

@@ -105,6 +105,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;
 	}
 }

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

@@ -96,8 +96,9 @@ static unique_ptr<LogicalOperator> PushFilter(unique_ptr<LogicalOperator> node,
 bool JoinOrderOptimizer::ExtractJoinRelations(LogicalOperator &input_op, vector<LogicalOperator *> &filter_operators,
                                               LogicalOperator *parent) {
 	LogicalOperator *op = &input_op;
-	while (op->children.size() == 1 && (op->type != LogicalOperatorType::LOGICAL_PROJECTION &&
-	                                    op->type != LogicalOperatorType::LOGICAL_EXPRESSION_GET)) {
+	while (op->children.size() == 1 &&
+	       (op->type != LogicalOperatorType::LOGICAL_PROJECTION &&
+	        op->type != LogicalOperatorType::LOGICAL_EXPRESSION_GET && op->type != LogicalOperatorType::LOGICAL_GET)) {
 		if (op->type == LogicalOperatorType::LOGICAL_FILTER) {
 			// extract join conditions from filter
 			filter_operators.push_back(op);
@@ -193,18 +194,7 @@ bool JoinOrderOptimizer::ExtractJoinRelations(LogicalOperator &input_op, vector<
 		bool can_reorder_right = ExtractJoinRelations(*op->children[1], filter_operators, op);
 		return can_reorder_left && can_reorder_right;
 	}
-	case LogicalOperatorType::LOGICAL_GET: {
-		// base table scan, add to set of relations
-		auto &get = op->Cast<LogicalGet>();
-		auto relation = make_uniq<SingleJoinRelation>(&input_op, parent);
-		idx_t relation_id = relations.size();
-		//! make sure the optimizer has knowledge of the exact column bindings as well.
-		auto table_index = get.table_index;
-		relation_mapping[table_index] = relation_id;
-		cardinality_estimator.AddRelationColumnMapping(&get, relation_id);
-		relations.push_back(std::move(relation));
-		return true;
-	}
+
 	case LogicalOperatorType::LOGICAL_EXPRESSION_GET: {
 		// base table scan, add to set of relations
 		auto &get = op->Cast<LogicalExpressionGet>();
@@ -222,24 +212,35 @@ bool JoinOrderOptimizer::ExtractJoinRelations(LogicalOperator &input_op, vector<
 		relations.push_back(std::move(relation));
 		return true;
 	}
+	case LogicalOperatorType::LOGICAL_GET:
 	case LogicalOperatorType::LOGICAL_PROJECTION: {
-		auto &proj = op->Cast<LogicalProjection>();
+		auto table_index = op->GetTableIndex()[0];
+		auto relation = make_uniq<SingleJoinRelation>(&input_op, parent);
+		auto relation_id = relations.size();
+
+		// If the children are empty, operator can't ge a logical get.
+		if (op->children.empty() && op->type == LogicalOperatorType::LOGICAL_GET) {
+			auto &get = op->Cast<LogicalGet>();
+			cardinality_estimator.AddRelationColumnMapping(&get, relation_id);
+			relation_mapping[table_index] = relation_id;
+			relations.push_back(std::move(relation));
+			return true;
+		}
+
 		// we run the join order optimizer within the subquery as well
 		JoinOrderOptimizer optimizer(context);
 		op->children[0] = optimizer.Optimize(std::move(op->children[0]));
-		// projection, add to the set of relations
-		auto relation = make_uniq<SingleJoinRelation>(&input_op, parent);
-		auto relation_id = relations.size();
+
 		// push one child column binding map back.
 		vector<column_binding_map_t<ColumnBinding>> child_binding_maps;
 		child_binding_maps.emplace_back();
 		optimizer.cardinality_estimator.CopyRelationMap(child_binding_maps.at(0));
-		// This logical projection may sit on top of a logical comparison join that has been pushed down
+		// This logical projection/get may sit on top of a logical comparison join that has been pushed down
 		// we want to copy the binding info of both tables
-		relation_mapping[proj.table_index] = relation_id;
+		relation_mapping[table_index] = relation_id;
 		for (auto &binding_info : child_binding_maps.at(0)) {
 			cardinality_estimator.AddRelationToColumnMapping(
-			    ColumnBinding(proj.table_index, binding_info.first.column_index), binding_info.second);
+			    ColumnBinding(table_index, binding_info.first.column_index), binding_info.second);
 			cardinality_estimator.AddColumnToRelationMap(binding_info.second.table_index,
 			                                             binding_info.second.column_index);
 		}
@@ -955,16 +956,16 @@ unique_ptr<LogicalOperator> JoinOrderOptimizer::Optimize(unique_ptr<LogicalOpera
 			for (auto &cond : join.conditions) {
 				auto comparison =
 				    make_uniq<BoundComparisonExpression>(cond.comparison, std::move(cond.left), std::move(cond.right));
-				if (filter_set.find(comparison.get()) == filter_set.end()) {
-					filter_set.insert(comparison.get());
+				if (filter_set.find(*comparison) == filter_set.end()) {
+					filter_set.insert(*comparison);
 					filters.push_back(std::move(comparison));
 				}
 			}
 			join.conditions.clear();
 		} else {
 			for (auto &expression : f_op->expressions) {
-				if (filter_set.find(expression.get()) == filter_set.end()) {
-					filter_set.insert(expression.get());
+				if (filter_set.find(*expression) == filter_set.end()) {
+					filter_set.insert(*expression);
 					filters.push_back(std::move(expression));
 				}
 			}

package/src/duckdb/src/optimizer/matcher/expression_matcher.cpp

@@ -4,82 +4,84 @@
 
 namespace duckdb {
 
-bool ExpressionMatcher::Match(Expression *expr, vector<Expression *> &bindings) {
-	if (type && !type->Match(expr->return_type)) {
+bool ExpressionMatcher::Match(Expression &expr, vector<reference<Expression>> &bindings) {
+	if (type && !type->Match(expr.return_type)) {
 		return false;
 	}
-	if (expr_type && !expr_type->Match(expr->type)) {
+	if (expr_type && !expr_type->Match(expr.type)) {
 		return false;
 	}
-	if (expr_class != ExpressionClass::INVALID && expr_class != expr->GetExpressionClass()) {
+	if (expr_class != ExpressionClass::INVALID && expr_class != expr.GetExpressionClass()) {
 		return false;
 	}
 	bindings.push_back(expr);
 	return true;
 }
 
-bool ExpressionEqualityMatcher::Match(Expression *expr, vector<Expression *> &bindings) {
-	if (!Expression::Equals(expression, expr)) {
+bool ExpressionEqualityMatcher::Match(Expression &expr, vector<reference<Expression>> &bindings) {
+	if (!expr.Equals(&expression)) {
 		return false;
 	}
 	bindings.push_back(expr);
 	return true;
 }
 
-bool CaseExpressionMatcher::Match(Expression *expr_p, vector<Expression *> &bindings) {
+bool CaseExpressionMatcher::Match(Expression &expr_p, vector<reference<Expression>> &bindings) {
 	if (!ExpressionMatcher::Match(expr_p, bindings)) {
 		return false;
 	}
 	return true;
 }
 
-bool ComparisonExpressionMatcher::Match(Expression *expr_p, vector<Expression *> &bindings) {
+bool ComparisonExpressionMatcher::Match(Expression &expr_p, vector<reference<Expression>> &bindings) {
 	if (!ExpressionMatcher::Match(expr_p, bindings)) {
 		return false;
 	}
-	auto &expr = expr_p->Cast<BoundComparisonExpression>();
-	vector<Expression *> expressions = {expr.left.get(), expr.right.get()};
+	auto &expr = expr_p.Cast<BoundComparisonExpression>();
+	vector<reference<Expression>> expressions;
+	expressions.push_back(*expr.left);
+	expressions.push_back(*expr.right);
 	return SetMatcher::Match(matchers, expressions, bindings, policy);
 }
 
-bool CastExpressionMatcher::Match(Expression *expr_p, vector<Expression *> &bindings) {
+bool CastExpressionMatcher::Match(Expression &expr_p, vector<reference<Expression>> &bindings) {
 	if (!ExpressionMatcher::Match(expr_p, bindings)) {
 		return false;
 	}
 	if (!matcher) {
 		return true;
 	}
-	auto &expr = expr_p->Cast<BoundCastExpression>();
-	return matcher->Match(expr.child.get(), bindings);
+	auto &expr = expr_p.Cast<BoundCastExpression>();
+	return matcher->Match(*expr.child, bindings);
 }
 
-bool InClauseExpressionMatcher::Match(Expression *expr_p, vector<Expression *> &bindings) {
+bool InClauseExpressionMatcher::Match(Expression &expr_p, vector<reference<Expression>> &bindings) {
 	if (!ExpressionMatcher::Match(expr_p, bindings)) {
 		return false;
 	}
-	auto &expr = expr_p->Cast<BoundOperatorExpression>();
+	auto &expr = expr_p.Cast<BoundOperatorExpression>();
 	if (expr.type != ExpressionType::COMPARE_IN || expr.type == ExpressionType::COMPARE_NOT_IN) {
 		return false;
 	}
 	return SetMatcher::Match(matchers, expr.children, bindings, policy);
 }
 
-bool ConjunctionExpressionMatcher::Match(Expression *expr_p, vector<Expression *> &bindings) {
+bool ConjunctionExpressionMatcher::Match(Expression &expr_p, vector<reference<Expression>> &bindings) {
 	if (!ExpressionMatcher::Match(expr_p, bindings)) {
 		return false;
 	}
-	auto &expr = expr_p->Cast<BoundConjunctionExpression>();
+	auto &expr = expr_p.Cast<BoundConjunctionExpression>();
 	if (!SetMatcher::Match(matchers, expr.children, bindings, policy)) {
 		return false;
 	}
 	return true;
 }
 
-bool FunctionExpressionMatcher::Match(Expression *expr_p, vector<Expression *> &bindings) {
+bool FunctionExpressionMatcher::Match(Expression &expr_p, vector<reference<Expression>> &bindings) {
 	if (!ExpressionMatcher::Match(expr_p, bindings)) {
 		return false;
 	}
-	auto &expr = expr_p->Cast<BoundFunctionExpression>();
+	auto &expr = expr_p.Cast<BoundFunctionExpression>();
 	if (!FunctionMatcher::Match(function, expr.function.name)) {
 		return false;
 	}
@@ -89,9 +91,9 @@ bool FunctionExpressionMatcher::Match(Expression *expr_p, vector<Expression *> &
 	return true;
 }
 
-bool FoldableConstantMatcher::Match(Expression *expr, vector<Expression *> &bindings) {
+bool FoldableConstantMatcher::Match(Expression &expr, vector<reference<Expression>> &bindings) {
 	// we match on ANY expression that is a scalar expression
-	if (!expr->IsFoldable()) {
+	if (!expr.IsFoldable()) {
 		return false;
 	}
 	bindings.push_back(expr);

package/src/duckdb/src/optimizer/rule/arithmetic_simplification.cpp

@@ -22,10 +22,10 @@ ArithmeticSimplificationRule::ArithmeticSimplificationRule(ExpressionRewriter &r
 	root = std::move(op);
 }
 
-unique_ptr<Expression> ArithmeticSimplificationRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
+unique_ptr<Expression> ArithmeticSimplificationRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
                                                            bool &changes_made, bool is_root) {
-	auto &root = bindings[0]->Cast<BoundFunctionExpression>();
-	auto &constant = bindings[1]->Cast<BoundConstantExpression>();
+	auto &root = bindings[0].get().Cast<BoundFunctionExpression>();
+	auto &constant = bindings[1].get().Cast<BoundConstantExpression>();
 	int constant_child = root.children[0].get() == &constant ? 0 : 1;
 	D_ASSERT(root.children.size() == 2);
 	(void)root;

package/src/duckdb/src/optimizer/rule/case_simplification.cpp

@@ -11,9 +11,9 @@ CaseSimplificationRule::CaseSimplificationRule(ExpressionRewriter &rewriter) : R
 	root = std::move(op);
 }
 
-unique_ptr<Expression> CaseSimplificationRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
+unique_ptr<Expression> CaseSimplificationRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
                                                      bool &changes_made, bool is_root) {
-	auto &root = bindings[0]->Cast<BoundCaseExpression>();
+	auto &root = bindings[0].get().Cast<BoundCaseExpression>();
 	for (idx_t i = 0; i < root.case_checks.size(); i++) {
 		auto &case_check = root.case_checks[i];
 		if (case_check.when_expr->IsFoldable()) {

package/src/duckdb/src/optimizer/rule/comparison_simplification.cpp

@@ -14,18 +14,17 @@ ComparisonSimplificationRule::ComparisonSimplificationRule(ExpressionRewriter &r
 	root = std::move(op);
 }
 
-unique_ptr<Expression> ComparisonSimplificationRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
+unique_ptr<Expression> ComparisonSimplificationRule::Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
                                                            bool &changes_made, bool is_root) {
-	D_ASSERT(bindings[0]->expression_class == ExpressionClass::BOUND_COMPARISON);
-	auto &expr = bindings[0]->Cast<BoundComparisonExpression>();
-	auto constant_expr = bindings[1];
-	bool column_ref_left = expr.left.get() != constant_expr;
+	auto &expr = bindings[0].get().Cast<BoundComparisonExpression>();
+	auto &constant_expr = bindings[1].get();
+	bool column_ref_left = expr.left.get() != &constant_expr;
 	auto column_ref_expr = !column_ref_left ? expr.right.get() : expr.left.get();
 	// the constant_expr is a scalar expression that we have to fold
 	// use an ExpressionExecutor to execute the expression
-	D_ASSERT(constant_expr->IsFoldable());
+	D_ASSERT(constant_expr.IsFoldable());
 	Value constant_value;
-	if (!ExpressionExecutor::TryEvaluateScalar(GetContext(), *constant_expr, constant_value)) {
+	if (!ExpressionExecutor::TryEvaluateScalar(GetContext(), constant_expr, constant_value)) {
 		return nullptr;
 	}
 	if (constant_value.IsNull() && !(expr.type == ExpressionType::COMPARE_NOT_DISTINCT_FROM ||

package/src/duckdb/src/optimizer/rule/conjunction_simplification.cpp

@@ -15,9 +15,9 @@ ConjunctionSimplificationRule::ConjunctionSimplificationRule(ExpressionRewriter
 }
 
 unique_ptr<Expression> ConjunctionSimplificationRule::RemoveExpression(BoundConjunctionExpression &conj,
-                                                                       Expression *expr) {
+                                                                       const Expression &expr) {
 	for (idx_t i = 0; i < conj.children.size(); i++) {
-		if (conj.children[i].get() == expr) {
+		if (conj.children[i].get() == &expr) {
 			// erase the expression
 			conj.children.erase(conj.children.begin() + i);
 			break;
@@ -30,15 +30,16 @@ unique_ptr<Expression> ConjunctionSimplificationRule::RemoveExpression(BoundConj
 	return nullptr;
 }
 
-unique_ptr<Expression> ConjunctionSimplificationRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
-                                                            bool &changes_made, bool is_root) {
-	auto &conjunction = bindings[0]->Cast<BoundConjunctionExpression>();
-	auto constant_expr = bindings[1];
+unique_ptr<Expression> ConjunctionSimplificationRule::Apply(LogicalOperator &op,
+                                                            vector<reference<Expression>> &bindings, bool &changes_made,
+                                                            bool is_root) {
+	auto &conjunction = bindings[0].get().Cast<BoundConjunctionExpression>();
+	auto &constant_expr = bindings[1].get();
 	// the constant_expr is a scalar expression that we have to fold
 	// use an ExpressionExecutor to execute the expression
-	D_ASSERT(constant_expr->IsFoldable());
+	D_ASSERT(constant_expr.IsFoldable());
 	Value constant_value;
-	if (!ExpressionExecutor::TryEvaluateScalar(GetContext(), *constant_expr, constant_value)) {
+	if (!ExpressionExecutor::TryEvaluateScalar(GetContext(), constant_expr, constant_value)) {
 		return nullptr;
 	}
 	constant_value = constant_value.DefaultCastAs(LogicalType::BOOLEAN);