duckdb 0.7.2-dev2320.0 → 0.7.2-dev2366.0

package/src/duckdb/src/planner/binder/expression/bind_aggregate_expression.cpp

@@ -60,7 +60,7 @@ static Value NegatePercentileValue(const Value &v, const bool desc) {
 static void NegatePercentileFractions(ClientContext &context, unique_ptr<ParsedExpression> &fractions, bool desc) {
 	D_ASSERT(fractions.get());
 	D_ASSERT(fractions->expression_class == ExpressionClass::BOUND_EXPRESSION);
-	auto &bound = (BoundExpression &)*fractions;
+	auto &bound = fractions->Cast<BoundExpression>();
 
 	if (!bound.expr->IsFoldable()) {
 		return;
@@ -81,7 +81,8 @@ static void NegatePercentileFractions(ClientContext &context, unique_ptr<ParsedE
 	}
 }
 
-BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFunctionCatalogEntry *func, idx_t depth) {
+BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, optional_ptr<AggregateFunctionCatalogEntry> func,
+                                           idx_t depth) {
 	// first bind the child of the aggregate expression (if any)
 	this->bound_aggregate = true;
 	unique_ptr<Expression> bound_filter;
@@ -137,7 +138,7 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFu
 				if (!success) {
 					throw BinderException(error);
 				}
-				auto &bound_expr = (BoundExpression &)*aggr.children[i];
+				auto &bound_expr = aggr.children[i]->Cast<BoundExpression>();
 				ExtractCorrelatedExpressions(binder, *bound_expr.expr);
 			}
 			if (aggr.filter) {
@@ -146,7 +147,7 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFu
 				if (!success) {
 					throw BinderException(error);
 				}
-				auto &bound_expr = (BoundExpression &)*aggr.filter;
+				auto &bound_expr = aggr.filter->Cast<BoundExpression>();
 				ExtractCorrelatedExpressions(binder, *bound_expr.expr);
 			}
 			if (aggr.order_bys && !aggr.order_bys->orders.empty()) {
@@ -155,7 +156,7 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFu
 					if (!success) {
 						throw BinderException(error);
 					}
-					auto &bound_expr = (BoundExpression &)*order.expression;
+					auto &bound_expr = order.expression->Cast<BoundExpression>();
 					ExtractCorrelatedExpressions(binder, *bound_expr.expr);
 				}
 			}

package/src/duckdb/src/planner/binder/expression/bind_cast_expression.cpp

@@ -8,7 +8,7 @@ namespace duckdb {
 
 BindResult ExpressionBinder::BindExpression(CastExpression &expr, idx_t depth) {
 	// first try to bind the child of the cast expression
-	string error = Bind(&expr.child, depth);
+	string error = Bind(expr.child, depth);
 	if (!error.empty()) {
 		return BindResult(error);
 	}

package/src/duckdb/src/planner/binder/expression/bind_collate_expression.cpp

@@ -6,11 +6,11 @@ namespace duckdb {
 
 BindResult ExpressionBinder::BindExpression(CollateExpression &expr, idx_t depth) {
 	// first try to bind the child of the cast expression
-	string error = Bind(&expr.child, depth);
+	string error = Bind(expr.child, depth);
 	if (!error.empty()) {
 		return BindResult(error);
 	}
-	auto &child = (BoundExpression &)*expr.child;
+	auto &child = expr.child->Cast<BoundExpression>();
 	if (child.expr->HasParameter()) {
 		throw ParameterNotResolvedException();
 	}

package/src/duckdb/src/planner/binder/expression/bind_columnref_expression.cpp

@@ -340,7 +340,7 @@ BindResult ExpressionBinder::BindExpression(ColumnRefExpression &colref_p, idx_t
 	// a generated column returns a generated expression, a struct on a column returns a struct extract
 	if (expr->type != ExpressionType::COLUMN_REF) {
 		auto alias = expr->alias;
-		auto result = BindExpression(&expr, depth);
+		auto result = BindExpression(expr, depth);
 		if (result.expression) {
 			result.expression->alias = std::move(alias);
 		}

package/src/duckdb/src/planner/binder/expression/bind_function_expression.cpp

@@ -15,7 +15,7 @@
 namespace duckdb {
 
 BindResult ExpressionBinder::BindExpression(FunctionExpression &function, idx_t depth,
-                                            unique_ptr<ParsedExpression> *expr_ptr) {
+                                            unique_ptr<ParsedExpression> &expr_ptr) {
 	// lookup the function in the catalog
 	QueryErrorContext error_context(binder.root_statement, function.query_location);
 	auto func = Catalog::GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, function.catalog, function.schema,
@@ -87,7 +87,8 @@ BindResult ExpressionBinder::BindExpression(FunctionExpression &function, idx_t
 	}
 }
 
-BindResult ExpressionBinder::BindFunction(FunctionExpression &function, ScalarFunctionCatalogEntry *func, idx_t depth) {
+BindResult ExpressionBinder::BindFunction(FunctionExpression &function, optional_ptr<ScalarFunctionCatalogEntry> func,
+                                          idx_t depth) {
 
 	// bind the children of the function expression
 	string error;
@@ -122,8 +123,8 @@ BindResult ExpressionBinder::BindFunction(FunctionExpression &function, ScalarFu
 	return BindResult(std::move(result));
 }
 
-BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function, ScalarFunctionCatalogEntry *func,
-                                                idx_t depth) {
+BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function,
+                                                optional_ptr<ScalarFunctionCatalogEntry> func, idx_t depth) {
 
 	// bind the children of the function expression
 	string error;
@@ -140,7 +141,7 @@ BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function, Sc
 	}
 
 	// get the logical type of the children of the list
-	auto &list_child = (BoundExpression &)*function.children[0];
+	auto &list_child = function.children[0]->Cast<BoundExpression>();
 
 	if (list_child.expr->return_type.id() != LogicalTypeId::LIST &&
 	    list_child.expr->return_type.id() != LogicalTypeId::SQLNULL &&
@@ -233,8 +234,8 @@ BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function, Sc
 	return BindResult(std::move(result));
 }
 
-BindResult ExpressionBinder::BindAggregate(FunctionExpression &expr, AggregateFunctionCatalogEntry *function,
-                                           idx_t depth) {
+BindResult ExpressionBinder::BindAggregate(FunctionExpression &expr,
+                                           optional_ptr<AggregateFunctionCatalogEntry> function, idx_t depth) {
 	return BindResult(binder.FormatError(expr, UnsupportedAggregateMessage()));
 }
 

package/src/duckdb/src/planner/binder/expression/bind_lambda.cpp

@@ -78,13 +78,13 @@ BindResult ExpressionBinder::BindExpression(LambdaExpression &expr, idx_t depth,
 
 	// bind the parameter expressions
 	for (idx_t i = 0; i < expr.params.size(); i++) {
-		auto result = BindExpression(&expr.params[i], depth, false);
+		auto result = BindExpression(expr.params[i], depth, false);
 		if (result.HasError()) {
 			throw InternalException("Error during lambda binding: %s", result.error);
 		}
 	}
 
-	auto result = BindExpression(&expr.expr, depth, false);
+	auto result = BindExpression(expr.expr, depth, false);
 	lambda_bindings->pop_back();
 
 	// successfully bound a subtree of nested lambdas, set this to nullptr in case other parts of the

package/src/duckdb/src/planner/binder/expression/bind_macro_expression.cpp

@@ -44,10 +44,10 @@ void ExpressionBinder::ReplaceMacroParametersRecursive(unique_ptr<ParsedExpressi
 	    *expr, [&](unique_ptr<ParsedExpression> &child) { ReplaceMacroParametersRecursive(child); });
 }
 
-BindResult ExpressionBinder::BindMacro(FunctionExpression &function, ScalarMacroCatalogEntry *macro_func, idx_t depth,
-                                       unique_ptr<ParsedExpression> *expr) {
+BindResult ExpressionBinder::BindMacro(FunctionExpression &function, optional_ptr<ScalarMacroCatalogEntry> macro_func,
+                                       idx_t depth, unique_ptr<ParsedExpression> &expr) {
 	// recast function so we can access the scalar member function->expression
-	auto &macro_def = (ScalarMacroFunction &)*macro_func->function;
+	auto &macro_def = macro_func->function->Cast<ScalarMacroFunction>();
 
 	// validate the arguments and separate positional and default arguments
 	vector<unique_ptr<ParsedExpression>> positionals;
@@ -56,7 +56,7 @@ BindResult ExpressionBinder::BindMacro(FunctionExpression &function, ScalarMacro
 	string error =
 	    MacroFunction::ValidateArguments(*macro_func->function, macro_func->name, function, positionals, defaults);
 	if (!error.empty()) {
-		throw BinderException(binder.FormatError(*expr->get(), error));
+		throw BinderException(binder.FormatError(*expr, error));
 	}
 
 	// create a MacroBinding to bind this macro's parameters to its arguments
@@ -80,8 +80,8 @@ BindResult ExpressionBinder::BindMacro(FunctionExpression &function, ScalarMacro
 	macro_binding = new_macro_binding.get();
 
 	// replace current expression with stored macro expression, and replace params
-	*expr = macro_def.expression->Copy();
-	ReplaceMacroParametersRecursive(*expr);
+	expr = macro_def.expression->Copy();
+	ReplaceMacroParametersRecursive(expr);
 
 	// bind the unfolded macro
 	return BindExpression(expr, depth);

package/src/duckdb/src/planner/binder/expression/bind_operator_expression.cpp

@@ -127,8 +127,8 @@ BindResult ExpressionBinder::BindExpression(OperatorExpression &op, idx_t depth)
 		break;
 	}
 	if (!function_name.empty()) {
-		auto function = make_uniq<FunctionExpression>(function_name, std::move(op.children));
-		return BindExpression(*function, depth, nullptr);
+		auto function = make_uniq_base<ParsedExpression, FunctionExpression>(function_name, std::move(op.children));
+		return BindExpression(function, depth, false);
 	}
 
 	vector<BoundExpression *> children;

package/src/duckdb/src/planner/binder/expression/bind_subquery_expression.cpp

@@ -67,7 +67,7 @@ BindResult ExpressionBinder::BindExpression(SubqueryExpression &expr, idx_t dept
 	// now bind the child node of the subquery
 	if (expr.child) {
 		// first bind the children of the subquery, if any
-		string error = Bind(&expr.child, depth);
+		string error = Bind(expr.child, depth);
 		if (!error.empty()) {
 			return BindResult(error);
 		}

package/src/duckdb/src/planner/binder/query_node/bind_table_macro_node.cpp

@@ -19,7 +19,7 @@ namespace duckdb {
 unique_ptr<QueryNode> Binder::BindTableMacro(FunctionExpression &function, TableMacroCatalogEntry *macro_func,
                                              idx_t depth) {
 
-	auto &macro_def = (TableMacroFunction &)*macro_func->function;
+	auto &macro_def = macro_func->function->Cast<TableMacroFunction>();
 	auto node = macro_def.query_node->Copy();
 
 	// auto &macro_def = *macro_func->function;

package/src/duckdb/src/planner/binder/query_node/plan_select_node.cpp

@@ -9,7 +9,7 @@
 namespace duckdb {
 
 unique_ptr<LogicalOperator> Binder::PlanFilter(unique_ptr<Expression> condition, unique_ptr<LogicalOperator> root) {
-	PlanSubqueries(&condition, &root);
+	PlanSubqueries(condition, root);
 	auto filter = make_uniq<LogicalFilter>(std::move(condition));
 	filter->AddChild(std::move(root));
 	return std::move(filter);
@@ -34,12 +34,12 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSelectNode &statement) {
 		if (!statement.groups.group_expressions.empty()) {
 			// visit the groups
 			for (auto &group : statement.groups.group_expressions) {
-				PlanSubqueries(&group, &root);
+				PlanSubqueries(group, root);
 			}
 		}
 		// now visit all aggregate expressions
 		for (auto &expr : statement.aggregates) {
-			PlanSubqueries(&expr, &root);
+			PlanSubqueries(expr, root);
 		}
 		// finally create the aggregate node with the group_index and aggregate_index as obtained from the binder
 		auto aggregate = make_uniq<LogicalAggregate>(statement.group_index, statement.aggregate_index,
@@ -59,7 +59,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSelectNode &statement) {
 	}
 
 	if (statement.having) {
-		PlanSubqueries(&statement.having, &root);
+		PlanSubqueries(statement.having, root);
 		auto having = make_uniq<LogicalFilter>(std::move(statement.having));
 
 		having->AddChild(std::move(root));
@@ -71,7 +71,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSelectNode &statement) {
 		win->expressions = std::move(statement.windows);
 		// visit the window expressions
 		for (auto &expr : win->expressions) {
-			PlanSubqueries(&expr, &root);
+			PlanSubqueries(expr, root);
 		}
 		D_ASSERT(!win->expressions.empty());
 		win->AddChild(std::move(root));
@@ -79,7 +79,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSelectNode &statement) {
 	}
 
 	if (statement.qualify) {
-		PlanSubqueries(&statement.qualify, &root);
+		PlanSubqueries(statement.qualify, root);
 		auto qualify = make_uniq<LogicalFilter>(std::move(statement.qualify));
 
 		qualify->AddChild(std::move(root));
@@ -97,7 +97,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSelectNode &statement) {
 		unnest->expressions = std::move(unnest_node.expressions);
 		// visit the unnest expressions
 		for (auto &expr : unnest->expressions) {
-			PlanSubqueries(&expr, &root);
+			PlanSubqueries(expr, root);
 		}
 		D_ASSERT(!unnest->expressions.empty());
 		unnest->AddChild(std::move(root));
@@ -105,7 +105,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSelectNode &statement) {
 	}
 
 	for (auto &expr : statement.select_list) {
-		PlanSubqueries(&expr, &root);
+		PlanSubqueries(expr, root);
 	}
 
 	auto proj = make_uniq<LogicalProjection>(statement.projection_index, std::move(statement.select_list));

package/src/duckdb/src/planner/binder/query_node/plan_subquery.cpp

@@ -378,14 +378,14 @@ unique_ptr<Expression> Binder::PlanSubquery(BoundSubqueryExpression &expr, uniqu
 	return result_expression;
 }
 
-void Binder::PlanSubqueries(unique_ptr<Expression> *expr_ptr, unique_ptr<LogicalOperator> *root) {
-	if (!*expr_ptr) {
+void Binder::PlanSubqueries(unique_ptr<Expression> &expr_ptr, unique_ptr<LogicalOperator> &root) {
+	if (!expr_ptr) {
 		return;
 	}
-	auto &expr = **expr_ptr;
+	auto &expr = *expr_ptr;
 
 	// first visit the children of the node, if any
-	ExpressionIterator::EnumerateChildren(expr, [&](unique_ptr<Expression> &expr) { PlanSubqueries(&expr, root); });
+	ExpressionIterator::EnumerateChildren(expr, [&](unique_ptr<Expression> &expr) { PlanSubqueries(expr, root); });
 
 	// check if this is a subquery node
 	if (expr.expression_class == ExpressionClass::BOUND_SUBQUERY) {
@@ -398,7 +398,7 @@ void Binder::PlanSubqueries(unique_ptr<Expression> *expr_ptr, unique_ptr<Logical
 			has_unplanned_subqueries = true;
 			return;
 		}
-		*expr_ptr = PlanSubquery(subquery, *root);
+		expr_ptr = PlanSubquery(subquery, root);
 	}
 }
 

package/src/duckdb/src/planner/binder/statement/bind_create.cpp

@@ -161,7 +161,7 @@ static void QualifyFunctionNames(ClientContext &context, unique_ptr<ParsedExpres
 
 SchemaCatalogEntry &Binder::BindCreateFunctionInfo(CreateInfo &info) {
 	auto &base = (CreateMacroInfo &)info;
-	auto &scalar_function = (ScalarMacroFunction &)*base.function;
+	auto &scalar_function = base.function->Cast<ScalarMacroFunction>();
 
 	if (scalar_function.expression->HasParameter()) {
 		throw BinderException("Parameter expressions within macro's are not supported!");
@@ -198,7 +198,7 @@ SchemaCatalogEntry &Binder::BindCreateFunctionInfo(CreateInfo &info) {
 	auto sel_node = make_uniq<BoundSelectNode>();
 	auto group_info = make_uniq<BoundGroupInformation>();
 	SelectBinder binder(*this, context, *sel_node, *group_info);
-	error = binder.Bind(&expression, 0, false);
+	error = binder.Bind(expression, 0, false);
 
 	if (!error.empty()) {
 		throw BinderException(error);

package/src/duckdb/src/planner/binder/statement/bind_delete.cpp

@@ -62,7 +62,7 @@ BoundStatement Binder::Bind(DeleteStatement &stmt) {
 		WhereBinder binder(*this, context);
 		condition = binder.Bind(stmt.condition);
 
-		PlanSubqueries(&condition, &root);
+		PlanSubqueries(condition, root);
 		auto filter = make_uniq<LogicalFilter>(std::move(condition));
 		filter->AddChild(std::move(root));
 		root = std::move(filter);

package/src/duckdb/src/planner/binder/statement/bind_update.cpp

@@ -162,7 +162,7 @@ unique_ptr<LogicalOperator> Binder::BindUpdateSet(LogicalOperator &op, unique_pt
 			UpdateBinder binder(*this, context);
 			binder.target_type = column.Type();
 			auto bound_expr = binder.Bind(expr);
-			PlanSubqueries(&bound_expr, &root);
+			PlanSubqueries(bound_expr, root);
 
 			op.expressions.push_back(make_uniq<BoundColumnRefExpression>(
 			    bound_expr->return_type, ColumnBinding(proj_index, projection_expressions.size())));
@@ -225,7 +225,7 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 		WhereBinder binder(*this, context);
 		auto condition = binder.Bind(stmt.set_info->condition);
 
-		PlanSubqueries(&condition, &root);
+		PlanSubqueries(condition, root);
 		auto filter = make_uniq<LogicalFilter>(std::move(condition));
 		filter->AddChild(std::move(root));
 		root = std::move(filter);

package/src/duckdb/src/planner/binder/tableref/plan_expressionlistref.cpp

@@ -10,7 +10,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundExpressionListRef &ref) {
 	// values list, first plan any subqueries in the list
 	for (auto &expr_list : ref.values) {
 		for (auto &expr : expr_list) {
-			PlanSubqueries(&expr, &root);
+			PlanSubqueries(expr, root);
 		}
 	}
 	// now create a LogicalExpressionGet from the set of expressions

package/src/duckdb/src/planner/binder/tableref/plan_joinref.cpp

@@ -268,7 +268,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundJoinRef &ref) {
 		auto filter = make_uniq<LogicalFilter>(std::move(ref.condition));
 		// visit the expressions in the filter
 		for (auto &expression : filter->expressions) {
-			PlanSubqueries(&expression, &root);
+			PlanSubqueries(expression, root);
 		}
 		filter->AddChild(std::move(root));
 		return std::move(filter);
@@ -288,7 +288,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundJoinRef &ref) {
 		if (child->type == LogicalOperatorType::LOGICAL_FILTER) {
 			auto &filter = child->Cast<LogicalFilter>();
 			for (auto &expr : filter.expressions) {
-				PlanSubqueries(&expr, &filter.children[0]);
+				PlanSubqueries(expr, filter.children[0]);
 			}
 		}
 	}
@@ -302,8 +302,8 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundJoinRef &ref) {
 		// and the expressions on the RHS with the RHS as root node
 		auto &comp_join = join->Cast<LogicalComparisonJoin>();
 		for (idx_t i = 0; i < comp_join.conditions.size(); i++) {
-			PlanSubqueries(&comp_join.conditions[i].left, &comp_join.children[0]);
-			PlanSubqueries(&comp_join.conditions[i].right, &comp_join.children[1]);
+			PlanSubqueries(comp_join.conditions[i].left, comp_join.children[0]);
+			PlanSubqueries(comp_join.conditions[i].right, comp_join.children[1]);
 		}
 		break;
 	}

package/src/duckdb/src/planner/expression.cpp

@@ -51,7 +51,8 @@ bool Expression::HasSideEffects() const {
 bool Expression::PropagatesNullValues() const {
 	if (type == ExpressionType::OPERATOR_IS_NULL || type == ExpressionType::OPERATOR_IS_NOT_NULL ||
 	    type == ExpressionType::COMPARE_NOT_DISTINCT_FROM || type == ExpressionType::COMPARE_DISTINCT_FROM ||
-	    type == ExpressionType::CONJUNCTION_OR || type == ExpressionType::CONJUNCTION_AND) {
+	    type == ExpressionType::CONJUNCTION_OR || type == ExpressionType::CONJUNCTION_AND ||
+	    type == ExpressionType::OPERATOR_COALESCE) {
 		return false;
 	}
 	bool propagate_null_values = true;

package/src/duckdb/src/planner/expression_binder/aggregate_binder.cpp

@@ -7,8 +7,8 @@ namespace duckdb {
 AggregateBinder::AggregateBinder(Binder &binder, ClientContext &context) : ExpressionBinder(binder, context, true) {
 }
 
-BindResult AggregateBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
+BindResult AggregateBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = *expr_ptr;
 	switch (expr.expression_class) {
 	case ExpressionClass::WINDOW:
 		throw ParserException("aggregate function calls cannot contain window function calls");

package/src/duckdb/src/planner/expression_binder/alter_binder.cpp

@@ -12,8 +12,8 @@ AlterBinder::AlterBinder(Binder &binder, ClientContext &context, TableCatalogEnt
 	this->target_type = std::move(target_type);
 }
 
-BindResult AlterBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
+BindResult AlterBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = *expr_ptr;
 	switch (expr.GetExpressionClass()) {
 	case ExpressionClass::WINDOW:
 		return BindResult("window functions are not allowed in alter statement");

package/src/duckdb/src/planner/expression_binder/base_select_binder.cpp

@@ -23,8 +23,8 @@ BaseSelectBinder::BaseSelectBinder(Binder &binder, ClientContext &context, Bound
     : BaseSelectBinder(binder, context, node, info, case_insensitive_map_t<idx_t>()) {
 }
 
-BindResult BaseSelectBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
+BindResult BaseSelectBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = *expr_ptr;
 	// check if the expression binds to one of the groups
 	auto group_index = TryBindGroup(expr, depth);
 	if (group_index != DConstants::INVALID_INDEX) {
@@ -69,7 +69,7 @@ idx_t BaseSelectBinder::TryBindGroup(ParsedExpression &expr, idx_t depth) {
 	return DConstants::INVALID_INDEX;
 }
 
-BindResult BaseSelectBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth) {
+BindResult BaseSelectBinder::BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth) {
 	// first try to bind the column reference regularly
 	auto result = ExpressionBinder::BindExpression(expr_ptr, depth);
 	if (!result.HasError()) {
@@ -77,7 +77,7 @@ BindResult BaseSelectBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_pt
 	}
 	// binding failed
 	// check in the alias map
-	auto &colref = (*expr_ptr)->Cast<ColumnRefExpression>();
+	auto &colref = (expr_ptr.get())->Cast<ColumnRefExpression>();
 	if (!colref.IsQualified()) {
 		auto alias_entry = alias_map.find(colref.column_names[0]);
 		if (alias_entry != alias_map.end()) {

package/src/duckdb/src/planner/expression_binder/check_binder.cpp

@@ -12,8 +12,8 @@ CheckBinder::CheckBinder(Binder &binder, ClientContext &context, string table_p,
 	target_type = LogicalType::INTEGER;
 }
 
-BindResult CheckBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
+BindResult CheckBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = *expr_ptr;
 	switch (expr.GetExpressionClass()) {
 	case ExpressionClass::WINDOW:
 		return BindResult("window functions are not allowed in check constraints");
@@ -39,7 +39,7 @@ BindResult ExpressionBinder::BindQualifiedColumnName(ColumnRefExpression &colref
 	for (idx_t i = struct_start; i + 1 < colref.column_names.size(); i++) {
 		result = CreateStructExtract(std::move(result), colref.column_names[i]);
 	}
-	return BindExpression(&result, 0);
+	return BindExpression(result, 0);
 }
 
 BindResult CheckBinder::BindCheckColumn(ColumnRefExpression &colref) {
@@ -66,7 +66,7 @@ BindResult CheckBinder::BindCheckColumn(ColumnRefExpression &colref) {
 	auto &col = columns.GetColumn(colref.column_names[0]);
 	if (col.Generated()) {
 		auto bound_expression = col.GeneratedExpression().Copy();
-		return BindExpression(&bound_expression, 0, false);
+		return BindExpression(bound_expression, 0, false);
 	}
 	bound_columns.insert(col.Physical());
 	D_ASSERT(col.StorageOid() != DConstants::INVALID_INDEX);

package/src/duckdb/src/planner/expression_binder/column_alias_binder.cpp

@@ -33,7 +33,7 @@ BindResult ColumnAliasBinder::BindAlias(ExpressionBinder &enclosing_binder, Colu
 
 	// since the alias has been found, pass a depth of 0. See Issue 4978 (#16)
 	// ColumnAliasBinders are only in Having, Qualify and Where Binders
-	auto result = enclosing_binder.BindExpression(&expression, 0, root_expression);
+	auto result = enclosing_binder.BindExpression(expression, 0, root_expression);
 	visited_select_indexes.erase(alias_entry->second);
 	return result;
 }

package/src/duckdb/src/planner/expression_binder/constant_binder.cpp

@@ -7,15 +7,15 @@ ConstantBinder::ConstantBinder(Binder &binder, ClientContext &context, string cl
     : ExpressionBinder(binder, context), clause(std::move(clause)) {
 }
 
-BindResult ConstantBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
+BindResult ConstantBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = *expr_ptr;
 	switch (expr.GetExpressionClass()) {
 	case ExpressionClass::COLUMN_REF: {
 		auto &colref = expr.Cast<ColumnRefExpression>();
 		if (!colref.IsQualified()) {
 			auto value_function = GetSQLValueFunction(colref.GetColumnName());
 			if (value_function) {
-				*expr_ptr = std::move(value_function);
+				expr_ptr = std::move(value_function);
 				return BindExpression(expr_ptr, depth, root_expression);
 			}
 		}

package/src/duckdb/src/planner/expression_binder/group_binder.cpp

@@ -14,8 +14,8 @@ GroupBinder::GroupBinder(Binder &binder, ClientContext &context, SelectNode &nod
       group_index(group_index) {
 }
 
-BindResult GroupBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
+BindResult GroupBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = *expr_ptr;
 	if (root_expression && depth == 0) {
 		switch (expr.expression_class) {
 		case ExpressionClass::COLUMN_REF:

package/src/duckdb/src/planner/expression_binder/having_binder.cpp

@@ -15,8 +15,8 @@ HavingBinder::HavingBinder(Binder &binder, ClientContext &context, BoundSelectNo
 	target_type = LogicalType(LogicalTypeId::BOOLEAN);
 }
 
-BindResult HavingBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = (ColumnRefExpression &)**expr_ptr;
+BindResult HavingBinder::BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = expr_ptr->Cast<ColumnRefExpression>();
 	auto alias_result = column_alias_binder.BindAlias(*this, expr, depth, root_expression);
 	if (!alias_result.HasError()) {
 		if (depth > 0) {
@@ -41,8 +41,8 @@ BindResult HavingBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, i
 	    "column %s must appear in the GROUP BY clause or be used in an aggregate function", expr.ToString()));
 }
 
-BindResult HavingBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
+BindResult HavingBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = *expr_ptr;
 	// check if the expression binds to one of the groups
 	auto group_index = TryBindGroup(expr, depth);
 	if (group_index != DConstants::INVALID_INDEX) {

package/src/duckdb/src/planner/expression_binder/index_binder.cpp

@@ -12,8 +12,8 @@ IndexBinder::IndexBinder(Binder &binder, ClientContext &context, optional_ptr<Ta
     : ExpressionBinder(binder, context), table(table), info(info) {
 }
 
-BindResult IndexBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
+BindResult IndexBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = *expr_ptr;
 	switch (expr.expression_class) {
 	case ExpressionClass::WINDOW:
 		return BindResult("window functions are not allowed in index expressions");

package/src/duckdb/src/planner/expression_binder/insert_binder.cpp

@@ -7,8 +7,8 @@ namespace duckdb {
 InsertBinder::InsertBinder(Binder &binder, ClientContext &context) : ExpressionBinder(binder, context) {
 }
 
-BindResult InsertBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
+BindResult InsertBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = *expr_ptr;
 	switch (expr.GetExpressionClass()) {
 	case ExpressionClass::DEFAULT:
 		return BindResult("DEFAULT is not allowed here!");

package/src/duckdb/src/planner/expression_binder/lateral_binder.cpp

@@ -23,7 +23,7 @@ void LateralBinder::ExtractCorrelatedColumns(Expression &expr) {
 	ExpressionIterator::EnumerateChildren(expr, [&](Expression &child) { ExtractCorrelatedColumns(child); });
 }
 
-BindResult LateralBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
+BindResult LateralBinder::BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
 	if (depth == 0) {
 		throw InternalException("Lateral binder can only bind correlated columns");
 	}
@@ -66,8 +66,8 @@ vector<CorrelatedColumnInfo> LateralBinder::ExtractCorrelatedColumns(Binder &bin
 	return all_correlated_columns;
 }
 
-BindResult LateralBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
+BindResult LateralBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = *expr_ptr;
 	switch (expr.GetExpressionClass()) {
 	case ExpressionClass::DEFAULT:
 		return BindResult("LATERAL join cannot contain DEFAULT clause");

package/src/duckdb/src/planner/expression_binder/qualify_binder.cpp

@@ -15,8 +15,8 @@ QualifyBinder::QualifyBinder(Binder &binder, ClientContext &context, BoundSelect
 	target_type = LogicalType(LogicalTypeId::BOOLEAN);
 }
 
-BindResult QualifyBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = (ColumnRefExpression &)**expr_ptr;
+BindResult QualifyBinder::BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = expr_ptr->Cast<ColumnRefExpression>();
 	auto result = duckdb::BaseSelectBinder::BindExpression(expr_ptr, depth);
 	if (!result.HasError()) {
 		return result;
@@ -31,8 +31,8 @@ BindResult QualifyBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr,
 	                                     expr.ToString()));
 }
 
-BindResult QualifyBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
+BindResult QualifyBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = *expr_ptr;
 	// check if the expression binds to one of the groups
 	auto group_index = TryBindGroup(expr, depth);
 	if (group_index != DConstants::INVALID_INDEX) {

package/src/duckdb/src/planner/expression_binder/relation_binder.cpp

@@ -6,8 +6,8 @@ RelationBinder::RelationBinder(Binder &binder, ClientContext &context, string op
     : ExpressionBinder(binder, context), op(std::move(op)) {
 }
 
-BindResult RelationBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = **expr_ptr;
+BindResult RelationBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = *expr_ptr;
 	switch (expr.expression_class) {
 	case ExpressionClass::AGGREGATE:
 		return BindResult("aggregate functions are not allowed in " + op);