duckdb 0.7.2-dev2507.0 → 0.7.2-dev2675.0

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));

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

@@ -57,8 +57,8 @@ BindResult SelectBinder::BindUnnest(FunctionExpression &function, idx_t depth, b
 			if (!error.empty()) {
 				return BindResult(error);
 			}
-			auto &const_child = (BoundExpression &)*function.children[i];
-			auto value = ExpressionExecutor::EvaluateScalar(context, *const_child.expr, true);
+			auto &const_child = BoundExpression::GetExpression(*function.children[i]);
+			auto value = ExpressionExecutor::EvaluateScalar(context, *const_child, true);
 			if (alias == "recursive") {
 				auto recursive = value.GetValue<bool>();
 				if (recursive) {
@@ -90,11 +90,11 @@ BindResult SelectBinder::BindUnnest(FunctionExpression &function, idx_t depth, b
 		if (!BindCorrelatedColumns(function.children[0])) {
 			return BindResult(error);
 		}
-		auto bound_expr = (BoundExpression *)function.children[0].get();
-		ExtractCorrelatedExpressions(binder, *bound_expr->expr);
+		auto &bound_expr = BoundExpression::GetExpression(*function.children[0]);
+		ExtractCorrelatedExpressions(binder, *bound_expr);
 	}
-	auto &child = (BoundExpression &)*function.children[0];
-	auto &child_type = child.expr->return_type;
+	auto &child = BoundExpression::GetExpression(*function.children[0]);
+	auto &child_type = child->return_type;
 	unnest_level--;
 
 	if (unnest_level > 0) {
@@ -116,7 +116,7 @@ BindResult SelectBinder::BindUnnest(FunctionExpression &function, idx_t depth, b
 	idx_t list_unnests;
 	idx_t struct_unnests = 0;
 
-	auto unnest_expr = std::move(child.expr);
+	auto unnest_expr = std::move(child);
 	if (child_type.id() == LogicalTypeId::SQLNULL) {
 		list_unnests = 1;
 	} else {

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

@@ -70,7 +70,7 @@ static unique_ptr<Expression> GetExpression(unique_ptr<ParsedExpression> &expr)
 	}
 	D_ASSERT(expr.get());
 	D_ASSERT(expr->expression_class == ExpressionClass::BOUND_EXPRESSION);
-	return std::move(((BoundExpression &)*expr).expr);
+	return std::move(BoundExpression::GetExpression(*expr));
 }
 
 static unique_ptr<Expression> CastWindowExpression(unique_ptr<ParsedExpression> &expr, const LogicalType &type) {
@@ -80,10 +80,10 @@ static unique_ptr<Expression> CastWindowExpression(unique_ptr<ParsedExpression>
 	D_ASSERT(expr.get());
 	D_ASSERT(expr->expression_class == ExpressionClass::BOUND_EXPRESSION);
 
-	auto &bound = (BoundExpression &)*expr;
-	bound.expr = BoundCastExpression::AddDefaultCastToType(std::move(bound.expr), type);
+	auto &bound = BoundExpression::GetExpression(*expr);
+	bound = BoundCastExpression::AddDefaultCastToType(std::move(bound), type);
 
-	return std::move(bound.expr);
+	return std::move(bound);
 }
 
 static LogicalType BindRangeExpression(ClientContext &context, const string &name, unique_ptr<ParsedExpression> &expr,
@@ -93,13 +93,13 @@ static LogicalType BindRangeExpression(ClientContext &context, const string &nam
 
 	D_ASSERT(order_expr.get());
 	D_ASSERT(order_expr->expression_class == ExpressionClass::BOUND_EXPRESSION);
-	auto &bound_order = (BoundExpression &)*order_expr;
-	children.emplace_back(bound_order.expr->Copy());
+	auto &bound_order = BoundExpression::GetExpression(*order_expr);
+	children.emplace_back(bound_order->Copy());
 
 	D_ASSERT(expr.get());
 	D_ASSERT(expr->expression_class == ExpressionClass::BOUND_EXPRESSION);
-	auto &bound = (BoundExpression &)*expr;
-	children.emplace_back(std::move(bound.expr));
+	auto &bound = BoundExpression::GetExpression(*expr);
+	children.emplace_back(std::move(bound));
 
 	string error;
 	FunctionBinder function_binder(context);
@@ -107,8 +107,8 @@ static LogicalType BindRangeExpression(ClientContext &context, const string &nam
 	if (!function) {
 		throw BinderException(error);
 	}
-	bound.expr = std::move(function);
-	return bound.expr->return_type;
+	bound = std::move(function);
+	return bound->return_type;
 }
 
 BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
@@ -157,26 +157,26 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 	for (auto &child : window.children) {
 		D_ASSERT(child.get());
 		D_ASSERT(child->expression_class == ExpressionClass::BOUND_EXPRESSION);
-		auto &bound = (BoundExpression &)*child;
+		auto &bound = BoundExpression::GetExpression(*child);
 		// Add casts for positional arguments
 		const auto argno = children.size();
 		switch (window.type) {
 		case ExpressionType::WINDOW_NTILE:
 			// ntile(bigint)
 			if (argno == 0) {
-				bound.expr = BoundCastExpression::AddCastToType(context, std::move(bound.expr), LogicalType::BIGINT);
+				bound = BoundCastExpression::AddCastToType(context, std::move(bound), LogicalType::BIGINT);
 			}
 			break;
 		case ExpressionType::WINDOW_NTH_VALUE:
 			// nth_value(<expr>, index)
 			if (argno == 1) {
-				bound.expr = BoundCastExpression::AddCastToType(context, std::move(bound.expr), LogicalType::BIGINT);
+				bound = BoundCastExpression::AddCastToType(context, std::move(bound), LogicalType::BIGINT);
 			}
 		default:
 			break;
 		}
-		types.push_back(bound.expr->return_type);
-		children.push_back(std::move(bound.expr));
+		types.push_back(bound->return_type);
+		children.push_back(std::move(bound));
 	}
 	//  Determine the function type.
 	LogicalType sql_type;
@@ -184,19 +184,19 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 	unique_ptr<FunctionData> bind_info;
 	if (window.type == ExpressionType::WINDOW_AGGREGATE) {
 		//  Look up the aggregate function in the catalog
-		auto func = Catalog::GetEntry<AggregateFunctionCatalogEntry>(context, window.catalog, window.schema,
-		                                                             window.function_name, false, error_context);
-		D_ASSERT(func->type == CatalogType::AGGREGATE_FUNCTION_ENTRY);
+		auto &func = Catalog::GetEntry<AggregateFunctionCatalogEntry>(context, window.catalog, window.schema,
+		                                                              window.function_name, error_context);
+		D_ASSERT(func.type == CatalogType::AGGREGATE_FUNCTION_ENTRY);
 
 		// bind the aggregate
 		string error;
 		FunctionBinder function_binder(context);
-		auto best_function = function_binder.BindFunction(func->name, func->functions, types, error);
+		auto best_function = function_binder.BindFunction(func.name, func.functions, types, error);
 		if (best_function == DConstants::INVALID_INDEX) {
 			throw BinderException(binder.FormatError(window, error));
 		}
 		// found a matching function! bind it as an aggregate
-		auto bound_function = func->functions.GetFunctionByOffset(best_function);
+		auto bound_function = func.functions.GetFunctionByOffset(best_function);
 		auto bound_aggregate = function_binder.BindAggregateFunction(bound_function, std::move(children));
 		// create the aggregate
 		aggregate = make_uniq<AggregateFunction>(bound_aggregate->function);
@@ -253,8 +253,8 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 		auto &order_expr = window.orders[0].expression;
 		D_ASSERT(order_expr.get());
 		D_ASSERT(order_expr->expression_class == ExpressionClass::BOUND_EXPRESSION);
-		auto &bound_order = (BoundExpression &)*order_expr;
-		auto order_type = bound_order.expr->return_type;
+		auto &bound_order = BoundExpression::GetExpression(*order_expr);
+		auto order_type = bound_order->return_type;
 		if (window.start_expr) {
 			order_type = LogicalType::MaxLogicalType(order_type, start_type);
 		}
@@ -263,7 +263,7 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 		}
 
 		// Cast all three to match
-		bound_order.expr = BoundCastExpression::AddCastToType(context, std::move(bound_order.expr), order_type);
+		bound_order = BoundCastExpression::AddCastToType(context, std::move(bound_order), order_type);
 		start_type = end_type = order_type;
 	}
 

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

@@ -16,10 +16,10 @@
 
 namespace duckdb {
 
-unique_ptr<QueryNode> Binder::BindTableMacro(FunctionExpression &function, TableMacroCatalogEntry *macro_func,
+unique_ptr<QueryNode> Binder::BindTableMacro(FunctionExpression &function, TableMacroCatalogEntry &macro_func,
                                              idx_t depth) {
 
-	auto &macro_def = macro_func->function->Cast<TableMacroFunction>();
+	auto &macro_def = macro_func.function->Cast<TableMacroFunction>();
 	auto node = macro_def.query_node->Copy();
 
 	// auto &macro_def = *macro_func->function;
@@ -28,7 +28,7 @@ unique_ptr<QueryNode> Binder::BindTableMacro(FunctionExpression &function, Table
 	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()) {
 		// cannot use error below as binder rnot in scope
 		// return BindResult(binder. FormatError(*expr->get(), error));
@@ -51,7 +51,7 @@ unique_ptr<QueryNode> Binder::BindTableMacro(FunctionExpression &function, Table
 		// 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;
 
 	// We need an ExpressionBinder so that we can call ExpressionBinder::ReplaceMacroParametersRecursive()

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

@@ -63,17 +63,17 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt) {
 	result.names = {"Count"};
 
 	// lookup the format in the catalog
-	auto copy_function =
+	auto &copy_function =
 	    Catalog::GetEntry<CopyFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, stmt.info->format);
-	if (copy_function->function.plan) {
+	if (copy_function.function.plan) {
 		// plan rewrite COPY TO
-		return copy_function->function.plan(*this, stmt);
+		return copy_function.function.plan(*this, stmt);
 	}
 
 	// bind the select statement
 	auto select_node = Bind(*stmt.select_statement);
 
-	if (!copy_function->function.copy_to_bind) {
+	if (!copy_function.function.copy_to_bind) {
 		throw NotImplementedException("COPY TO is not supported for FORMAT \"%s\"", stmt.info->format);
 	}
 	bool use_tmp_file = true;
@@ -138,9 +138,9 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt) {
 	auto unique_column_names = GetUniqueNames(select_node.names);
 
 	auto function_data =
-	    copy_function->function.copy_to_bind(context, *stmt.info, unique_column_names, select_node.types);
+	    copy_function.function.copy_to_bind(context, *stmt.info, unique_column_names, select_node.types);
 	// now create the copy information
-	auto copy = make_uniq<LogicalCopyToFile>(copy_function->function, std::move(function_data));
+	auto copy = make_uniq<LogicalCopyToFile>(copy_function.function, std::move(function_data));
 	copy->file_path = stmt.info->file_path;
 	copy->use_tmp_file = use_tmp_file;
 	copy->overwrite_or_ignore = overwrite_or_ignore;
@@ -187,17 +187,18 @@ BoundStatement Binder::BindCopyFrom(CopyStatement &stmt) {
 
 	// lookup the format in the catalog
 	auto &catalog = Catalog::GetSystemCatalog(context);
-	auto copy_function = catalog.GetEntry<CopyFunctionCatalogEntry>(context, DEFAULT_SCHEMA, stmt.info->format);
-	if (!copy_function->function.copy_from_bind) {
+	auto &copy_function = catalog.GetEntry<CopyFunctionCatalogEntry>(context, DEFAULT_SCHEMA, stmt.info->format);
+	if (!copy_function.function.copy_from_bind) {
 		throw NotImplementedException("COPY FROM is not supported for FORMAT \"%s\"", stmt.info->format);
 	}
 	// lookup the table to copy into
 	BindSchemaOrCatalog(stmt.info->catalog, stmt.info->schema);
-	auto table = Catalog::GetEntry<TableCatalogEntry>(context, stmt.info->catalog, stmt.info->schema, stmt.info->table);
+	auto &table =
+	    Catalog::GetEntry<TableCatalogEntry>(context, stmt.info->catalog, stmt.info->schema, stmt.info->table);
 	vector<string> expected_names;
 	if (!bound_insert.column_index_map.empty()) {
 		expected_names.resize(bound_insert.expected_types.size());
-		for (auto &col : table->GetColumns().Physical()) {
+		for (auto &col : table.GetColumns().Physical()) {
 			auto i = col.Physical();
 			if (bound_insert.column_index_map[i] != DConstants::INVALID_INDEX) {
 				expected_names[bound_insert.column_index_map[i]] = col.Name();
@@ -205,14 +206,14 @@ BoundStatement Binder::BindCopyFrom(CopyStatement &stmt) {
 		}
 	} else {
 		expected_names.reserve(bound_insert.expected_types.size());
-		for (auto &col : table->GetColumns().Physical()) {
+		for (auto &col : table.GetColumns().Physical()) {
 			expected_names.push_back(col.Name());
 		}
 	}
 
 	auto function_data =
-	    copy_function->function.copy_from_bind(context, *stmt.info, expected_names, bound_insert.expected_types);
-	auto get = make_uniq<LogicalGet>(GenerateTableIndex(), copy_function->function.copy_from_function,
+	    copy_function.function.copy_from_bind(context, *stmt.info, expected_names, bound_insert.expected_types);
+	auto get = make_uniq<LogicalGet>(GenerateTableIndex(), copy_function.function.copy_from_function,
 	                                 std::move(function_data), bound_insert.expected_types, expected_names);
 	for (idx_t i = 0; i < bound_insert.expected_types.size(); i++) {
 		get->column_ids.push_back(i);