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

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

@@ -19,6 +19,7 @@
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "duckdb/main/client_config.hpp"
 #include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
+#include "duckdb/main/query_result.hpp"
 
 namespace duckdb {
 
@@ -344,7 +345,9 @@ unique_ptr<BoundTableRef> Binder::BindBoundPivot(PivotRef &ref) {
 	result->bound_pivot.group_count = ref.bound_group_names.size();
 	result->bound_pivot.types = types;
 	auto subquery_alias = ref.alias.empty() ? "__unnamed_pivot" : ref.alias;
+	QueryResult::DeduplicateColumns(names);
 	bind_context.AddGenericBinding(result->bind_index, subquery_alias, names, types);
+
 	MoveCorrelatedExpressions(*result->child_binder);
 	return std::move(result);
 }

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

@@ -10,8 +10,8 @@ unique_ptr<BoundTableRef> Binder::Bind(SubqueryRef &ref, optional_ptr<CommonTabl
 	if (cte) {
 		binder->bound_ctes.insert(*cte);
 	}
-	binder->alias = ref.alias.empty() ? "unnamed_subquery" : ref.alias;
 	auto subquery = binder->BindNode(*ref.subquery->node);
+	binder->alias = ref.alias.empty() ? "unnamed_subquery" : ref.alias;
 	idx_t bind_index = subquery->GetRootIndex();
 	string subquery_alias;
 	if (ref.alias.empty()) {

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

@@ -102,7 +102,7 @@ bool Binder::BindTableFunctionParameters(TableFunctionCatalogEntry &table_functi
 			continue;
 		}
 
-		TableFunctionBinder binder(*this, context);
+		TableFunctionBinder binder(*this, context, table_function.name);
 		LogicalType sql_type;
 		auto expr = binder.Bind(child, &sql_type);
 		if (expr->HasParameter()) {
@@ -140,7 +140,7 @@ Binder::BindTableFunctionInternal(TableFunction &table_function, const string &f
 	vector<string> return_names;
 	if (table_function.bind || table_function.bind_replace) {
 		TableFunctionBindInput bind_input(parameters, named_parameters, input_table_types, input_table_names,
-		                                  table_function.function_info.get());
+		                                  table_function.function_info.get(), this);
 		if (table_function.bind_replace) {
 			auto new_plan = table_function.bind_replace(context, bind_input);
 			if (new_plan != nullptr) {
@@ -251,12 +251,12 @@ unique_ptr<BoundTableRef> Binder::Bind(TableFunctionRef &ref) {
 
 	// select the function based on the input parameters
 	FunctionBinder function_binder(context);
-	idx_t best_function_idx = function_binder.BindFunction(function.name, function.functions, arguments, error);
-	if (best_function_idx == DConstants::INVALID_INDEX) {
+	auto best_function_idx = function_binder.BindFunction(function.name, function.functions, arguments, error);
+	if (!best_function_idx.IsValid()) {
 		error.AddQueryLocation(ref);
 		error.Throw();
 	}
-	auto table_function = function.functions.GetFunctionByOffset(best_function_idx);
+	auto table_function = function.functions.GetFunctionByOffset(best_function_idx.GetIndex());
 
 	// now check the named parameters
 	BindNamedParameters(table_function.named_parameters, named_parameters, error_context, table_function.name);

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

@@ -67,6 +67,76 @@ Binder::Binder(bool, ClientContext &context, shared_ptr<Binder> parent_p, bool i
 	}
 }
 
+unique_ptr<BoundCTENode> Binder::BindMaterializedCTE(CommonTableExpressionMap &cte_map) {
+	// Extract materialized CTEs from cte_map
+	vector<unique_ptr<CTENode>> materialized_ctes;
+	for (auto &cte : cte_map.map) {
+		auto &cte_entry = cte.second;
+		if (cte_entry->materialized == CTEMaterialize::CTE_MATERIALIZE_ALWAYS) {
+			auto mat_cte = make_uniq<CTENode>();
+			mat_cte->ctename = cte.first;
+			mat_cte->query = cte_entry->query->node->Copy();
+			mat_cte->aliases = cte_entry->aliases;
+			materialized_ctes.push_back(std::move(mat_cte));
+		}
+	}
+
+	if (materialized_ctes.empty()) {
+		return nullptr;
+	}
+
+	unique_ptr<CTENode> cte_root = nullptr;
+	while (!materialized_ctes.empty()) {
+		unique_ptr<CTENode> node_result;
+		node_result = std::move(materialized_ctes.back());
+		node_result->cte_map = cte_map.Copy();
+		if (cte_root) {
+			node_result->child = std::move(cte_root);
+		} else {
+			node_result->child = nullptr;
+		}
+		cte_root = std::move(node_result);
+		materialized_ctes.pop_back();
+	}
+
+	AddCTEMap(cte_map);
+	auto bound_cte = BindCTE(cte_root->Cast<CTENode>());
+
+	return bound_cte;
+}
+
+template <class T>
+BoundStatement Binder::BindWithCTE(T &statement) {
+	BoundStatement bound_statement;
+	auto bound_cte = BindMaterializedCTE(statement.template Cast<T>().cte_map);
+	if (bound_cte) {
+		BoundCTENode *tail = bound_cte.get();
+
+		while (tail->child && tail->child->type == QueryNodeType::CTE_NODE) {
+			tail = &tail->child->Cast<BoundCTENode>();
+		}
+
+		bound_statement = tail->child_binder->Bind(statement.template Cast<T>());
+
+		tail->types = bound_statement.types;
+		tail->names = bound_statement.names;
+
+		for (auto &c : tail->query_binder->correlated_columns) {
+			tail->child_binder->AddCorrelatedColumn(c);
+		}
+
+		MoveCorrelatedExpressions(*tail->child_binder);
+
+		// extract operator below root operation
+		auto plan = std::move(bound_statement.plan->children[0]);
+		bound_statement.plan->children.clear();
+		bound_statement.plan->children.push_back(CreatePlan(*bound_cte, std::move(plan)));
+	} else {
+		bound_statement = Bind(statement.template Cast<T>());
+	}
+	return bound_statement;
+}
+
 BoundStatement Binder::Bind(SQLStatement &statement) {
 	root_statement = &statement;
 	switch (statement.type) {
@@ -77,9 +147,9 @@ BoundStatement Binder::Bind(SQLStatement &statement) {
 	case StatementType::COPY_STATEMENT:
 		return Bind(statement.Cast<CopyStatement>());
 	case StatementType::DELETE_STATEMENT:
-		return Bind(statement.Cast<DeleteStatement>());
+		return BindWithCTE(statement.Cast<DeleteStatement>());
 	case StatementType::UPDATE_STATEMENT:
-		return Bind(statement.Cast<UpdateStatement>());
+		return BindWithCTE(statement.Cast<UpdateStatement>());
 	case StatementType::RELATION_STATEMENT:
 		return Bind(statement.Cast<RelationStatement>());
 	case StatementType::CREATE_STATEMENT:
@@ -263,17 +333,19 @@ void Binder::AddCTE(const string &name, CommonTableExpressionInfo &info) {
 	CTE_bindings.insert(make_pair(name, reference<CommonTableExpressionInfo>(info)));
 }
 
-optional_ptr<CommonTableExpressionInfo> Binder::FindCTE(const string &name, bool skip) {
+vector<reference<CommonTableExpressionInfo>> Binder::FindCTE(const string &name, bool skip) {
 	auto entry = CTE_bindings.find(name);
+	vector<reference<CommonTableExpressionInfo>> ctes;
 	if (entry != CTE_bindings.end()) {
 		if (!skip || entry->second.get().query->node->type == QueryNodeType::RECURSIVE_CTE_NODE) {
-			return &entry->second.get();
+			ctes.push_back(entry->second);
 		}
 	}
 	if (parent && inherit_ctes) {
-		return parent->FindCTE(name, name == alias);
+		auto parent_ctes = parent->FindCTE(name, name == alias);
+		ctes.insert(ctes.end(), parent_ctes.begin(), parent_ctes.end());
 	}
-	return nullptr;
+	return ctes;
 }
 
 bool Binder::CTEIsAlreadyBound(CommonTableExpressionInfo &cte) {

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

@@ -142,7 +142,12 @@ bool BoundCastExpression::CastIsInvertible(const LogicalType &source_type, const
 		}
 		return true;
 	}
-	if (source_type.id() == LogicalTypeId::TIMESTAMP || source_type.id() == LogicalTypeId::TIMESTAMP_TZ) {
+	switch (source_type.id()) {
+	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_TZ:
+	case LogicalTypeId::TIMESTAMP_SEC:
+	case LogicalTypeId::TIMESTAMP_MS:
+	case LogicalTypeId::TIMESTAMP_NS:
 		switch (target_type.id()) {
 		case LogicalTypeId::DATE:
 		case LogicalTypeId::TIME:
@@ -151,8 +156,8 @@ bool BoundCastExpression::CastIsInvertible(const LogicalType &source_type, const
 		default:
 			break;
 		}
-	}
-	if (source_type.id() == LogicalTypeId::VARCHAR) {
+		break;
+	case LogicalTypeId::VARCHAR:
 		switch (target_type.id()) {
 		case LogicalTypeId::TIMESTAMP:
 		case LogicalTypeId::TIMESTAMP_NS:
@@ -163,6 +168,9 @@ bool BoundCastExpression::CastIsInvertible(const LogicalType &source_type, const
 		default:
 			return false;
 		}
+		break;
+	default:
+		break;
 	}
 	if (target_type.id() == LogicalTypeId::VARCHAR) {
 		switch (source_type.id()) {

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

@@ -0,0 +1,22 @@
+#include "duckdb/planner/expression/bound_expanded_expression.hpp"
+
+namespace duckdb {
+
+BoundExpandedExpression::BoundExpandedExpression(vector<unique_ptr<Expression>> expanded_expressions_p)
+    : Expression(ExpressionType::BOUND_EXPANDED, ExpressionClass::BOUND_EXPANDED, LogicalType::INTEGER),
+      expanded_expressions(std::move(expanded_expressions_p)) {
+}
+
+string BoundExpandedExpression::ToString() const {
+	return "BOUND_EXPANDED";
+}
+
+bool BoundExpandedExpression::Equals(const BaseExpression &other_p) const {
+	return false;
+}
+
+unique_ptr<Expression> BoundExpandedExpression::Copy() {
+	throw SerializationException("Cannot copy BoundExpandedExpression");
+}
+
+} // namespace duckdb

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

@@ -4,35 +4,29 @@
 #include "duckdb/parser/expression/columnref_expression.hpp"
 #include "duckdb/parser/expression/operator_expression.hpp"
 #include "duckdb/parser/expression/window_expression.hpp"
-#include "duckdb/parser/parsed_expression_iterator.hpp"
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_window_expression.hpp"
 #include "duckdb/planner/expression_binder/aggregate_binder.hpp"
 #include "duckdb/planner/query_node/bound_select_node.hpp"
+#include "duckdb/planner/expression_binder/select_bind_state.hpp"
 
 namespace duckdb {
 
-BaseSelectBinder::BaseSelectBinder(Binder &binder, ClientContext &context, BoundSelectNode &node,
-                                   BoundGroupInformation &info, case_insensitive_map_t<idx_t> alias_map)
-    : ExpressionBinder(binder, context), inside_window(false), node(node), info(info), alias_map(std::move(alias_map)) {
-}
-
 BaseSelectBinder::BaseSelectBinder(Binder &binder, ClientContext &context, BoundSelectNode &node,
                                    BoundGroupInformation &info)
-    : BaseSelectBinder(binder, context, node, info, case_insensitive_map_t<idx_t>()) {
+    : ExpressionBinder(binder, context), inside_window(false), node(node), info(info) {
 }
 
 BindResult BaseSelectBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
 	auto &expr = *expr_ptr;
 	// check if the expression binds to one of the groups
-	auto group_index = TryBindGroup(expr, depth);
+	auto group_index = TryBindGroup(expr);
 	if (group_index != DConstants::INVALID_INDEX) {
 		return BindGroup(expr, depth, group_index);
 	}
 	switch (expr.expression_class) {
 	case ExpressionClass::COLUMN_REF:
-		return BindColumnRef(expr_ptr, depth);
+		return BindColumnRef(expr_ptr, depth, root_expression);
 	case ExpressionClass::DEFAULT:
 		return BindResult("SELECT clause cannot contain DEFAULT clause");
 	case ExpressionClass::WINDOW:
@@ -42,7 +36,7 @@ BindResult BaseSelectBinder::BindExpression(unique_ptr<ParsedExpression> &expr_p
 	}
 }
 
-idx_t BaseSelectBinder::TryBindGroup(ParsedExpression &expr, idx_t depth) {
+idx_t BaseSelectBinder::TryBindGroup(ParsedExpression &expr) {
 	// first check the group alias map, if expr is a ColumnRefExpression
 	if (expr.type == ExpressionType::COLUMN_REF) {
 		auto &colref = expr.Cast<ColumnRefExpression>();
@@ -61,50 +55,16 @@ idx_t BaseSelectBinder::TryBindGroup(ParsedExpression &expr, idx_t depth) {
 		return entry->second;
 	}
 #ifdef DEBUG
-	for (auto entry : info.map) {
-		D_ASSERT(!entry.first.get().Equals(expr));
-		D_ASSERT(!expr.Equals(entry.first.get()));
+	for (auto map_entry : info.map) {
+		D_ASSERT(!map_entry.first.get().Equals(expr));
+		D_ASSERT(!expr.Equals(map_entry.first.get()));
 	}
 #endif
 	return DConstants::INVALID_INDEX;
 }
 
-BindResult BaseSelectBinder::BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth) {
-	// first try to bind the column reference regularly
-	auto result = ExpressionBinder::BindExpression(expr_ptr, depth);
-	if (!result.HasError()) {
-		return result;
-	}
-	// binding failed
-	// check in the alias map
-	auto &colref = (expr_ptr.get())->Cast<ColumnRefExpression>();
-	if (!colref.IsQualified()) {
-		auto alias_entry = alias_map.find(colref.column_names[0]);
-		if (alias_entry != alias_map.end()) {
-			// found entry!
-			auto index = alias_entry->second;
-			if (index >= node.select_list.size()) {
-				throw BinderException("Column \"%s\" referenced that exists in the SELECT clause - but this column "
-				                      "cannot be referenced before it is defined",
-				                      colref.column_names[0]);
-			}
-			if (node.select_list[index]->IsVolatile()) {
-				throw BinderException("Alias \"%s\" referenced in a SELECT clause - but the expression has side "
-				                      "effects. This is not yet supported.",
-				                      colref.column_names[0]);
-			}
-			if (node.select_list[index]->HasSubquery()) {
-				throw BinderException("Alias \"%s\" referenced in a SELECT clause - but the expression has a subquery."
-				                      " This is not yet supported.",
-				                      colref.column_names[0]);
-			}
-			auto copied_expression = node.original_expressions[index]->Copy();
-			result = BindExpression(copied_expression, depth, false);
-			return result;
-		}
-	}
-	// entry was not found in the alias map: return the original error
-	return result;
+BindResult BaseSelectBinder::BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
+	return ExpressionBinder::BindExpression(expr_ptr, depth);
 }
 
 BindResult BaseSelectBinder::BindGroupingFunction(OperatorExpression &op, idx_t depth) {
@@ -121,7 +81,7 @@ BindResult BaseSelectBinder::BindGroupingFunction(OperatorExpression &op, idx_t
 	group_indexes.reserve(op.children.size());
 	for (auto &child : op.children) {
 		ExpressionBinder::QualifyColumnNames(binder, child);
-		auto idx = TryBindGroup(*child, depth);
+		auto idx = TryBindGroup(*child);
 		if (idx == DConstants::INVALID_INDEX) {
 			return BindResult(BinderException(op, "GROUPING child \"%s\" must be a grouping column", child->GetName()));
 		}
@@ -147,11 +107,4 @@ BindResult BaseSelectBinder::BindGroup(ParsedExpression &expr, idx_t depth, idx_
 	}
 }
 
-bool BaseSelectBinder::QualifyColumnAlias(const ColumnRefExpression &colref) {
-	if (!colref.IsQualified()) {
-		return alias_map.find(colref.column_names[0]) != alias_map.end();
-	}
-	return false;
-}
-
 } // namespace duckdb

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

@@ -1,15 +1,14 @@
 #include "duckdb/planner/expression_binder/column_alias_binder.hpp"
 
 #include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/planner/query_node/bound_select_node.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/planner/expression_binder.hpp"
 #include "duckdb/planner/binder.hpp"
+#include "duckdb/planner/expression_binder/select_bind_state.hpp"
 
 namespace duckdb {
 
-ColumnAliasBinder::ColumnAliasBinder(BoundSelectNode &node, const case_insensitive_map_t<idx_t> &alias_map)
-    : node(node), alias_map(alias_map), visited_select_indexes() {
+ColumnAliasBinder::ColumnAliasBinder(SelectBindState &bind_state) : bind_state(bind_state), visited_select_indexes() {
 }
 
 bool ColumnAliasBinder::BindAlias(ExpressionBinder &enclosing_binder, unique_ptr<ParsedExpression> &expr_ptr,
@@ -24,8 +23,8 @@ bool ColumnAliasBinder::BindAlias(ExpressionBinder &enclosing_binder, unique_ptr
 	}
 
 	// We try to find the alias in the alias_map and return false, if no alias exists.
-	auto alias_entry = alias_map.find(expr.column_names[0]);
-	if (alias_entry == alias_map.end()) {
+	auto alias_entry = bind_state.alias_map.find(expr.column_names[0]);
+	if (alias_entry == bind_state.alias_map.end()) {
 		return false;
 	}
 
@@ -35,12 +34,10 @@ bool ColumnAliasBinder::BindAlias(ExpressionBinder &enclosing_binder, unique_ptr
 	}
 
 	// We found an alias, so we copy the alias expression into this expression.
-	auto original_expr = node.original_expressions[alias_entry->second]->Copy();
+	auto original_expr = bind_state.BindAlias(alias_entry->second);
 	expr_ptr = std::move(original_expr);
 	visited_select_indexes.insert(alias_entry->second);
 
-	// Since the alias has been found, we pass a depth of 0. See issue 4978 (#16).
-	// Only HAVING, QUALIFY, and WHERE binders contain ColumnAliasBinders.
 	result = enclosing_binder.BindExpression(expr_ptr, depth, root_expression);
 	visited_select_indexes.erase(alias_entry->second);
 	return true;

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

@@ -4,13 +4,14 @@
 #include "duckdb/parser/expression/constant_expression.hpp"
 #include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
+#include "duckdb/planner/expression_binder/select_bind_state.hpp"
 #include "duckdb/common/to_string.hpp"
 
 namespace duckdb {
 
 GroupBinder::GroupBinder(Binder &binder, ClientContext &context, SelectNode &node, idx_t group_index,
-                         case_insensitive_map_t<idx_t> &alias_map, case_insensitive_map_t<idx_t> &group_alias_map)
-    : ExpressionBinder(binder, context), node(node), alias_map(alias_map), group_alias_map(group_alias_map),
+                         SelectBindState &bind_state, case_insensitive_map_t<idx_t> &group_alias_map)
+    : ExpressionBinder(binder, context), node(node), bind_state(bind_state), group_alias_map(group_alias_map),
       group_index(group_index) {
 }
 
@@ -94,8 +95,8 @@ BindResult GroupBinder::BindColumnRef(ColumnRefExpression &colref) {
 		// failed to bind the column and the node is the root expression with depth = 0
 		// check if refers to an alias in the select clause
 		auto alias_name = colref.column_names[0];
-		auto entry = alias_map.find(alias_name);
-		if (entry == alias_map.end()) {
+		auto entry = bind_state.alias_map.find(alias_name);
+		if (entry == bind_state.alias_map.end()) {
 			// no matching alias found
 			return result;
 		}

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

@@ -9,14 +9,13 @@
 namespace duckdb {
 
 HavingBinder::HavingBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info,
-                           case_insensitive_map_t<idx_t> &alias_map, AggregateHandling aggregate_handling)
-    : BaseSelectBinder(binder, context, node, info), column_alias_binder(node, alias_map),
+                           AggregateHandling aggregate_handling)
+    : BaseSelectBinder(binder, context, node, info), column_alias_binder(node.bind_state),
       aggregate_handling(aggregate_handling) {
 	target_type = LogicalType(LogicalTypeId::BOOLEAN);
 }
 
 BindResult HavingBinder::BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
-
 	// Keep the original column name to return a meaningful error message.
 	auto column_name = expr_ptr->Cast<ColumnRefExpression>().GetColumnName();
 
@@ -37,7 +36,7 @@ BindResult HavingBinder::BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, i
 			    "Having clause cannot reference column \"%s\" in correlated subquery and group by all", column_name);
 		}
 
-		auto expr = duckdb::BaseSelectBinder::BindExpression(expr_ptr, depth);
+		auto expr = duckdb::BaseSelectBinder::BindColumnRef(expr_ptr, depth, root_expression);
 		if (expr.HasError()) {
 			return expr;
 		}
@@ -54,21 +53,8 @@ BindResult HavingBinder::BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, i
 	    "column %s must appear in the GROUP BY clause or be used in an aggregate function", column_name));
 }
 
-BindResult HavingBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = *expr_ptr;
-	// check if the expression binds to one of the groups
-	auto group_index = TryBindGroup(expr, depth);
-	if (group_index != DConstants::INVALID_INDEX) {
-		return BindGroup(expr, depth, group_index);
-	}
-	switch (expr.expression_class) {
-	case ExpressionClass::WINDOW:
-		return BindResult("HAVING clause cannot contain window functions!");
-	case ExpressionClass::COLUMN_REF:
-		return BindColumnRef(expr_ptr, depth, root_expression);
-	default:
-		return duckdb::BaseSelectBinder::BindExpression(expr_ptr, depth);
-	}
+BindResult HavingBinder::BindWindow(WindowExpression &expr, idx_t depth) {
+	return BindResult("HAVING clause cannot contain window functions!");
 }
 
 } // namespace duckdb

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

@@ -81,11 +81,6 @@ static void ReduceColumnDepth(vector<CorrelatedColumnInfo> &columns,
 	}
 }
 
-static void ReduceExpressionSubquery(BoundSubqueryExpression &expr,
-                                     const vector<CorrelatedColumnInfo> &correlated_columns) {
-	ReduceColumnDepth(expr.binder->correlated_columns, correlated_columns);
-}
-
 class ExpressionDepthReducerRecursive : public BoundNodeVisitor {
 public:
 	explicit ExpressionDepthReducerRecursive(const vector<CorrelatedColumnInfo> &correlated)
@@ -111,6 +106,13 @@ public:
 		BoundNodeVisitor::VisitBoundTableRef(ref);
 	}
 
+	static void ReduceExpressionSubquery(BoundSubqueryExpression &expr,
+	                                     const vector<CorrelatedColumnInfo> &correlated_columns) {
+		ReduceColumnDepth(expr.binder->correlated_columns, correlated_columns);
+		ExpressionDepthReducerRecursive recursive(correlated_columns);
+		recursive.VisitBoundQueryNode(*expr.subquery);
+	}
+
 private:
 	const vector<CorrelatedColumnInfo> &correlated_columns;
 };
@@ -127,9 +129,7 @@ protected:
 	}
 
 	unique_ptr<Expression> VisitReplace(BoundSubqueryExpression &expr, unique_ptr<Expression> *expr_ptr) override {
-		ReduceExpressionSubquery(expr, correlated_columns);
-		ExpressionDepthReducerRecursive recursive(correlated_columns);
-		recursive.VisitBoundQueryNode(*expr.subquery);
+		ExpressionDepthReducerRecursive::ReduceExpressionSubquery(expr, correlated_columns);
 		return nullptr;
 	}
 

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

@@ -1,5 +1,6 @@
 #include "duckdb/planner/expression_binder/order_binder.hpp"
 
+#include "duckdb/parser/expression/collate_expression.hpp"
 #include "duckdb/parser/expression/columnref_expression.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
 #include "duckdb/parser/expression/parameter_expression.hpp"
@@ -7,26 +8,23 @@
 #include "duckdb/parser/expression/star_expression.hpp"
 #include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/planner/binder.hpp"
+#include "duckdb/planner/expression/bound_constant_expression.hpp"
 #include "duckdb/planner/expression/bound_parameter_expression.hpp"
 #include "duckdb/planner/expression_binder.hpp"
+#include "duckdb/planner/expression_binder/select_bind_state.hpp"
+#include "duckdb/common/pair.hpp"
 
 namespace duckdb {
 
-OrderBinder::OrderBinder(vector<Binder *> binders, idx_t projection_index, case_insensitive_map_t<idx_t> &alias_map,
-                         parsed_expression_map_t<idx_t> &projection_map, idx_t max_count)
-    : binders(std::move(binders)), projection_index(projection_index), max_count(max_count), extra_list(nullptr),
-      alias_map(alias_map), projection_map(projection_map) {
+OrderBinder::OrderBinder(vector<Binder *> binders, SelectBindState &bind_state)
+    : binders(std::move(binders)), extra_list(nullptr), bind_state(bind_state) {
 }
-OrderBinder::OrderBinder(vector<Binder *> binders, idx_t projection_index, SelectNode &node,
-                         case_insensitive_map_t<idx_t> &alias_map, parsed_expression_map_t<idx_t> &projection_map)
-    : binders(std::move(binders)), projection_index(projection_index), alias_map(alias_map),
-      projection_map(projection_map) {
-	this->max_count = node.select_list.size();
+OrderBinder::OrderBinder(vector<Binder *> binders, SelectNode &node, SelectBindState &bind_state)
+    : binders(std::move(binders)), bind_state(bind_state) {
 	this->extra_list = &node.select_list;
 }
 
-unique_ptr<Expression> OrderBinder::CreateProjectionReference(ParsedExpression &expr, const idx_t index,
-                                                              const LogicalType &logical_type) {
+unique_ptr<Expression> OrderBinder::CreateProjectionReference(ParsedExpression &expr, const idx_t index) {
 	string alias;
 	if (extra_list && index < extra_list->size()) {
 		alias = extra_list->at(index)->ToString();
@@ -35,15 +33,18 @@ unique_ptr<Expression> OrderBinder::CreateProjectionReference(ParsedExpression &
 			alias = expr.alias;
 		}
 	}
-	return make_uniq<BoundColumnRefExpression>(std::move(alias), logical_type, ColumnBinding(projection_index, index));
+	auto result = make_uniq<BoundConstantExpression>(Value::UBIGINT(index));
+	result->alias = std::move(alias);
+	result->query_location = expr.query_location;
+	return std::move(result);
 }
 
 unique_ptr<Expression> OrderBinder::CreateExtraReference(unique_ptr<ParsedExpression> expr) {
 	if (!extra_list) {
 		throw InternalException("CreateExtraReference called without extra_list");
 	}
-	projection_map[*expr] = extra_list->size();
-	auto result = CreateProjectionReference(*expr, extra_list->size(), LogicalType::INVALID);
+	bind_state.projection_map[*expr] = extra_list->size();
+	auto result = CreateProjectionReference(*expr, extra_list->size());
 	extra_list->push_back(std::move(expr));
 	return result;
 }
@@ -57,8 +58,14 @@ unique_ptr<Expression> OrderBinder::BindConstant(ParsedExpression &expr, const V
 		return nullptr;
 	}
 	// INTEGER constant: we use the integer as an index into the select list (e.g. ORDER BY 1)
-	auto index = (idx_t)val.GetValue<int64_t>();
-	return CreateProjectionReference(expr, index - 1, LogicalType::ANY);
+	auto order_value = val.GetValue<int64_t>();
+	auto index = order_value <= 0 ? NumericLimits<idx_t>::Maximum() : idx_t(order_value - 1);
+	child_list_t<Value> values;
+	values.push_back(make_pair("index", Value::UBIGINT(index)));
+	auto result = make_uniq<BoundConstantExpression>(Value::STRUCT(std::move(values)));
+	result->alias = std::move(expr.alias);
+	result->query_location = expr.query_location;
+	return std::move(result);
 }
 
 unique_ptr<Expression> OrderBinder::Bind(unique_ptr<ParsedExpression> expr) {
@@ -83,23 +90,32 @@ unique_ptr<Expression> OrderBinder::Bind(unique_ptr<ParsedExpression> expr) {
 			break;
 		}
 		// check the alias list
-		auto entry = alias_map.find(colref.column_names[0]);
-		if (entry != alias_map.end()) {
+		auto entry = bind_state.alias_map.find(colref.column_names[0]);
+		if (entry != bind_state.alias_map.end()) {
 			// it does! point it to that entry
-			return CreateProjectionReference(*expr, entry->second, LogicalType::INVALID);
+			return CreateProjectionReference(*expr, entry->second);
 		}
 		break;
 	}
 	case ExpressionClass::POSITIONAL_REFERENCE: {
 		auto &posref = expr->Cast<PositionalReferenceExpression>();
-		if (posref.index < 1 || posref.index > max_count) {
-			throw BinderException("ORDER term out of range - should be between 1 and %lld", (idx_t)max_count);
-		}
-		return CreateProjectionReference(*expr, posref.index - 1, LogicalType::ANY);
+		return CreateProjectionReference(*expr, posref.index - 1);
 	}
 	case ExpressionClass::PARAMETER: {
 		throw ParameterNotAllowedException("Parameter not supported in ORDER BY clause");
 	}
+	case ExpressionClass::COLLATE: {
+		auto &collation = expr->Cast<CollateExpression>();
+		if (collation.child->expression_class == ExpressionClass::CONSTANT) {
+			auto &constant = collation.child->Cast<ConstantExpression>();
+			auto index = NumericCast<idx_t>(constant.value.GetValue<idx_t>()) - 1;
+			child_list_t<Value> values;
+			values.push_back(make_pair("index", Value::UBIGINT(index)));
+			values.push_back(make_pair("collation", Value(std::move(collation.collation))));
+			return make_uniq<BoundConstantExpression>(Value::STRUCT(std::move(values)));
+		}
+		break;
+	}
 	default:
 		break;
 	}
@@ -109,14 +125,14 @@ unique_ptr<Expression> OrderBinder::Bind(unique_ptr<ParsedExpression> expr) {
 		ExpressionBinder::QualifyColumnNames(*binder, expr);
 	}
 	// first check if the ORDER BY clause already points to an entry in the projection list
-	auto entry = projection_map.find(*expr);
-	if (entry != projection_map.end()) {
+	auto entry = bind_state.projection_map.find(*expr);
+	if (entry != bind_state.projection_map.end()) {
 		if (entry->second == DConstants::INVALID_INDEX) {
 			throw BinderException("Ambiguous reference to column");
 		}
 		// there is a matching entry in the projection list
 		// just point to that entry
-		return CreateProjectionReference(*expr, entry->second, LogicalType::INVALID);
+		return CreateProjectionReference(*expr, entry->second);
 	}
 	if (!extra_list) {
 		// no extra list specified: we cannot push an extra ORDER BY clause