duckdb 0.10.2-dev0.0 → 0.10.2-dev3.0

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

@@ -14,6 +14,8 @@
 #include "duckdb/parser/tableref/joinref.hpp"
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
+#include "duckdb/planner/expression/bound_constant_expression.hpp"
+#include "duckdb/planner/expression/bound_expanded_expression.hpp"
 #include "duckdb/planner/expression_binder/column_alias_binder.hpp"
 #include "duckdb/planner/expression_binder/constant_binder.hpp"
 #include "duckdb/planner/expression_binder/group_binder.hpp"
@@ -25,6 +27,7 @@
 #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 {
 
@@ -36,29 +39,29 @@ unique_ptr<Expression> Binder::BindOrderExpression(OrderBinder &order_binder, un
 		// remove the expression from the DISTINCT ON list
 		return nullptr;
 	}
-	D_ASSERT(bound_expr->type == ExpressionType::BOUND_COLUMN_REF);
+	D_ASSERT(bound_expr->type == ExpressionType::VALUE_CONSTANT);
 	return bound_expr;
 }
 
 BoundLimitNode Binder::BindLimitValue(OrderBinder &order_binder, unique_ptr<ParsedExpression> limit_val,
                                       bool is_percentage, bool is_offset) {
 	auto new_binder = Binder::CreateBinder(context, this, true);
-	if (limit_val->HasSubquery()) {
+	ExpressionBinder expr_binder(*new_binder, context);
+	auto target_type = is_percentage ? LogicalType::DOUBLE : LogicalType::BIGINT;
+	expr_binder.target_type = target_type;
+	auto original_limit = limit_val->Copy();
+	auto expr = expr_binder.Bind(limit_val);
+	if (expr->HasSubquery()) {
 		if (!order_binder.HasExtraList()) {
 			throw BinderException("Subquery in LIMIT/OFFSET not supported in set operation");
 		}
-		auto bound_limit = order_binder.CreateExtraReference(std::move(limit_val));
+		auto bound_limit = order_binder.CreateExtraReference(std::move(original_limit));
 		if (is_percentage) {
 			return BoundLimitNode::ExpressionPercentage(std::move(bound_limit));
 		} else {
 			return BoundLimitNode::ExpressionValue(std::move(bound_limit));
 		}
 	}
-	ExpressionBinder expr_binder(*new_binder, context);
-	auto target_type = is_percentage ? LogicalType::DOUBLE : LogicalType::BIGINT;
-	;
-	expr_binder.target_type = target_type;
-	auto expr = expr_binder.Bind(limit_val);
 	if (expr->IsFoldable()) {
 		//! this is a constant
 		auto val = ExpressionExecutor::EvaluateScalar(context, *expr).CastAs(context, target_type);
@@ -121,7 +124,7 @@ unique_ptr<BoundResultModifier> Binder::BindLimitPercent(OrderBinder &order_bind
 	return std::move(result);
 }
 
-void Binder::BindModifiers(OrderBinder &order_binder, QueryNode &statement, BoundQueryNode &result) {
+void Binder::PrepareModifiers(OrderBinder &order_binder, QueryNode &statement, BoundQueryNode &result) {
 	for (auto &mod : statement.modifiers) {
 		unique_ptr<BoundResultModifier> bound_modifier;
 		switch (mod->type) {
@@ -157,16 +160,12 @@ void Binder::BindModifiers(OrderBinder &order_binder, QueryNode &statement, Boun
 				if (star.exclude_list.empty() && star.replace_list.empty() && !star.expr) {
 					// ORDER BY ALL
 					// replace the order list with the all elements in the SELECT list
-					auto order_type = order.orders[0].type;
-					auto null_order = order.orders[0].null_order;
-
-					vector<OrderByNode> new_orders;
-					for (idx_t i = 0; i < order_binder.MaxCount(); i++) {
-						new_orders.emplace_back(
-						    order_type, null_order,
-						    make_uniq<ConstantExpression>(Value::INTEGER(UnsafeNumericCast<int32_t>(i + 1))));
-					}
-					order.orders = std::move(new_orders);
+					auto order_type = config.ResolveOrder(order.orders[0].type);
+					auto null_order = config.ResolveNullOrder(order_type, order.orders[0].null_order);
+					auto constant_expr = make_uniq<BoundConstantExpression>(Value("ALL"));
+					bound_order->orders.emplace_back(order_type, null_order, std::move(constant_expr));
+					bound_modifier = std::move(bound_order);
+					break;
 				}
 			}
 #if 0
@@ -233,10 +232,66 @@ void Binder::BindModifiers(OrderBinder &order_binder, QueryNode &statement, Boun
 	}
 }
 
-static void AssignReturnType(unique_ptr<Expression> &expr, const vector<LogicalType> &sql_types) {
+unique_ptr<Expression> CreateOrderExpression(unique_ptr<Expression> expr, const vector<string> &names,
+                                             const vector<LogicalType> &sql_types, idx_t table_index, idx_t index) {
+	if (index >= sql_types.size()) {
+		throw BinderException(*expr, "ORDER term out of range - should be between 1 and %lld", sql_types.size());
+	}
+	auto result = make_uniq<BoundColumnRefExpression>(std::move(expr->alias), sql_types[index],
+	                                                  ColumnBinding(table_index, index));
+	if (result->alias.empty() && index < names.size()) {
+		result->alias = names[index];
+	}
+	return std::move(result);
+}
+
+unique_ptr<Expression> FinalizeBindOrderExpression(unique_ptr<Expression> expr, idx_t table_index,
+                                                   const vector<string> &names, const vector<LogicalType> &sql_types,
+                                                   const SelectBindState &bind_state) {
+	auto &constant = expr->Cast<BoundConstantExpression>();
+	switch (constant.value.type().id()) {
+	case LogicalTypeId::UBIGINT: {
+		// index
+		auto index = UBigIntValue::Get(constant.value);
+		return CreateOrderExpression(std::move(expr), names, sql_types, table_index, bind_state.GetFinalIndex(index));
+	}
+	case LogicalTypeId::VARCHAR: {
+		// ORDER BY ALL
+		return nullptr;
+	}
+	case LogicalTypeId::STRUCT: {
+		// collation
+		auto &struct_values = StructValue::GetChildren(constant.value);
+		if (struct_values.size() > 2) {
+			throw InternalException("Expected one or two children: index and optional collation");
+		}
+		auto index = UBigIntValue::Get(struct_values[0]);
+		string collation;
+		if (struct_values.size() == 2) {
+			collation = StringValue::Get(struct_values[1]);
+		}
+		auto result = CreateOrderExpression(std::move(expr), names, sql_types, table_index, index);
+		if (!collation.empty()) {
+			if (sql_types[index].id() != LogicalTypeId::VARCHAR) {
+				throw BinderException(*result, "COLLATE can only be applied to varchar columns");
+			}
+			result->return_type = LogicalType::VARCHAR_COLLATION(std::move(collation));
+		}
+		return result;
+	}
+	default:
+		throw InternalException("Unknown type in FinalizeBindOrderExpression");
+	}
+}
+
+static void AssignReturnType(unique_ptr<Expression> &expr, idx_t table_index, const vector<string> &names,
+                             const vector<LogicalType> &sql_types, const SelectBindState &bind_state) {
 	if (!expr) {
 		return;
 	}
+	if (expr->type == ExpressionType::VALUE_CONSTANT) {
+		expr = FinalizeBindOrderExpression(std::move(expr), table_index, names, sql_types, bind_state);
+	}
 	if (expr->type != ExpressionType::BOUND_COLUMN_REF) {
 		return;
 	}
@@ -244,8 +299,8 @@ static void AssignReturnType(unique_ptr<Expression> &expr, const vector<LogicalT
 	bound_colref.return_type = sql_types[bound_colref.binding.column_index];
 }
 
-void Binder::BindModifierTypes(BoundQueryNode &result, const vector<LogicalType> &sql_types, idx_t,
-                               const vector<idx_t> &expansion_count) {
+void Binder::BindModifiers(BoundQueryNode &result, idx_t table_index, const vector<string> &names,
+                           const vector<LogicalType> &sql_types, const SelectBindState &bind_state) {
 	for (auto &bound_mod : result.modifiers) {
 		switch (bound_mod->type) {
 		case ResultModifierType::DISTINCT_MODIFIER: {
@@ -253,59 +308,48 @@ void Binder::BindModifierTypes(BoundQueryNode &result, const vector<LogicalType>
 			D_ASSERT(!distinct.target_distincts.empty());
 			// set types of distinct targets
 			for (auto &expr : distinct.target_distincts) {
-				D_ASSERT(expr->type == ExpressionType::BOUND_COLUMN_REF);
-				auto &bound_colref = expr->Cast<BoundColumnRefExpression>();
-				if (bound_colref.binding.column_index == DConstants::INVALID_INDEX) {
-					throw BinderException("Ambiguous name in DISTINCT ON!");
-				}
-
-				idx_t max_count = sql_types.size();
-				if (bound_colref.binding.column_index > max_count - 1) {
-					D_ASSERT(bound_colref.return_type == LogicalType::ANY);
-					throw BinderException("ORDER term out of range - should be between 1 and %lld", max_count);
+				expr = FinalizeBindOrderExpression(std::move(expr), table_index, names, sql_types, bind_state);
+				if (!expr) {
+					throw InternalException("DISTINCT ON ORDER BY ALL not supported");
 				}
-
-				bound_colref.return_type = sql_types[bound_colref.binding.column_index];
 			}
-			for (auto &target_distinct : distinct.target_distincts) {
-				auto &bound_colref = target_distinct->Cast<BoundColumnRefExpression>();
-				const auto &sql_type = sql_types[bound_colref.binding.column_index];
-				ExpressionBinder::PushCollation(context, target_distinct, sql_type, true);
+			for (auto &expr : distinct.target_distincts) {
+				ExpressionBinder::PushCollation(context, expr, expr->return_type, true);
 			}
 			break;
 		}
 		case ResultModifierType::LIMIT_MODIFIER: {
 			auto &limit = bound_mod->Cast<BoundLimitModifier>();
-			AssignReturnType(limit.limit_val.GetExpression(), sql_types);
-			AssignReturnType(limit.offset_val.GetExpression(), sql_types);
+			AssignReturnType(limit.limit_val.GetExpression(), table_index, names, sql_types, bind_state);
+			AssignReturnType(limit.offset_val.GetExpression(), table_index, names, sql_types, bind_state);
 			break;
 		}
 		case ResultModifierType::ORDER_MODIFIER: {
-
 			auto &order = bound_mod->Cast<BoundOrderModifier>();
+			bool order_by_all = false;
 			for (auto &order_node : order.orders) {
-
 				auto &expr = order_node.expression;
-				D_ASSERT(expr->type == ExpressionType::BOUND_COLUMN_REF);
-				auto &bound_colref = expr->Cast<BoundColumnRefExpression>();
-				if (bound_colref.binding.column_index == DConstants::INVALID_INDEX) {
-					throw BinderException("Ambiguous name in ORDER BY!");
-				}
-
-				if (!expansion_count.empty() && bound_colref.return_type.id() != LogicalTypeId::ANY) {
-					bound_colref.binding.column_index = expansion_count[bound_colref.binding.column_index];
+				expr = FinalizeBindOrderExpression(std::move(expr), table_index, names, sql_types, bind_state);
+				if (!expr) {
+					order_by_all = true;
 				}
-
-				idx_t max_count = sql_types.size();
-				if (bound_colref.binding.column_index > max_count - 1) {
-					D_ASSERT(bound_colref.return_type == LogicalType::ANY);
-					throw BinderException("ORDER term out of range - should be between 1 and %lld", max_count);
+			}
+			if (order_by_all) {
+				D_ASSERT(order.orders.size() == 1);
+				auto order_type = order.orders[0].type;
+				auto null_order = order.orders[0].null_order;
+				order.orders.clear();
+				for (idx_t i = 0; i < sql_types.size(); i++) {
+					auto expr = make_uniq<BoundColumnRefExpression>(sql_types[i], ColumnBinding(table_index, i));
+					if (i < names.size()) {
+						expr->alias = names[i];
+					}
+					order.orders.emplace_back(order_type, null_order, std::move(expr));
 				}
-
-				const auto &sql_type = sql_types[bound_colref.binding.column_index];
-				bound_colref.return_type = sql_type;
-
-				ExpressionBinder::PushCollation(context, order_node.expression, sql_type);
+			}
+			for (auto &order_node : order.orders) {
+				auto &expr = order_node.expression;
+				ExpressionBinder::PushCollation(context, order_node.expression, expr->return_type);
 			}
 			break;
 		}
@@ -380,19 +424,17 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 	}
 	statement.select_list = std::move(new_select_list);
 
-	// create a mapping of (alias -> index) and a mapping of (Expression -> index) for the SELECT list
-	case_insensitive_map_t<idx_t> alias_map;
-	parsed_expression_map_t<idx_t> projection_map;
+	auto &bind_state = result->bind_state;
 	for (idx_t i = 0; i < statement.select_list.size(); i++) {
 		auto &expr = statement.select_list[i];
 		result->names.push_back(expr->GetName());
 		ExpressionBinder::QualifyColumnNames(*this, expr);
 		if (!expr->alias.empty()) {
-			alias_map[expr->alias] = i;
+			bind_state.alias_map[expr->alias] = i;
 			result->names[i] = expr->alias;
 		}
-		projection_map[*expr] = i;
-		result->original_expressions.push_back(expr->Copy());
+		bind_state.projection_map[*expr] = i;
+		bind_state.original_expressions.push_back(expr->Copy());
 	}
 	result->column_count = statement.select_list.size();
 
@@ -402,15 +444,15 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 		// bind any star expressions in the WHERE clause
 		BindWhereStarExpression(statement.where_clause);
 
-		ColumnAliasBinder alias_binder(*result, alias_map);
+		ColumnAliasBinder alias_binder(bind_state);
 		WhereBinder where_binder(*this, context, &alias_binder);
 		unique_ptr<ParsedExpression> condition = std::move(statement.where_clause);
 		result->where_clause = where_binder.Bind(condition);
 	}
 
 	// now bind all the result modifiers; including DISTINCT and ORDER BY targets
-	OrderBinder order_binder({this}, result->projection_index, statement, alias_map, projection_map);
-	BindModifiers(order_binder, statement, *result);
+	OrderBinder order_binder({this}, statement, bind_state);
+	PrepareModifiers(order_binder, statement, *result);
 
 	vector<unique_ptr<ParsedExpression>> unbound_groups;
 	BoundGroupInformation info;
@@ -418,7 +460,7 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 	if (!group_expressions.empty()) {
 		// the statement has a GROUP BY clause, bind it
 		unbound_groups.resize(group_expressions.size());
-		GroupBinder group_binder(*this, context, statement, result->group_index, alias_map, info.alias_map);
+		GroupBinder group_binder(*this, context, statement, result->group_index, bind_state, info.alias_map);
 		for (idx_t i = 0; i < group_expressions.size(); i++) {
 
 			// we keep a copy of the unbound expression;
@@ -468,35 +510,36 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 
 	// bind the HAVING clause, if any
 	if (statement.having) {
-		HavingBinder having_binder(*this, context, *result, info, alias_map, statement.aggregate_handling);
+		HavingBinder having_binder(*this, context, *result, info, statement.aggregate_handling);
 		ExpressionBinder::QualifyColumnNames(*this, statement.having);
 		result->having = having_binder.Bind(statement.having);
 	}
 
 	// bind the QUALIFY clause, if any
-	unique_ptr<QualifyBinder> qualify_binder;
+	vector<BoundColumnReferenceInfo> bound_qualify_columns;
 	if (statement.qualify) {
 		if (statement.aggregate_handling == AggregateHandling::FORCE_AGGREGATES) {
 			throw BinderException("Combining QUALIFY with GROUP BY ALL is not supported yet");
 		}
-		qualify_binder = make_uniq<QualifyBinder>(*this, context, *result, info, alias_map);
+		QualifyBinder qualify_binder(*this, context, *result, info);
 		ExpressionBinder::QualifyColumnNames(*this, statement.qualify);
-		result->qualify = qualify_binder->Bind(statement.qualify);
-		if (qualify_binder->HasBoundColumns() && qualify_binder->BoundAggregates()) {
-			throw BinderException("Cannot mix aggregates with non-aggregated columns!");
+		result->qualify = qualify_binder.Bind(statement.qualify);
+		if (qualify_binder.HasBoundColumns()) {
+			if (qualify_binder.BoundAggregates()) {
+				throw BinderException("Cannot mix aggregates with non-aggregated columns!");
+			}
+			bound_qualify_columns = qualify_binder.GetBoundColumns();
 		}
 	}
 
 	// after that, we bind to the SELECT list
-	SelectBinder select_binder(*this, context, *result, info, alias_map);
+	SelectBinder select_binder(*this, context, *result, info);
 
 	// if we expand select-list expressions, e.g., via UNNEST, then we need to possibly
 	// adjust the column index of the already bound ORDER BY modifiers, and not only set their types
-	vector<LogicalType> modifier_sql_types;
-	vector<idx_t> modifier_expansion_count;
-
 	vector<idx_t> group_by_all_indexes;
 	vector<string> new_names;
+	vector<LogicalType> internal_sql_types;
 
 	for (idx_t i = 0; i < statement.select_list.size(); i++) {
 		bool is_window = statement.select_list[i]->IsWindow();
@@ -506,33 +549,37 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 		bool is_original_column = i < result->column_count;
 		bool can_group_by_all =
 		    statement.aggregate_handling == AggregateHandling::FORCE_AGGREGATES && is_original_column;
+		result->bound_column_count++;
 
-		if (select_binder.HasExpandedExpressions()) {
+		if (expr->type == ExpressionType::BOUND_EXPANDED) {
 			if (!is_original_column) {
-				throw InternalException("Only original columns can have expanded expressions");
+				throw BinderException("UNNEST of struct cannot be used in ORDER BY/DISTINCT ON clause");
 			}
 			if (statement.aggregate_handling == AggregateHandling::FORCE_AGGREGATES) {
 				throw BinderException("UNNEST of struct cannot be combined with GROUP BY ALL");
 			}
 
-			auto &struct_expressions = select_binder.ExpandedExpressions();
+			auto &expanded = expr->Cast<BoundExpandedExpression>();
+			auto &struct_expressions = expanded.expanded_expressions;
 			D_ASSERT(!struct_expressions.empty());
-			modifier_expansion_count.push_back(modifier_sql_types.size());
 
 			for (auto &struct_expr : struct_expressions) {
-				modifier_sql_types.push_back(struct_expr->return_type);
 				new_names.push_back(struct_expr->GetName());
 				result->types.push_back(struct_expr->return_type);
+				internal_sql_types.push_back(struct_expr->return_type);
 				result->select_list.push_back(std::move(struct_expr));
 			}
-
-			struct_expressions.clear();
+			bind_state.AddExpandedColumn(struct_expressions.size());
 			continue;
 		}
 
-		// not an expanded expression
-		modifier_expansion_count.push_back(modifier_sql_types.size());
-		modifier_sql_types.push_back(result_type);
+		if (expr->IsVolatile()) {
+			bind_state.SetExpressionIsVolatile(i);
+		}
+		if (expr->HasSubquery()) {
+			bind_state.SetExpressionHasSubquery(i);
+		}
+		bind_state.AddRegularColumn();
 
 		if (can_group_by_all && select_binder.HasBoundColumns()) {
 			if (select_binder.BoundAggregates()) {
@@ -554,6 +601,7 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 			new_names.push_back(std::move(result->names[i]));
 			result->types.push_back(result_type);
 		}
+		internal_sql_types.push_back(result_type);
 
 		if (can_group_by_all) {
 			select_binder.ResetBindings();
@@ -581,17 +629,14 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 		if (statement.aggregate_handling == AggregateHandling::NO_AGGREGATES_ALLOWED) {
 			throw BinderException("Aggregates cannot be present in a Project relation!");
 		} else {
-			vector<reference<BaseSelectBinder>> to_check_binders;
-			to_check_binders.push_back(select_binder);
-			if (qualify_binder) {
-				to_check_binders.push_back(*qualify_binder);
+			vector<BoundColumnReferenceInfo> bound_columns;
+			if (select_binder.HasBoundColumns()) {
+				bound_columns = select_binder.GetBoundColumns();
 			}
-			for (auto &binder : to_check_binders) {
-				auto &sel_binder = binder.get();
-				if (!sel_binder.HasBoundColumns()) {
-					continue;
-				}
-				auto &bound_columns = sel_binder.GetBoundColumns();
+			for (auto &bound_qualify_col : bound_qualify_columns) {
+				bound_columns.push_back(bound_qualify_col);
+			}
+			if (!bound_columns.empty()) {
 				string error;
 				error = "column \"%s\" must appear in the GROUP BY clause or must be part of an aggregate function.";
 				if (statement.aggregate_handling == AggregateHandling::FORCE_AGGREGATES) {
@@ -616,7 +661,7 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 	}
 
 	// now that the SELECT list is bound, we set the types of DISTINCT/ORDER BY expressions
-	BindModifierTypes(*result, modifier_sql_types, result->projection_index, modifier_expansion_count);
+	BindModifiers(*result, result->projection_index, result->names, internal_sql_types, bind_state);
 	return std::move(result);
 }
 

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

@@ -9,12 +9,12 @@
 #include "duckdb/planner/expression_binder/order_binder.hpp"
 #include "duckdb/planner/query_node/bound_select_node.hpp"
 #include "duckdb/planner/query_node/bound_set_operation_node.hpp"
+#include "duckdb/planner/expression_binder/select_bind_state.hpp"
 #include "duckdb/common/enum_util.hpp"
 
 namespace duckdb {
 
-static void GatherAliases(BoundQueryNode &node, case_insensitive_map_t<idx_t> &aliases,
-                          parsed_expression_map_t<idx_t> &expressions, const vector<idx_t> &reorder_idx) {
+static void GatherAliases(BoundQueryNode &node, SelectBindState &bind_state, const vector<idx_t> &reorder_idx) {
 	if (node.type == QueryNodeType::SET_OPERATION_NODE) {
 		// setop, recurse
 		auto &setop = node.Cast<BoundSetOperationNode>();
@@ -32,41 +32,45 @@ static void GatherAliases(BoundQueryNode &node, case_insensitive_map_t<idx_t> &a
 			}
 
 			// use new reorder index
-			GatherAliases(*setop.left, aliases, expressions, new_left_reorder_idx);
-			GatherAliases(*setop.right, aliases, expressions, new_right_reorder_idx);
+			GatherAliases(*setop.left, bind_state, new_left_reorder_idx);
+			GatherAliases(*setop.right, bind_state, new_right_reorder_idx);
 			return;
 		}
 
-		GatherAliases(*setop.left, aliases, expressions, reorder_idx);
-		GatherAliases(*setop.right, aliases, expressions, reorder_idx);
+		GatherAliases(*setop.left, bind_state, reorder_idx);
+		GatherAliases(*setop.right, bind_state, reorder_idx);
 	} else {
 		// query node
 		D_ASSERT(node.type == QueryNodeType::SELECT_NODE);
 		auto &select = node.Cast<BoundSelectNode>();
-		// fill the alias lists
+		// fill the alias lists with the names
 		for (idx_t i = 0; i < select.names.size(); i++) {
 			auto &name = select.names[i];
-			auto &expr = select.original_expressions[i];
 			// first check if the alias is already in there
-			auto entry = aliases.find(name);
+			auto entry = bind_state.alias_map.find(name);
 
 			idx_t index = reorder_idx[i];
 
-			if (entry == aliases.end()) {
+			if (entry == bind_state.alias_map.end()) {
 				// the alias is not in there yet, just assign it
-				aliases[name] = index;
+				bind_state.alias_map[name] = index;
 			}
+		}
+		// check if the expression matches one of the expressions in the original expression liset
+		for (idx_t i = 0; i < select.bind_state.original_expressions.size(); i++) {
+			auto &expr = select.bind_state.original_expressions[i];
+			idx_t index = reorder_idx[i];
 			// now check if the node is already in the set of expressions
-			auto expr_entry = expressions.find(*expr);
-			if (expr_entry != expressions.end()) {
+			auto expr_entry = bind_state.projection_map.find(*expr);
+			if (expr_entry != bind_state.projection_map.end()) {
 				// the node is in there
 				// repeat the same as with the alias: if there is an ambiguity we insert "-1"
 				if (expr_entry->second != index) {
-					expressions[*expr] = DConstants::INVALID_INDEX;
+					bind_state.projection_map[*expr] = DConstants::INVALID_INDEX;
 				}
 			} else {
 				// not in there yet, just place it in there
-				expressions[*expr] = index;
+				bind_state.projection_map[*expr] = index;
 			}
 		}
 	}
@@ -114,8 +118,8 @@ static void BuildUnionByNameInfo(ClientContext &context, BoundSetOperationNode &
 		bool right_exist = right_index != right_names_map.end();
 		LogicalType result_type;
 		if (left_exist && right_exist) {
-			result_type = LogicalType::MaxLogicalType(context, left_node.types[left_index->second],
-			                                          right_node.types[right_index->second]);
+			result_type = LogicalType::ForceMaxLogicalType(left_node.types[left_index->second],
+			                                               right_node.types[right_index->second]);
 			if (left_index->second != i || right_index->second != i) {
 				need_reorder = true;
 			}
@@ -225,32 +229,30 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SetOperationNode &statement) {
 		}
 	}
 
+	SelectBindState bind_state;
 	if (!statement.modifiers.empty()) {
 		// handle the ORDER BY/DISTINCT clauses
 
 		// we recursively visit the children of this node to extract aliases and expressions that can be referenced
 		// in the ORDER BY
-		case_insensitive_map_t<idx_t> alias_map;
-		parsed_expression_map_t<idx_t> expression_map;
 
 		if (result->setop_type == SetOperationType::UNION_BY_NAME) {
-			GatherAliases(*result->left, alias_map, expression_map, result->left_reorder_idx);
-			GatherAliases(*result->right, alias_map, expression_map, result->right_reorder_idx);
+			GatherAliases(*result->left, bind_state, result->left_reorder_idx);
+			GatherAliases(*result->right, bind_state, result->right_reorder_idx);
 		} else {
 			vector<idx_t> reorder_idx;
 			for (idx_t i = 0; i < result->names.size(); i++) {
 				reorder_idx.push_back(i);
 			}
-			GatherAliases(*result, alias_map, expression_map, reorder_idx);
+			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()}, result->setop_index,
-		                         alias_map, expression_map, result->names.size());
-		BindModifiers(order_binder, statement, *result);
+		OrderBinder order_binder({result->left_binder.get(), result->right_binder.get()}, bind_state);
+		PrepareModifiers(order_binder, statement, *result);
 	}
 
 	// finally bind the types of the ORDER/DISTINCT clause expressions
-	BindModifierTypes(*result, result->types, result->setop_index);
+	BindModifiers(*result, result->setop_index, result->names, result->types, bind_state);
 	return std::move(result);
 }
 

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

@@ -23,4 +23,33 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundCTENode &node) {
 	return VisitQueryNode(node, std::move(root));
 }
 
+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;
+	if (node.child && node.child->type == QueryNodeType::CTE_NODE) {
+		cte_child = CreatePlan(node.child->Cast<BoundCTENode>(), std::move(base));
+	} else if (node.child) {
+		cte_child = CreatePlan(*node.child);
+	} else {
+		cte_child = 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));
+
+		// 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));
+	}
+}
+
 } // namespace duckdb

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

@@ -254,7 +254,7 @@ static unique_ptr<Expression> PlanCorrelatedSubquery(Binder &binder, BoundSubque
 		FlattenDependentJoins flatten(binder, correlated_columns, perform_delim);
 
 		// first we check which logical operators have correlated expressions in the first place
-		flatten.DetectCorrelatedExpressions(plan.get());
+		flatten.DetectCorrelatedExpressions(*plan);
 		// now we push the dependent join down
 		auto dependent_join = flatten.PushDownDependentJoin(std::move(plan));
 
@@ -279,7 +279,7 @@ static unique_ptr<Expression> PlanCorrelatedSubquery(Binder &binder, BoundSubque
 		delim_join->mark_index = mark_index;
 		// RHS
 		FlattenDependentJoins flatten(binder, correlated_columns, perform_delim, true);
-		flatten.DetectCorrelatedExpressions(plan.get());
+		flatten.DetectCorrelatedExpressions(*plan);
 		auto dependent_join = flatten.PushDownDependentJoin(std::move(plan));
 
 		// fetch the set of columns
@@ -307,7 +307,7 @@ static unique_ptr<Expression> PlanCorrelatedSubquery(Binder &binder, BoundSubque
 		delim_join->mark_index = mark_index;
 		// RHS
 		FlattenDependentJoins flatten(binder, correlated_columns, true, true);
-		flatten.DetectCorrelatedExpressions(plan.get());
+		flatten.DetectCorrelatedExpressions(*plan);
 		auto dependent_join = flatten.PushDownDependentJoin(std::move(plan));
 
 		// fetch the columns
@@ -411,8 +411,8 @@ void Binder::PlanSubqueries(unique_ptr<Expression> &expr_ptr, unique_ptr<Logical
 }
 
 unique_ptr<LogicalOperator> Binder::PlanLateralJoin(unique_ptr<LogicalOperator> left, unique_ptr<LogicalOperator> right,
-                                                    vector<CorrelatedColumnInfo> &correlated_columns,
-                                                    JoinType join_type, unique_ptr<Expression> condition) {
+                                                    vector<CorrelatedColumnInfo> &correlated, JoinType join_type,
+                                                    unique_ptr<Expression> condition) {
 	// scan the right operator for correlated columns
 	// correlated LATERAL JOIN
 	vector<JoinCondition> conditions;
@@ -423,13 +423,13 @@ unique_ptr<LogicalOperator> Binder::PlanLateralJoin(unique_ptr<LogicalOperator>
 		                                             arbitrary_expressions);
 	}
 
-	auto perform_delim = PerformDuplicateElimination(*this, correlated_columns);
-	auto delim_join = CreateDuplicateEliminatedJoin(correlated_columns, join_type, std::move(left), perform_delim);
+	auto perform_delim = PerformDuplicateElimination(*this, correlated);
+	auto delim_join = CreateDuplicateEliminatedJoin(correlated, join_type, std::move(left), perform_delim);
 
-	FlattenDependentJoins flatten(*this, correlated_columns, perform_delim);
+	FlattenDependentJoins flatten(*this, correlated, perform_delim);
 
 	// first we check which logical operators have correlated expressions in the first place
-	flatten.DetectCorrelatedExpressions(right.get(), true);
+	flatten.DetectCorrelatedExpressions(*right, true);
 	// now we push the dependent join down
 	auto dependent_join = flatten.PushDownDependentJoin(std::move(right));
 
@@ -448,7 +448,7 @@ unique_ptr<LogicalOperator> Binder::PlanLateralJoin(unique_ptr<LogicalOperator>
 	D_ASSERT(delim_join->conditions.empty());
 	delim_join->conditions = std::move(conditions);
 	// then add the delim join conditions
-	CreateDelimJoinConditions(*delim_join, correlated_columns, plan_columns, flatten.delim_offset, perform_delim);
+	CreateDelimJoinConditions(*delim_join, correlated, plan_columns, flatten.delim_offset, perform_delim);
 	delim_join->AddChild(std::move(dependent_join));
 
 	// check if there are any arbitrary expressions left