duckdb 1.0.1-dev21.0 → 1.0.1-dev27.0

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

@@ -14,19 +14,18 @@ void ExpressionBinder::ReplaceMacroParametersInLambda(FunctionExpression &functi
 
 	for (auto &child : function.children) {
 		if (child->expression_class != ExpressionClass::LAMBDA) {
-			// not a lambda expression
 			ReplaceMacroParameters(child, lambda_params);
 			continue;
 		}
 
-		// special-handling for LHS lambda parameters
-		// we do not replace them, and we add them to the lambda_params vector
+		// Special-handling for LHS lambda parameters.
+		// We do not replace them, and we add them to the lambda_params vector.
 		auto &lambda_expr = child->Cast<LambdaExpression>();
 		string error_message;
 		auto column_ref_expressions = lambda_expr.ExtractColumnRefExpressions(error_message);
 
 		if (!error_message.empty()) {
-			// possibly a JSON function, replace both LHS and RHS
+			// Possibly a JSON function, replace both LHS and RHS.
 			ParsedExpressionIterator::EnumerateChildren(*lambda_expr.lhs, [&](unique_ptr<ParsedExpression> &child) {
 				ReplaceMacroParameters(child, lambda_params);
 			});
@@ -36,21 +35,18 @@ void ExpressionBinder::ReplaceMacroParametersInLambda(FunctionExpression &functi
 			continue;
 		}
 
-		// push this level
+		// Push the lambda parameter names of this level.
 		lambda_params.emplace_back();
-
-		// push the lambda parameter names
 		for (const auto &column_ref_expr : column_ref_expressions) {
 			const auto &column_ref = column_ref_expr.get().Cast<ColumnRefExpression>();
 			lambda_params.back().emplace(column_ref.GetName());
 		}
 
-		// only replace in RHS
+		// Only replace in the RHS of the expression.
 		ParsedExpressionIterator::EnumerateChildren(*lambda_expr.expr, [&](unique_ptr<ParsedExpression> &child) {
 			ReplaceMacroParameters(child, lambda_params);
 		});
 
-		// pop this level
 		lambda_params.pop_back();
 	}
 }
@@ -60,10 +56,8 @@ void ExpressionBinder::ReplaceMacroParameters(unique_ptr<ParsedExpression> &expr
 
 	switch (expr->GetExpressionClass()) {
 	case ExpressionClass::COLUMN_REF: {
-		// if the expression is a parameter, replace it with its argument
+		// If the expression is a column reference, we replace it with its argument.
 		auto &col_ref = expr->Cast<ColumnRefExpression>();
-
-		// don't replace lambda parameters
 		if (LambdaExpression::IsLambdaParameter(lambda_params, col_ref.GetName())) {
 			return;
 		}
@@ -84,10 +78,9 @@ void ExpressionBinder::ReplaceMacroParameters(unique_ptr<ParsedExpression> &expr
 		return;
 	}
 	case ExpressionClass::FUNCTION: {
-		// special-handling for lambdas, which are inside function expressions,
+		// Special-handling for lambdas, which are inside function expressions.
 		auto &function = expr->Cast<FunctionExpression>();
-		if (IsLambdaFunction(function)) {
-			// special case
+		if (function.IsLambdaFunction()) {
 			return ReplaceMacroParametersInLambda(function, lambda_params);
 		}
 		break;
@@ -98,30 +91,26 @@ void ExpressionBinder::ReplaceMacroParameters(unique_ptr<ParsedExpression> &expr
 		    *sq->node, [&](unique_ptr<ParsedExpression> &child) { ReplaceMacroParameters(child, lambda_params); });
 		break;
 	}
-	default: // fall through
+	default:
 		break;
 	}
 
-	// replace macro parameters in child expressions
 	ParsedExpressionIterator::EnumerateChildren(
 	    *expr, [&](unique_ptr<ParsedExpression> &child) { ReplaceMacroParameters(child, lambda_params); });
 }
 
-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>();
-
+void ExpressionBinder::UnfoldMacroExpression(FunctionExpression &function, ScalarMacroCatalogEntry &macro_func,
+                                             unique_ptr<ParsedExpression> &expr) {
 	// 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);
-	if (!error.empty()) {
-		throw BinderException(*expr, error);
+	auto bind_result =
+	    MacroFunction::BindMacroFunction(macro_func.macros, macro_func.name, function, positionals, defaults);
+	if (!bind_result.error.empty()) {
+		throw BinderException(*expr, bind_result.error);
 	}
+	auto &macro_def = macro_func.macros[bind_result.function_idx.GetIndex()]->Cast<ScalarMacroFunction>();
 
 	// create a MacroBinding to bind this macro's parameters to its arguments
 	vector<LogicalType> types;
@@ -154,6 +143,14 @@ BindResult ExpressionBinder::BindMacro(FunctionExpression &function, ScalarMacro
 	// now replace the parameters
 	vector<unordered_set<string>> lambda_params;
 	ReplaceMacroParameters(expr, lambda_params);
+}
+
+BindResult ExpressionBinder::BindMacro(FunctionExpression &function, ScalarMacroCatalogEntry &macro_func, idx_t depth,
+                                       unique_ptr<ParsedExpression> &expr) {
+	auto stack_checker = StackCheck(*expr, 3);
+
+	// unfold the macro expression
+	UnfoldMacroExpression(function, macro_func, expr);
 
 	// bind the unfolded macro
 	return BindExpression(expr, depth);

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

@@ -18,7 +18,7 @@ LogicalType ExpressionBinder::ResolveNotType(OperatorExpression &op, vector<uniq
 	return LogicalType(LogicalTypeId::BOOLEAN);
 }
 
-LogicalType ExpressionBinder::ResolveInType(OperatorExpression &op, vector<unique_ptr<Expression>> &children) {
+LogicalType ExpressionBinder::ResolveCoalesceType(OperatorExpression &op, vector<unique_ptr<Expression>> &children) {
 	if (children.empty()) {
 		throw InternalException("IN requires at least a single child node");
 	}
@@ -50,11 +50,10 @@ LogicalType ExpressionBinder::ResolveInType(OperatorExpression &op, vector<uniqu
 		child = BoundCastExpression::AddCastToType(context, std::move(child), max_type);
 		if (is_in_operator) {
 			// If it's IN/NOT_IN operator, push collation functions.
-			ExpressionBinder::PushCollation(context, child, max_type, true);
+			ExpressionBinder::PushCollation(context, child, max_type);
 		}
 	}
-	// (NOT) IN always returns a boolean
-	return LogicalType::BOOLEAN;
+	return max_type;
 }
 
 LogicalType ExpressionBinder::ResolveOperatorType(OperatorExpression &op, vector<unique_ptr<Expression>> &children) {
@@ -68,10 +67,11 @@ LogicalType ExpressionBinder::ResolveOperatorType(OperatorExpression &op, vector
 		return LogicalType::BOOLEAN;
 	case ExpressionType::COMPARE_IN:
 	case ExpressionType::COMPARE_NOT_IN:
-		return ResolveInType(op, children);
+		ResolveCoalesceType(op, children);
+		// (NOT) IN always returns a boolean
+		return LogicalType::BOOLEAN;
 	case ExpressionType::OPERATOR_COALESCE: {
-		ResolveInType(op, children);
-		return children[0]->return_type;
+		return ResolveCoalesceType(op, children);
 	}
 	case ExpressionType::OPERATOR_NOT:
 		return ResolveNotType(op, children);

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

@@ -1,5 +1,6 @@
 #include "duckdb/parser/expression/parameter_expression.hpp"
 #include "duckdb/planner/binder.hpp"
+#include "duckdb/planner/expression/bound_cast_expression.hpp"
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
 #include "duckdb/planner/expression/bound_parameter_expression.hpp"
 #include "duckdb/planner/expression_binder.hpp"
@@ -19,10 +20,16 @@ BindResult ExpressionBinder::BindExpression(ParameterExpression &expr, idx_t dep
 	if (param_data_it != parameter_data.end()) {
 		// it has! emit a constant directly
 		auto &data = param_data_it->second;
+		auto return_type = binder.parameters->GetReturnType(parameter_id);
+		bool is_literal =
+		    return_type.id() == LogicalTypeId::INTEGER_LITERAL || return_type.id() == LogicalTypeId::STRING_LITERAL;
 		auto constant = make_uniq<BoundConstantExpression>(data.GetValue());
 		constant->alias = expr.alias;
-		constant->return_type = binder.parameters->GetReturnType(parameter_id);
-		return BindResult(std::move(constant));
+		if (is_literal) {
+			return BindResult(std::move(constant));
+		}
+		auto cast = BoundCastExpression::AddCastToType(context, std::move(constant), return_type);
+		return BindResult(std::move(cast));
 	}
 
 	auto bound_parameter = binder.parameters->BindParameterExpression(expr);

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

@@ -7,6 +7,7 @@
 #include "duckdb/parser/parsed_expression_iterator.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/function/scalar/regexp.hpp"
+#include "duckdb/parser/expression/function_expression.hpp"
 
 namespace duckdb {
 
@@ -24,30 +25,36 @@ bool Binder::FindStarExpression(unique_ptr<ParsedExpression> &expr, StarExpressi
 	bool has_star = false;
 	if (expr->GetExpressionClass() == ExpressionClass::STAR) {
 		auto &current_star = expr->Cast<StarExpression>();
-		if (!current_star.columns) {
+		if (StarExpression::IsStar(*expr)) {
 			if (is_root) {
+				D_ASSERT(!in_columns);
+				// At the root level
 				*star = &current_star;
 				return true;
 			}
+
 			if (!in_columns) {
+				// '*' can only appear inside COLUMNS or at the root level
 				throw BinderException(
 				    "STAR expression is only allowed as the root element of an expression. Use COLUMNS(*) instead.");
 			}
-			// star expression inside a COLUMNS - convert to a constant list
+
 			if (!current_star.replace_list.empty()) {
+				// '*' inside COLUMNS can not have a REPLACE list
 				throw BinderException(
 				    "STAR expression with REPLACE list is only allowed as the root element of COLUMNS");
 			}
+
+			// '*' expression inside a COLUMNS - convert to a constant list of strings (column names)
 			vector<unique_ptr<ParsedExpression>> star_list;
 			bind_context.GenerateAllColumnExpressions(current_star, star_list);
 
 			vector<Value> values;
 			values.reserve(star_list.size());
-			for (auto &expr : star_list) {
-				values.emplace_back(GetColumnsStringValue(*expr));
+			for (auto &element : star_list) {
+				values.emplace_back(GetColumnsStringValue(*element));
 			}
 			D_ASSERT(!values.empty());
-
 			expr = make_uniq<ConstantExpression>(Value::LIST(LogicalType::VARCHAR, values));
 			return true;
 		}
@@ -55,6 +62,7 @@ bool Binder::FindStarExpression(unique_ptr<ParsedExpression> &expr, StarExpressi
 			throw BinderException("COLUMNS expression is not allowed inside another COLUMNS expression");
 		}
 		in_columns = true;
+
 		if (*star) {
 			// we can have multiple
 			if (!(*star)->Equals(current_star)) {
@@ -76,7 +84,7 @@ bool Binder::FindStarExpression(unique_ptr<ParsedExpression> &expr, StarExpressi
 
 void Binder::ReplaceStarExpression(unique_ptr<ParsedExpression> &expr, unique_ptr<ParsedExpression> &replacement) {
 	D_ASSERT(expr);
-	if (expr->GetExpressionClass() == ExpressionClass::STAR) {
+	if (StarExpression::IsColumns(*expr) || StarExpression::IsStar(*expr)) {
 		D_ASSERT(replacement);
 		auto alias = expr->alias;
 		expr = replacement->Copy();
@@ -195,6 +203,9 @@ void Binder::ExpandStarExpression(unique_ptr<ParsedExpression> expr,
 			// scan the list for all selected columns and construct a lookup table
 			case_insensitive_map_t<bool> selected_set;
 			for (auto &child : children) {
+				if (child.IsNull()) {
+					throw BinderException(*star, "Columns expression does not support NULL input parameters");
+				}
 				selected_set.insert(make_pair(StringValue::Get(child), false));
 			}
 			// now check the list of all possible expressions and select which ones make it in
@@ -221,10 +232,18 @@ void Binder::ExpandStarExpression(unique_ptr<ParsedExpression> expr,
 	}
 
 	// now perform the replacement
+	if (StarExpression::IsColumnsUnpacked(*star)) {
+		if (StarExpression::IsColumnsUnpacked(*expr)) {
+			throw BinderException("*COLUMNS not allowed at the root level, use COLUMNS instead");
+		}
+		ReplaceUnpackedStarExpression(expr, star_list);
+		new_select_list.push_back(std::move(expr));
+		return;
+	}
 	for (idx_t i = 0; i < star_list.size(); i++) {
 		auto new_expr = expr->Copy();
 		ReplaceStarExpression(new_expr, star_list[i]);
-		if (star->columns) {
+		if (StarExpression::IsColumns(*star)) {
 			optional_ptr<ParsedExpression> expr = star_list[i].get();
 			while (expr) {
 				if (expr->type == ExpressionType::COLUMN_REF) {

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

@@ -57,6 +57,11 @@ BindResult SelectBinder::BindUnnest(FunctionExpression &function, idx_t depth, b
 		return BindResult(BinderException(function, UnsupportedUnnestMessage()));
 	}
 
+	if (function.distinct || function.filter || !function.order_bys->orders.empty()) {
+		throw InvalidInputException("\"DISTINCT\", \"FILTER\", and \"ORDER BY\" are not "
+		                            "applicable to \"UNNEST\"");
+	}
+
 	idx_t max_depth = 1;
 	if (function.children.size() != 1) {
 		bool has_parameter = false;

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

@@ -0,0 +1,91 @@
+#include "duckdb/planner/binder.hpp"
+#include "duckdb/parser/expression/star_expression.hpp"
+#include "duckdb/parser/expression/operator_expression.hpp"
+#include "duckdb/parser/expression/function_expression.hpp"
+#include "duckdb/parser/parsed_expression_iterator.hpp"
+
+namespace duckdb {
+
+using expression_list_t = vector<unique_ptr<ParsedExpression>>;
+
+static void AddChild(unique_ptr<ParsedExpression> &child, expression_list_t &new_children,
+                     expression_list_t &replacements) {
+	if (!StarExpression::IsColumnsUnpacked(*child)) {
+		// Just add the child directly
+		new_children.push_back(std::move(child));
+		return;
+	}
+	// Replace the child with the replacement expression(s)
+	for (auto &replacement : replacements) {
+		new_children.push_back(replacement->Copy());
+	}
+}
+
+static void ReplaceInFunction(unique_ptr<ParsedExpression> &expr, expression_list_t &star_list) {
+	auto &function_expr = expr->Cast<FunctionExpression>();
+
+	// Replace children
+	expression_list_t new_children;
+	for (auto &child : function_expr.children) {
+		AddChild(child, new_children, star_list);
+	}
+	function_expr.children = std::move(new_children);
+
+	// Replace ORDER_BY
+	if (function_expr.order_bys) {
+		expression_list_t new_orders;
+		for (auto &order : function_expr.order_bys->orders) {
+			AddChild(order.expression, new_orders, star_list);
+		}
+		if (new_orders.size() != function_expr.order_bys->orders.size()) {
+			throw NotImplementedException("*COLUMNS(...) is not supported in the order expression");
+		}
+		for (idx_t i = 0; i < new_orders.size(); i++) {
+			auto &new_order = new_orders[i];
+			function_expr.order_bys->orders[i].expression = std::move(new_order);
+		}
+	}
+}
+
+static void ReplaceInOperator(unique_ptr<ParsedExpression> &expr, expression_list_t &star_list) {
+	auto &operator_expr = expr->Cast<OperatorExpression>();
+
+	// Replace children
+	expression_list_t new_children;
+	for (auto &child : operator_expr.children) {
+		AddChild(child, new_children, star_list);
+	}
+	operator_expr.children = std::move(new_children);
+}
+
+void Binder::ReplaceUnpackedStarExpression(unique_ptr<ParsedExpression> &expr, expression_list_t &star_list) {
+	D_ASSERT(expr);
+	auto expression_class = expr->GetExpressionClass();
+	// Replace *COLUMNS(...) in the supported places
+	switch (expression_class) {
+	case ExpressionClass::STAR: {
+		if (!StarExpression::IsColumnsUnpacked(*expr)) {
+			break;
+		}
+		// Deal with any *COLUMNS that was not replaced
+		throw BinderException("*COLUMNS() can not be used in this place");
+	}
+	case ExpressionClass::FUNCTION: {
+		ReplaceInFunction(expr, star_list);
+		break;
+	}
+	case ExpressionClass::OPERATOR: {
+		ReplaceInOperator(expr, star_list);
+		break;
+	}
+	default: {
+		break;
+	}
+	}
+
+	// Visit the children of this expression, collecting the unpacked expressions
+	ParsedExpressionIterator::EnumerateChildren(
+	    *expr, [&](unique_ptr<ParsedExpression> &child_expr) { ReplaceUnpackedStarExpression(child_expr, star_list); });
+}
+
+} // namespace duckdb

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

@@ -202,12 +202,12 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 	//	Restore any collation expressions
 	for (auto &part_expr : window.partitions) {
 		auto &bound_partition = BoundExpression::GetExpression(*part_expr);
-		ExpressionBinder::PushCollation(context, bound_partition, bound_partition->return_type, true);
+		ExpressionBinder::PushCollation(context, bound_partition, bound_partition->return_type);
 	}
 	for (auto &order : window.orders) {
 		auto &order_expr = order.expression;
 		auto &bound_order = BoundExpression::GetExpression(*order_expr);
-		ExpressionBinder::PushCollation(context, bound_order, bound_order->return_type, false);
+		ExpressionBinder::PushCollation(context, bound_order, bound_order->return_type);
 	}
 	// successfully bound all children: create bound window function
 	vector<LogicalType> types;

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

@@ -8,9 +8,12 @@
 #include "duckdb/parser/expression/comparison_expression.hpp"
 #include "duckdb/parser/expression/conjunction_expression.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
+#include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/parser/expression/star_expression.hpp"
 #include "duckdb/parser/expression/subquery_expression.hpp"
+#include "duckdb/parser/parsed_expression_iterator.hpp"
 #include "duckdb/parser/query_node/select_node.hpp"
+#include "duckdb/parser/tableref/basetableref.hpp"
 #include "duckdb/parser/tableref/joinref.hpp"
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
@@ -22,12 +25,10 @@
 #include "duckdb/planner/expression_binder/having_binder.hpp"
 #include "duckdb/planner/expression_binder/order_binder.hpp"
 #include "duckdb/planner/expression_binder/qualify_binder.hpp"
+#include "duckdb/planner/expression_binder/select_bind_state.hpp"
 #include "duckdb/planner/expression_binder/select_binder.hpp"
 #include "duckdb/planner/expression_binder/where_binder.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/planner/query_node/bound_select_node.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/planner/expression_binder/select_bind_state.hpp"
 
 namespace duckdb {
 
@@ -200,7 +201,7 @@ void Binder::PrepareModifiers(OrderBinder &order_binder, QueryNode &statement, B
 #endif
 			for (auto &order_node : order.orders) {
 				vector<unique_ptr<ParsedExpression>> order_list;
-				order_binders[0]->ExpandStarExpression(std::move(order_node.expression), order_list);
+				order_binders[0].get().ExpandStarExpression(std::move(order_node.expression), order_list);
 
 				auto type = config.ResolveOrder(order_node.type);
 				auto null_order = config.ResolveNullOrder(type, order_node.null_order);
@@ -314,7 +315,7 @@ void Binder::BindModifiers(BoundQueryNode &result, idx_t table_index, const vect
 				}
 			}
 			for (auto &expr : distinct.target_distincts) {
-				ExpressionBinder::PushCollation(context, expr, expr->return_type, true);
+				ExpressionBinder::PushCollation(context, expr, expr->return_type);
 			}
 			break;
 		}
@@ -361,6 +362,7 @@ void Binder::BindModifiers(BoundQueryNode &result, idx_t table_index, const vect
 
 unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
 	D_ASSERT(statement.from_table);
+
 	// first bind the FROM table statement
 	auto from = std::move(statement.from_table);
 	auto from_table = Bind(*from);
@@ -451,7 +453,7 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 	}
 
 	// now bind all the result modifiers; including DISTINCT and ORDER BY targets
-	OrderBinder order_binder({this}, statement, bind_state);
+	OrderBinder order_binder({*this}, statement, bind_state);
 	PrepareModifiers(order_binder, statement, *result);
 
 	vector<unique_ptr<ParsedExpression>> unbound_groups;
@@ -480,19 +482,20 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 			bool contains_subquery = bound_expr_ref.HasSubquery();
 
 			// push a potential collation, if necessary
-			bool requires_collation = ExpressionBinder::PushCollation(context, bound_expr, group_type, true);
+			bool requires_collation = ExpressionBinder::PushCollation(context, bound_expr, group_type);
 			if (!contains_subquery && requires_collation) {
 				// if there is a collation on a group x, we should group by the collated expr,
 				// but also push a first(x) aggregate in case x is selected (uncollated)
 				info.collated_groups[i] = result->aggregates.size();
 
-				auto first_fun = FirstFun::GetFunction(LogicalType::VARCHAR);
+				auto first_fun = FirstFun::GetFunction(bound_expr_ref.return_type);
 				vector<unique_ptr<Expression>> first_children;
 				// FIXME: would be better to just refer to this expression, but for now we copy
 				first_children.push_back(bound_expr_ref.Copy());
 
 				FunctionBinder function_binder(context);
 				auto function = function_binder.BindAggregateFunction(first_fun, std::move(first_children));
+				function->alias = "__collated_group";
 				result->aggregates.push_back(std::move(function));
 			}
 			result->groups.group_expressions.push_back(std::move(bound_expr));

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

@@ -247,7 +247,7 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SetOperationNode &statement) {
 			GatherAliases(*result, bind_state, reorder_idx);
 		}
 		// now we perform the actual resolution of the ORDER BY/DISTINCT expressions
-		OrderBinder order_binder({result->left_binder.get(), result->right_binder.get()}, bind_state);
+		OrderBinder order_binder({*result->left_binder, *result->right_binder}, bind_state);
 		PrepareModifiers(order_binder, statement, *result);
 	}
 

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

@@ -18,22 +18,18 @@ namespace duckdb {
 
 unique_ptr<QueryNode> Binder::BindTableMacro(FunctionExpression &function, TableMacroCatalogEntry &macro_func,
                                              idx_t depth) {
-
-	auto &macro_def = macro_func.function->Cast<TableMacroFunction>();
-	auto node = macro_def.query_node->Copy();
-
-	// auto &macro_def = *macro_func->function;
-
 	// 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);
-	if (!error.empty()) {
+	auto bind_result =
+	    MacroFunction::BindMacroFunction(macro_func.macros, macro_func.name, function, positionals, defaults);
+	if (!bind_result.error.empty()) {
 		// cannot use error below as binder rnot in scope
 		// return BindResult(binder. FormatError(*expr->get(), error));
-		throw BinderException(function, error);
+		throw BinderException(function, bind_result.error);
 	}
+	auto &macro_def = macro_func.macros[bind_result.function_idx.GetIndex()]->Cast<TableMacroFunction>();
+	auto node = macro_def.query_node->Copy();
 
 	// create a MacroBinding to bind this macro's parameters to its arguments
 	vector<LogicalType> types;

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

@@ -26,30 +26,34 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundCTENode &node) {
 unique_ptr<LogicalOperator> Binder::CreatePlan(BoundCTENode &node, unique_ptr<LogicalOperator> base) {
 	// Generate the logical plan for the cte_query and child.
 	auto cte_query = CreatePlan(*node.query);
-	unique_ptr<LogicalOperator> cte_child;
+	unique_ptr<LogicalOperator> root;
 	if (node.child && node.child->type == QueryNodeType::CTE_NODE) {
-		cte_child = CreatePlan(node.child->Cast<BoundCTENode>(), std::move(base));
+		root = CreatePlan(node.child->Cast<BoundCTENode>(), std::move(base));
 	} else if (node.child) {
-		cte_child = CreatePlan(*node.child);
+		root = CreatePlan(*node.child);
 	} else {
-		cte_child = std::move(base);
+		root = std::move(base);
 	}
 
 	// Only keep the materialized CTE, if it is used
 	if (node.child_binder->bind_context.cte_references[node.ctename] &&
 	    *node.child_binder->bind_context.cte_references[node.ctename] > 0) {
-		auto root = make_uniq<LogicalMaterializedCTE>(node.ctename, node.setop_index, node.types.size(),
-		                                              std::move(cte_query), std::move(cte_child));
+
+		// Push the CTE through single-child operators so query modifiers appear ABOVE the CTE (internal issue #2652)
+		// Otherwise, we may have a LIMIT on top of the CTE, and an ORDER BY in the query, and we can't make a TopN
+		reference<unique_ptr<LogicalOperator>> cte_child = root;
+		while (cte_child.get()->children.size() == 1 && cte_child.get()->type != LogicalOperatorType::LOGICAL_CTE_REF) {
+			cte_child = cte_child.get()->children[0];
+		}
+		cte_child.get() = make_uniq<LogicalMaterializedCTE>(node.ctename, node.setop_index, node.types.size(),
+		                                                    std::move(cte_query), std::move(cte_child.get()));
 
 		// check if there are any unplanned subqueries left in either child
 		has_unplanned_dependent_joins = has_unplanned_dependent_joins ||
 		                                node.child_binder->has_unplanned_dependent_joins ||
 		                                node.query_binder->has_unplanned_dependent_joins;
-
-		return VisitQueryNode(node, std::move(root));
-	} else {
-		return VisitQueryNode(node, std::move(cte_child));
 	}
+	return VisitQueryNode(node, std::move(root));
 }
 
 } // namespace duckdb

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

@@ -28,19 +28,19 @@ unique_ptr<LogicalOperator> Binder::CastLogicalOperatorToTypes(vector<LogicalTyp
 		if (node->children.size() == 1 && node->children[0]->type == LogicalOperatorType::LOGICAL_GET) {
 			// If this projection only has one child and that child is a logical get we can try to pushdown types
 			auto &logical_get = node->children[0]->Cast<LogicalGet>();
+			auto &column_ids = logical_get.GetColumnIds();
 			if (logical_get.function.type_pushdown) {
 				unordered_map<idx_t, LogicalType> new_column_types;
 				bool do_pushdown = true;
 				for (idx_t i = 0; i < op->expressions.size(); i++) {
 					if (op->expressions[i]->type == ExpressionType::BOUND_COLUMN_REF) {
 						auto &col_ref = op->expressions[i]->Cast<BoundColumnRefExpression>();
-						if (new_column_types.find(logical_get.column_ids[col_ref.binding.column_index]) !=
-						    new_column_types.end()) {
+						if (new_column_types.find(column_ids[col_ref.binding.column_index]) != new_column_types.end()) {
 							// Only one reference per column is accepted
 							do_pushdown = false;
 							break;
 						}
-						new_column_types[logical_get.column_ids[col_ref.binding.column_index]] = target_types[i];
+						new_column_types[column_ids[col_ref.binding.column_index]] = target_types[i];
 					} else {
 						do_pushdown = false;
 						break;