duckdb 0.7.2-dev2430.0 → 0.7.2-dev2552.0

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

@@ -18,44 +18,44 @@ BindResult ExpressionBinder::BindExpression(BetweenExpression &expr, idx_t depth
 		return BindResult(error);
 	}
 	// the children have been successfully resolved
-	auto &input = (BoundExpression &)*expr.input;
-	auto &lower = (BoundExpression &)*expr.lower;
-	auto &upper = (BoundExpression &)*expr.upper;
+	auto &input = BoundExpression::GetExpression(*expr.input);
+	auto &lower = BoundExpression::GetExpression(*expr.lower);
+	auto &upper = BoundExpression::GetExpression(*expr.upper);
 
-	auto input_sql_type = input.expr->return_type;
-	auto lower_sql_type = lower.expr->return_type;
-	auto upper_sql_type = upper.expr->return_type;
+	auto input_sql_type = input->return_type;
+	auto lower_sql_type = lower->return_type;
+	auto upper_sql_type = upper->return_type;
 
 	// cast the input types to the same type
 	// now obtain the result type of the input types
 	auto input_type = BoundComparisonExpression::BindComparison(input_sql_type, lower_sql_type);
 	input_type = BoundComparisonExpression::BindComparison(input_type, upper_sql_type);
 	// add casts (if necessary)
-	input.expr = BoundCastExpression::AddCastToType(context, std::move(input.expr), input_type);
-	lower.expr = BoundCastExpression::AddCastToType(context, std::move(lower.expr), input_type);
-	upper.expr = BoundCastExpression::AddCastToType(context, std::move(upper.expr), input_type);
+	input = BoundCastExpression::AddCastToType(context, std::move(input), input_type);
+	lower = BoundCastExpression::AddCastToType(context, std::move(lower), input_type);
+	upper = BoundCastExpression::AddCastToType(context, std::move(upper), input_type);
 	if (input_type.id() == LogicalTypeId::VARCHAR) {
 		// handle collation
 		auto collation = StringType::GetCollation(input_type);
-		input.expr = PushCollation(context, std::move(input.expr), collation, false);
-		lower.expr = PushCollation(context, std::move(lower.expr), collation, false);
-		upper.expr = PushCollation(context, std::move(upper.expr), collation, false);
+		input = PushCollation(context, std::move(input), collation, false);
+		lower = PushCollation(context, std::move(lower), collation, false);
+		upper = PushCollation(context, std::move(upper), collation, false);
 	}
-	if (!input.expr->HasSideEffects() && !input.expr->HasParameter() && !input.expr->HasSubquery()) {
+	if (!input->HasSideEffects() && !input->HasParameter() && !input->HasSubquery()) {
 		// the expression does not have side effects and can be copied: create two comparisons
 		// the reason we do this is that individual comparisons are easier to handle in optimizers
 		// if both comparisons remain they will be folded together again into a single BETWEEN in the optimizer
 		auto left_compare = make_uniq<BoundComparisonExpression>(ExpressionType::COMPARE_GREATERTHANOREQUALTO,
-		                                                         input.expr->Copy(), std::move(lower.expr));
+		                                                         input->Copy(), std::move(lower));
 		auto right_compare = make_uniq<BoundComparisonExpression>(ExpressionType::COMPARE_LESSTHANOREQUALTO,
-		                                                          std::move(input.expr), std::move(upper.expr));
+		                                                          std::move(input), std::move(upper));
 		return BindResult(make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND,
 		                                                        std::move(left_compare), std::move(right_compare)));
 	} else {
 		// expression has side effects: we cannot duplicate it
 		// create a bound_between directly
-		return BindResult(make_uniq<BoundBetweenExpression>(std::move(input.expr), std::move(lower.expr),
-		                                                    std::move(upper.expr), true, true));
+		return BindResult(
+		    make_uniq<BoundBetweenExpression>(std::move(input), std::move(lower), std::move(upper), true, true));
 	}
 }
 

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

@@ -18,26 +18,26 @@ BindResult ExpressionBinder::BindExpression(CaseExpression &expr, idx_t depth) {
 	}
 	// the children have been successfully resolved
 	// figure out the result type of the CASE expression
-	auto return_type = ((BoundExpression &)*expr.else_expr).expr->return_type;
+	auto &else_expr = BoundExpression::GetExpression(*expr.else_expr);
+	auto return_type = else_expr->return_type;
 	for (auto &check : expr.case_checks) {
-		auto &then_expr = (BoundExpression &)*check.then_expr;
-		return_type = LogicalType::MaxLogicalType(return_type, then_expr.expr->return_type);
+		auto &then_expr = BoundExpression::GetExpression(*check.then_expr);
+		return_type = LogicalType::MaxLogicalType(return_type, then_expr->return_type);
 	}
 
 	// bind all the individual components of the CASE statement
 	auto result = make_uniq<BoundCaseExpression>(return_type);
 	for (idx_t i = 0; i < expr.case_checks.size(); i++) {
 		auto &check = expr.case_checks[i];
-		auto &when_expr = (BoundExpression &)*check.when_expr;
-		auto &then_expr = (BoundExpression &)*check.then_expr;
+		auto &when_expr = BoundExpression::GetExpression(*check.when_expr);
+		auto &then_expr = BoundExpression::GetExpression(*check.then_expr);
 		BoundCaseCheck result_check;
 		result_check.when_expr =
-		    BoundCastExpression::AddCastToType(context, std::move(when_expr.expr), LogicalType::BOOLEAN);
-		result_check.then_expr = BoundCastExpression::AddCastToType(context, std::move(then_expr.expr), return_type);
+		    BoundCastExpression::AddCastToType(context, std::move(when_expr), LogicalType::BOOLEAN);
+		result_check.then_expr = BoundCastExpression::AddCastToType(context, std::move(then_expr), return_type);
 		result->case_checks.push_back(std::move(result_check));
 	}
-	auto &else_expr = (BoundExpression &)*expr.else_expr;
-	result->else_expr = BoundCastExpression::AddCastToType(context, std::move(else_expr.expr), return_type);
+	result->else_expr = BoundCastExpression::AddCastToType(context, std::move(else_expr), return_type);
 	return BindResult(std::move(result));
 }
 } // namespace duckdb

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

@@ -16,17 +16,17 @@ BindResult ExpressionBinder::BindExpression(CastExpression &expr, idx_t depth) {
 	// Right now just considering its DEFAULT_SCHEMA always
 	Binder::BindLogicalType(context, expr.cast_type);
 	// the children have been successfully resolved
-	auto &child = (BoundExpression &)*expr.child;
+	auto &child = BoundExpression::GetExpression(*expr.child);
 	if (expr.try_cast) {
-		if (child.expr->return_type == expr.cast_type) {
+		if (child->return_type == expr.cast_type) {
 			// no cast required: type matches
-			return BindResult(std::move(child.expr));
+			return BindResult(std::move(child));
 		}
-		child.expr = BoundCastExpression::AddCastToType(context, std::move(child.expr), expr.cast_type, true);
+		child = BoundCastExpression::AddCastToType(context, std::move(child), expr.cast_type, true);
 	} else {
 		// otherwise add a cast to the target type
-		child.expr = BoundCastExpression::AddCastToType(context, std::move(child.expr), expr.cast_type);
+		child = BoundCastExpression::AddCastToType(context, std::move(child), expr.cast_type);
 	}
-	return BindResult(std::move(child.expr));
+	return BindResult(std::move(child));
 }
 } // namespace duckdb

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

@@ -10,17 +10,17 @@ BindResult ExpressionBinder::BindExpression(CollateExpression &expr, idx_t depth
 	if (!error.empty()) {
 		return BindResult(error);
 	}
-	auto &child = expr.child->Cast<BoundExpression>();
-	if (child.expr->HasParameter()) {
+	auto &child = BoundExpression::GetExpression(*expr.child);
+	if (child->HasParameter()) {
 		throw ParameterNotResolvedException();
 	}
-	if (child.expr->return_type.id() != LogicalTypeId::VARCHAR) {
+	if (child->return_type.id() != LogicalTypeId::VARCHAR) {
 		throw BinderException("collations are only supported for type varchar");
 	}
 	// Validate the collation, but don't use it
-	PushCollation(context, child.expr->Copy(), expr.collation, false);
-	child.expr->return_type = LogicalType::VARCHAR_COLLATION(expr.collation);
-	return BindResult(std::move(child.expr));
+	PushCollation(context, child->Copy(), expr.collation, false);
+	child->return_type = LogicalType::VARCHAR_COLLATION(expr.collation);
+	return BindResult(std::move(child));
 }
 
 } // namespace duckdb

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

@@ -204,13 +204,13 @@ unique_ptr<ParsedExpression> ExpressionBinder::CreateStructPack(ColumnRefExpress
 		}
 		if (colref.column_names.size() == 2) {
 			auto &qualifier = colref.column_names[0];
-			if (catalog_entry->catalog->GetName() != qualifier && catalog_entry->schema->name != qualifier) {
+			if (catalog_entry->catalog.GetName() != qualifier && catalog_entry->schema.name != qualifier) {
 				return nullptr;
 			}
 		} else if (colref.column_names.size() == 3) {
 			auto &catalog_name = colref.column_names[0];
 			auto &schema_name = colref.column_names[1];
-			if (catalog_entry->catalog->GetName() != catalog_name || catalog_entry->schema->name != schema_name) {
+			if (catalog_entry->catalog.GetName() != catalog_name || catalog_entry->schema.name != schema_name) {
 				return nullptr;
 			}
 		} else {

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

@@ -35,28 +35,29 @@ unique_ptr<Expression> ExpressionBinder::PushCollation(ClientContext &context, u
 	}
 	auto &catalog = Catalog::GetSystemCatalog(context);
 	auto splits = StringUtil::Split(StringUtil::Lower(collation), ".");
-	vector<CollateCatalogEntry *> entries;
+	vector<reference<CollateCatalogEntry>> entries;
 	for (auto &collation_argument : splits) {
-		auto collation_entry = catalog.GetEntry<CollateCatalogEntry>(context, DEFAULT_SCHEMA, collation_argument);
-		if (collation_entry->combinable) {
+		auto &collation_entry = catalog.GetEntry<CollateCatalogEntry>(context, DEFAULT_SCHEMA, collation_argument);
+		if (collation_entry.combinable) {
 			entries.insert(entries.begin(), collation_entry);
 		} else {
-			if (!entries.empty() && !entries.back()->combinable) {
-				throw BinderException("Cannot combine collation types \"%s\" and \"%s\"", entries.back()->name,
-				                      collation_entry->name);
+			if (!entries.empty() && !entries.back().get().combinable) {
+				throw BinderException("Cannot combine collation types \"%s\" and \"%s\"", entries.back().get().name,
+				                      collation_entry.name);
 			}
 			entries.push_back(collation_entry);
 		}
 	}
-	for (auto &collation_entry : entries) {
-		if (equality_only && collation_entry->not_required_for_equality) {
+	for (auto &entry : entries) {
+		auto &collation_entry = entry.get();
+		if (equality_only && collation_entry.not_required_for_equality) {
 			continue;
 		}
 		vector<unique_ptr<Expression>> children;
 		children.push_back(std::move(source));
 
 		FunctionBinder function_binder(context);
-		auto function = function_binder.BindScalarFunction(collation_entry->function, std::move(children));
+		auto function = function_binder.BindScalarFunction(collation_entry.function, std::move(children));
 		source = std::move(function);
 	}
 	return source;
@@ -119,28 +120,27 @@ BindResult ExpressionBinder::BindExpression(ComparisonExpression &expr, idx_t de
 		return BindResult(error);
 	}
 	// the children have been successfully resolved
-	auto &left = (BoundExpression &)*expr.left;
-	auto &right = (BoundExpression &)*expr.right;
-	auto left_sql_type = left.expr->return_type;
-	auto right_sql_type = right.expr->return_type;
+	auto &left = BoundExpression::GetExpression(*expr.left);
+	auto &right = BoundExpression::GetExpression(*expr.right);
+	auto left_sql_type = left->return_type;
+	auto right_sql_type = right->return_type;
 	// cast the input types to the same type
 	// now obtain the result type of the input types
 	auto input_type = BoundComparisonExpression::BindComparison(left_sql_type, right_sql_type);
 	// add casts (if necessary)
-	left.expr = BoundCastExpression::AddCastToType(context, std::move(left.expr), input_type,
-	                                               input_type.id() == LogicalTypeId::ENUM);
-	right.expr = BoundCastExpression::AddCastToType(context, std::move(right.expr), input_type,
-	                                                input_type.id() == LogicalTypeId::ENUM);
+	left = BoundCastExpression::AddCastToType(context, std::move(left), input_type,
+	                                          input_type.id() == LogicalTypeId::ENUM);
+	right = BoundCastExpression::AddCastToType(context, std::move(right), input_type,
+	                                           input_type.id() == LogicalTypeId::ENUM);
 
 	if (input_type.id() == LogicalTypeId::VARCHAR) {
 		// handle collation
 		auto collation = StringType::GetCollation(input_type);
-		left.expr = PushCollation(context, std::move(left.expr), collation, expr.type == ExpressionType::COMPARE_EQUAL);
-		right.expr =
-		    PushCollation(context, std::move(right.expr), collation, expr.type == ExpressionType::COMPARE_EQUAL);
+		left = PushCollation(context, std::move(left), collation, expr.type == ExpressionType::COMPARE_EQUAL);
+		right = PushCollation(context, std::move(right), collation, expr.type == ExpressionType::COMPARE_EQUAL);
 	}
 	// now create the bound comparison expression
-	return BindResult(make_uniq<BoundComparisonExpression>(expr.type, std::move(left.expr), std::move(right.expr)));
+	return BindResult(make_uniq<BoundComparisonExpression>(expr.type, std::move(left), std::move(right)));
 }
 
 } // namespace duckdb

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

@@ -19,9 +19,8 @@ BindResult ExpressionBinder::BindExpression(ConjunctionExpression &expr, idx_t d
 	// and construct the bound conjunction expression
 	auto result = make_uniq<BoundConjunctionExpression>(expr.type);
 	for (auto &child_expr : expr.children) {
-		auto &child = (BoundExpression &)*child_expr;
-		result->children.push_back(
-		    BoundCastExpression::AddCastToType(context, std::move(child.expr), LogicalType::BOOLEAN));
+		auto &child = BoundExpression::GetExpression(*child_expr);
+		result->children.push_back(BoundCastExpression::AddCastToType(context, std::move(child), LogicalType::BOOLEAN));
 	}
 	// now create the bound conjunction expression
 	return BindResult(std::move(result));

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

@@ -1,5 +1,7 @@
 #include "duckdb/catalog/catalog.hpp"
+#include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/function/function_binder.hpp"
 #include "duckdb/parser/expression/function_expression.hpp"
@@ -19,11 +21,12 @@ BindResult ExpressionBinder::BindExpression(FunctionExpression &function, idx_t
 	// 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,
-	                              function.function_name, true, error_context);
+	                              function.function_name, OnEntryNotFound::RETURN_NULL, error_context);
 	if (!func) {
 		// function was not found - check if we this is a table function
-		auto table_func = Catalog::GetEntry(context, CatalogType::TABLE_FUNCTION_ENTRY, function.catalog,
-		                                    function.schema, function.function_name, true, error_context);
+		auto table_func =
+		    Catalog::GetEntry(context, CatalogType::TABLE_FUNCTION_ENTRY, function.catalog, function.schema,
+		                      function.function_name, OnEntryNotFound::RETURN_NULL, error_context);
 		if (table_func) {
 			throw BinderException(binder.FormatError(
 			    function,
@@ -52,7 +55,7 @@ BindResult ExpressionBinder::BindExpression(FunctionExpression &function, idx_t
 		}
 		// rebind the function
 		func = Catalog::GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, function.catalog, function.schema,
-		                         function.function_name, false, error_context);
+		                         function.function_name, OnEntryNotFound::THROW_EXCEPTION, error_context);
 	}
 
 	if (func->type != CatalogType::AGGREGATE_FUNCTION_ENTRY &&
@@ -70,25 +73,24 @@ BindResult ExpressionBinder::BindExpression(FunctionExpression &function, idx_t
 		if (function.function_name != "->>") {
 			for (auto &child : function.children) {
 				if (child->expression_class == ExpressionClass::LAMBDA) {
-					return BindLambdaFunction(function, (ScalarFunctionCatalogEntry *)func, depth);
+					return BindLambdaFunction(function, func->Cast<ScalarFunctionCatalogEntry>(), depth);
 				}
 			}
 		}
 
 		// other scalar function
-		return BindFunction(function, (ScalarFunctionCatalogEntry *)func, depth);
+		return BindFunction(function, func->Cast<ScalarFunctionCatalogEntry>(), depth);
 
 	case CatalogType::MACRO_ENTRY:
 		// macro function
-		return BindMacro(function, (ScalarMacroCatalogEntry *)func, depth, expr_ptr);
+		return BindMacro(function, func->Cast<ScalarMacroCatalogEntry>(), depth, expr_ptr);
 	default:
 		// aggregate function
-		return BindAggregate(function, (AggregateFunctionCatalogEntry *)func, depth);
+		return BindAggregate(function, func->Cast<AggregateFunctionCatalogEntry>(), depth);
 	}
 }
 
-BindResult ExpressionBinder::BindFunction(FunctionExpression &function, optional_ptr<ScalarFunctionCatalogEntry> func,
-                                          idx_t depth) {
+BindResult ExpressionBinder::BindFunction(FunctionExpression &function, ScalarFunctionCatalogEntry &func, idx_t depth) {
 
 	// bind the children of the function expression
 	string error;
@@ -109,22 +111,21 @@ BindResult ExpressionBinder::BindFunction(FunctionExpression &function, optional
 	// extract the children and types
 	vector<unique_ptr<Expression>> children;
 	for (idx_t i = 0; i < function.children.size(); i++) {
-		auto &child = (BoundExpression &)*function.children[i];
-		D_ASSERT(child.expr);
-		children.push_back(std::move(child.expr));
+		auto &child = BoundExpression::GetExpression(*function.children[i]);
+		children.push_back(std::move(child));
 	}
 
 	FunctionBinder function_binder(context);
 	unique_ptr<Expression> result =
-	    function_binder.BindScalarFunction(*func, std::move(children), error, function.is_operator, &binder);
+	    function_binder.BindScalarFunction(func, std::move(children), error, function.is_operator, &binder);
 	if (!result) {
 		throw BinderException(binder.FormatError(function, error));
 	}
 	return BindResult(std::move(result));
 }
 
-BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function,
-                                                optional_ptr<ScalarFunctionCatalogEntry> func, idx_t depth) {
+BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function, ScalarFunctionCatalogEntry &func,
+                                                idx_t depth) {
 
 	// bind the children of the function expression
 	string error;
@@ -141,18 +142,16 @@ BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function,
 	}
 
 	// get the logical type of the children of the list
-	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 &&
-	    list_child.expr->return_type.id() != LogicalTypeId::UNKNOWN) {
+	auto &list_child = BoundExpression::GetExpression(*function.children[0]);
+	if (list_child->return_type.id() != LogicalTypeId::LIST && list_child->return_type.id() != LogicalTypeId::SQLNULL &&
+	    list_child->return_type.id() != LogicalTypeId::UNKNOWN) {
 		throw BinderException(" Invalid LIST argument to " + function.function_name + "!");
 	}
 
-	LogicalType list_child_type = list_child.expr->return_type.id();
-	if (list_child.expr->return_type.id() != LogicalTypeId::SQLNULL &&
-	    list_child.expr->return_type.id() != LogicalTypeId::UNKNOWN) {
-		list_child_type = ListType::GetChildType(list_child.expr->return_type);
+	LogicalType list_child_type = list_child->return_type.id();
+	if (list_child->return_type.id() != LogicalTypeId::SQLNULL &&
+	    list_child->return_type.id() != LogicalTypeId::UNKNOWN) {
+		list_child_type = ListType::GetChildType(list_child->return_type);
 	}
 
 	// bind the lambda parameter
@@ -164,12 +163,11 @@ BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function,
 	} else {
 		// successfully bound: replace the node with a BoundExpression
 		auto alias = function.children[1]->alias;
-		function.children[1] = make_uniq<BoundExpression>(std::move(bind_lambda_result.expression));
-		auto &be = function.children[1]->Cast<BoundExpression>();
-		be.alias = alias;
+		bind_lambda_result.expression->alias = alias;
 		if (!alias.empty()) {
-			be.expr->alias = alias;
+			bind_lambda_result.expression->alias = alias;
 		}
+		function.children[1] = make_uniq<BoundExpression>(std::move(bind_lambda_result.expression));
 	}
 
 	if (!error.empty()) {
@@ -183,9 +181,8 @@ BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function,
 	// extract the children and types
 	vector<unique_ptr<Expression>> children;
 	for (idx_t i = 0; i < function.children.size(); i++) {
-		auto &child = (BoundExpression &)*function.children[i];
-		D_ASSERT(child.expr);
-		children.push_back(std::move(child.expr));
+		auto &child = BoundExpression::GetExpression(*function.children[i]);
+		children.push_back(std::move(child));
 	}
 
 	// capture the (lambda) columns
@@ -194,7 +191,7 @@ BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function,
 
 	FunctionBinder function_binder(context);
 	unique_ptr<Expression> result =
-	    function_binder.BindScalarFunction(*func, std::move(children), error, function.is_operator, &binder);
+	    function_binder.BindScalarFunction(func, std::move(children), error, function.is_operator, &binder);
 	if (!result) {
 		throw BinderException(binder.FormatError(function, error));
 	}
@@ -205,7 +202,7 @@ BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function,
 	// remove the lambda expression from the children
 	auto lambda = std::move(bound_function_expr.children.back());
 	bound_function_expr.children.pop_back();
-	auto &bound_lambda = (BoundLambdaExpression &)*lambda;
+	auto &bound_lambda = lambda->Cast<BoundLambdaExpression>();
 
 	// push back (in reverse order) any nested lambda parameters so that we can later use them in the lambda expression
 	// (rhs)
@@ -234,8 +231,8 @@ BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function,
 	return BindResult(std::move(result));
 }
 
-BindResult ExpressionBinder::BindAggregate(FunctionExpression &expr,
-                                           optional_ptr<AggregateFunctionCatalogEntry> function, idx_t depth) {
+BindResult ExpressionBinder::BindAggregate(FunctionExpression &expr, AggregateFunctionCatalogEntry &function,
+                                           idx_t depth) {
 	return BindResult(binder.FormatError(expr, UnsupportedAggregateMessage()));
 }
 

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

@@ -44,17 +44,17 @@ void ExpressionBinder::ReplaceMacroParametersRecursive(unique_ptr<ParsedExpressi
 	    *expr, [&](unique_ptr<ParsedExpression> &child) { ReplaceMacroParametersRecursive(child); });
 }
 
-BindResult ExpressionBinder::BindMacro(FunctionExpression &function, optional_ptr<ScalarMacroCatalogEntry> macro_func,
-                                       idx_t depth, unique_ptr<ParsedExpression> &expr) {
+BindResult ExpressionBinder::BindMacro(FunctionExpression &function, ScalarMacroCatalogEntry &macro_func, idx_t depth,
+                                       unique_ptr<ParsedExpression> &expr) {
 	// recast function so we can access the scalar member function->expression
-	auto &macro_def = macro_func->function->Cast<ScalarMacroFunction>();
+	auto &macro_def = macro_func.function->Cast<ScalarMacroFunction>();
 
 	// validate the arguments and separate positional and default arguments
 	vector<unique_ptr<ParsedExpression>> positionals;
 	unordered_map<string, unique_ptr<ParsedExpression>> defaults;
 
 	string error =
-	    MacroFunction::ValidateArguments(*macro_func->function, macro_func->name, function, positionals, defaults);
+	    MacroFunction::ValidateArguments(*macro_func.function, macro_func.name, function, positionals, defaults);
 	if (!error.empty()) {
 		throw BinderException(binder.FormatError(*expr, error));
 	}
@@ -75,7 +75,7 @@ BindResult ExpressionBinder::BindMacro(FunctionExpression &function, optional_pt
 		// now push the defaults into the positionals
 		positionals.push_back(std::move(defaults[it->first]));
 	}
-	auto new_macro_binding = make_uniq<DummyBinding>(types, names, macro_func->name);
+	auto new_macro_binding = make_uniq<DummyBinding>(types, names, macro_func.name);
 	new_macro_binding->arguments = &positionals;
 	macro_binding = new_macro_binding.get();
 

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

@@ -8,27 +8,27 @@
 
 namespace duckdb {
 
-static LogicalType ResolveNotType(OperatorExpression &op, vector<BoundExpression *> &children) {
+static LogicalType ResolveNotType(OperatorExpression &op, vector<unique_ptr<Expression>> &children) {
 	// NOT expression, cast child to BOOLEAN
 	D_ASSERT(children.size() == 1);
-	children[0]->expr = BoundCastExpression::AddDefaultCastToType(std::move(children[0]->expr), LogicalType::BOOLEAN);
+	children[0] = BoundCastExpression::AddDefaultCastToType(std::move(children[0]), LogicalType::BOOLEAN);
 	return LogicalType(LogicalTypeId::BOOLEAN);
 }
 
-static LogicalType ResolveInType(OperatorExpression &op, vector<BoundExpression *> &children) {
+static LogicalType ResolveInType(OperatorExpression &op, vector<unique_ptr<Expression>> &children) {
 	if (children.empty()) {
 		throw InternalException("IN requires at least a single child node");
 	}
 	// get the maximum type from the children
-	LogicalType max_type = children[0]->expr->return_type;
-	bool any_varchar = children[0]->expr->return_type == LogicalType::VARCHAR;
-	bool any_enum = children[0]->expr->return_type.id() == LogicalTypeId::ENUM;
+	LogicalType max_type = children[0]->return_type;
+	bool any_varchar = children[0]->return_type == LogicalType::VARCHAR;
+	bool any_enum = children[0]->return_type.id() == LogicalTypeId::ENUM;
 	for (idx_t i = 1; i < children.size(); i++) {
-		max_type = LogicalType::MaxLogicalType(max_type, children[i]->expr->return_type);
-		if (children[i]->expr->return_type == LogicalType::VARCHAR) {
+		max_type = LogicalType::MaxLogicalType(max_type, children[i]->return_type);
+		if (children[i]->return_type == LogicalType::VARCHAR) {
 			any_varchar = true;
 		}
-		if (children[i]->expr->return_type.id() == LogicalTypeId::ENUM) {
+		if (children[i]->return_type.id() == LogicalTypeId::ENUM) {
 			any_enum = true;
 		}
 	}
@@ -40,18 +40,18 @@ static LogicalType ResolveInType(OperatorExpression &op, vector<BoundExpression
 
 	// cast all children to the same type
 	for (idx_t i = 0; i < children.size(); i++) {
-		children[i]->expr = BoundCastExpression::AddDefaultCastToType(std::move(children[i]->expr), max_type);
+		children[i] = BoundCastExpression::AddDefaultCastToType(std::move(children[i]), max_type);
 	}
 	// (NOT) IN always returns a boolean
 	return LogicalType::BOOLEAN;
 }
 
-static LogicalType ResolveOperatorType(OperatorExpression &op, vector<BoundExpression *> &children) {
+static LogicalType ResolveOperatorType(OperatorExpression &op, vector<unique_ptr<Expression>> &children) {
 	switch (op.type) {
 	case ExpressionType::OPERATOR_IS_NULL:
 	case ExpressionType::OPERATOR_IS_NOT_NULL:
 		// IS (NOT) NULL always returns a boolean, and does not cast its children
-		if (!children[0]->expr->return_type.IsValid()) {
+		if (!children[0]->return_type.IsValid()) {
 			throw ParameterNotResolvedException();
 		}
 		return LogicalType::BOOLEAN;
@@ -60,7 +60,7 @@ static LogicalType ResolveOperatorType(OperatorExpression &op, vector<BoundExpre
 		return ResolveInType(op, children);
 	case ExpressionType::OPERATOR_COALESCE: {
 		ResolveInType(op, children);
-		return children[0]->expr->return_type;
+		return children[0]->return_type;
 	}
 	case ExpressionType::OPERATOR_NOT:
 		return ResolveNotType(op, children);
@@ -90,8 +90,8 @@ BindResult ExpressionBinder::BindExpression(OperatorExpression &op, idx_t depth)
 	switch (op.type) {
 	case ExpressionType::ARRAY_EXTRACT: {
 		D_ASSERT(op.children[0]->expression_class == ExpressionClass::BOUND_EXPRESSION);
-		auto &b_exp = (BoundExpression &)*op.children[0];
-		if (b_exp.expr->return_type.id() == LogicalTypeId::MAP) {
+		auto &b_exp = BoundExpression::GetExpression(*op.children[0]);
+		if (b_exp->return_type.id() == LogicalTypeId::MAP) {
 			function_name = "map_extract";
 		} else {
 			function_name = "array_extract";
@@ -105,14 +105,14 @@ BindResult ExpressionBinder::BindExpression(OperatorExpression &op, idx_t depth)
 		D_ASSERT(op.children.size() == 2);
 		D_ASSERT(op.children[0]->expression_class == ExpressionClass::BOUND_EXPRESSION);
 		D_ASSERT(op.children[1]->expression_class == ExpressionClass::BOUND_EXPRESSION);
-		auto &extract_exp = (BoundExpression &)*op.children[0];
-		auto &name_exp = (BoundExpression &)*op.children[1];
-		auto extract_expr_type = extract_exp.expr->return_type.id();
+		auto &extract_exp = BoundExpression::GetExpression(*op.children[0]);
+		auto &name_exp = BoundExpression::GetExpression(*op.children[1]);
+		auto extract_expr_type = extract_exp->return_type.id();
 		if (extract_expr_type != LogicalTypeId::STRUCT && extract_expr_type != LogicalTypeId::UNION &&
 		    extract_expr_type != LogicalTypeId::SQLNULL) {
 			return BindResult(StringUtil::Format(
 			    "Cannot extract field %s from expression \"%s\" because it is not a struct or a union",
-			    name_exp.ToString(), extract_exp.ToString()));
+			    name_exp->ToString(), extract_exp->ToString()));
 		}
 		function_name = extract_expr_type == LogicalTypeId::UNION ? "union_extract" : "struct_extract";
 		break;
@@ -131,10 +131,10 @@ BindResult ExpressionBinder::BindExpression(OperatorExpression &op, idx_t depth)
 		return BindExpression(function, depth, false);
 	}
 
-	vector<BoundExpression *> children;
+	vector<unique_ptr<Expression>> children;
 	for (idx_t i = 0; i < op.children.size(); i++) {
 		D_ASSERT(op.children[i]->expression_class == ExpressionClass::BOUND_EXPRESSION);
-		children.push_back((BoundExpression *)op.children[i].get());
+		children.push_back(std::move(BoundExpression::GetExpression(*op.children[i])));
 	}
 	// now resolve the types
 	LogicalType result_type = ResolveOperatorType(op, children);
@@ -143,13 +143,13 @@ BindResult ExpressionBinder::BindExpression(OperatorExpression &op, idx_t depth)
 			throw BinderException("COALESCE needs at least one child");
 		}
 		if (children.size() == 1) {
-			return BindResult(std::move(children[0]->expr));
+			return BindResult(std::move(children[0]));
 		}
 	}
 
 	auto result = make_uniq<BoundOperatorExpression>(op.type, result_type);
 	for (auto &child : children) {
-		result->children.push_back(std::move(child->expr));
+		result->children.push_back(std::move(child));
 	}
 	return BindResult(std::move(result));
 }

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

@@ -75,7 +75,6 @@ BindResult ExpressionBinder::BindExpression(SubqueryExpression &expr, idx_t dept
 	// both binding the child and binding the subquery was successful
 	D_ASSERT(expr.subquery->node->type == QueryNodeType::BOUND_SUBQUERY_NODE);
 	auto bound_subquery = (BoundSubqueryNode *)expr.subquery->node.get();
-	auto child = (BoundExpression *)expr.child.get();
 	auto subquery_binder = std::move(bound_subquery->subquery_binder);
 	auto bound_node = std::move(bound_subquery->bound_node);
 	LogicalType return_type =
@@ -89,15 +88,16 @@ BindResult ExpressionBinder::BindExpression(SubqueryExpression &expr, idx_t dept
 		// ANY comparison
 		// cast child and subquery child to equivalent types
 		D_ASSERT(bound_node->types.size() == 1);
-		auto compare_type = LogicalType::MaxLogicalType(child->expr->return_type, bound_node->types[0]);
-		child->expr = BoundCastExpression::AddCastToType(context, std::move(child->expr), compare_type);
+		auto &child = BoundExpression::GetExpression(*expr.child);
+		auto compare_type = LogicalType::MaxLogicalType(child->return_type, bound_node->types[0]);
+		child = BoundCastExpression::AddCastToType(context, std::move(child), compare_type);
 		result->child_type = bound_node->types[0];
 		result->child_target = compare_type;
+		result->child = std::move(child);
 	}
 	result->binder = std::move(subquery_binder);
 	result->subquery = std::move(bound_node);
 	result->subquery_type = expr.subquery_type;
-	result->child = child ? std::move(child->expr) : nullptr;
 	result->comparison_type = expr.comparison_type;
 
 	return BindResult(std::move(result));