duckdb 0.9.3-dev0.0 → 0.9.3-dev12.0

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

@@ -40,7 +40,6 @@ public:
 
 BindResult ExpressionBinder::BindExpression(SubqueryExpression &expr, idx_t depth) {
 	if (expr.subquery->node->type != QueryNodeType::BOUND_SUBQUERY_NODE) {
-		D_ASSERT(depth == 0);
 		// first bind the actual subquery in a new binder
 		auto subquery_binder = Binder::CreateBinder(context, &binder);
 		subquery_binder->can_contain_nulls = true;
@@ -56,8 +55,7 @@ BindResult ExpressionBinder::BindExpression(SubqueryExpression &expr, idx_t dept
 			}
 		}
 		if (expr.subquery_type != SubqueryType::EXISTS && bound_node->types.size() > 1) {
-			throw BinderException(binder.FormatError(
-			    expr, StringUtil::Format("Subquery returns %zu columns - expected 1", bound_node->types.size())));
+			throw BinderException(expr, "Subquery returns %zu columns - expected 1", bound_node->types.size());
 		}
 		auto prior_subquery = std::move(expr.subquery);
 		expr.subquery = make_uniq<SelectStatement>();
@@ -67,9 +65,9 @@ BindResult ExpressionBinder::BindExpression(SubqueryExpression &expr, idx_t dept
 	// now bind the child node of the subquery
 	if (expr.child) {
 		// first bind the children of the subquery, if any
-		string error = Bind(expr.child, depth);
-		if (!error.empty()) {
-			return BindResult(error);
+		auto error = Bind(expr.child, depth);
+		if (error.HasError()) {
+			return BindResult(std::move(error));
 		}
 	}
 	// both binding the child and binding the subquery was successful
@@ -89,7 +87,13 @@ BindResult ExpressionBinder::BindExpression(SubqueryExpression &expr, idx_t dept
 		// cast child and subquery child to equivalent types
 		D_ASSERT(bound_node->types.size() == 1);
 		auto &child = BoundExpression::GetExpression(*expr.child);
-		auto compare_type = LogicalType::MaxLogicalType(child->return_type, bound_node->types[0]);
+		auto child_type = ExpressionBinder::GetExpressionReturnType(*child);
+		LogicalType compare_type;
+		if (!LogicalType::TryGetMaxLogicalType(context, child_type, bound_node->types[0], compare_type)) {
+			throw BinderException(
+			    expr, "Cannot compare values of type %s and %s in IN/ANY/ALL clause - an explicit cast is required",
+			    child_type.ToString(), 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;

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

@@ -20,7 +20,7 @@ unique_ptr<Expression> CreateBoundStructExtract(ClientContext &context, unique_p
 	vector<unique_ptr<Expression>> arguments;
 	arguments.push_back(std::move(expr));
 	arguments.push_back(make_uniq<BoundConstantExpression>(Value(key)));
-	auto extract_function = StructExtractFun::GetFunction();
+	auto extract_function = StructExtractFun::KeyExtractFunction();
 	auto bind_info = extract_function.bind(context, extract_function, arguments);
 	auto return_type = extract_function.return_type;
 	auto result = make_uniq<BoundFunctionExpression>(return_type, std::move(extract_function), std::move(arguments),
@@ -29,14 +29,27 @@ unique_ptr<Expression> CreateBoundStructExtract(ClientContext &context, unique_p
 	return std::move(result);
 }
 
+unique_ptr<Expression> CreateBoundStructExtractIndex(ClientContext &context, unique_ptr<Expression> expr, idx_t key) {
+	vector<unique_ptr<Expression>> arguments;
+	arguments.push_back(std::move(expr));
+	arguments.push_back(make_uniq<BoundConstantExpression>(Value::BIGINT(int64_t(key))));
+	auto extract_function = StructExtractFun::IndexExtractFunction();
+	auto bind_info = extract_function.bind(context, extract_function, arguments);
+	auto return_type = extract_function.return_type;
+	auto result = make_uniq<BoundFunctionExpression>(return_type, std::move(extract_function), std::move(arguments),
+	                                                 std::move(bind_info));
+	result->alias = "element" + to_string(key);
+	return std::move(result);
+}
+
 BindResult SelectBinder::BindUnnest(FunctionExpression &function, idx_t depth, bool root_expression) {
 	// bind the children of the function expression
 	if (depth > 0) {
-		return BindResult(binder.FormatError(function, "UNNEST() for correlated expressions is not supported yet"));
+		return BindResult(BinderException(function, "UNNEST() for correlated expressions is not supported yet"));
 	}
-	string error;
+	ErrorData error;
 	if (function.children.empty()) {
-		return BindResult(binder.FormatError(function, "UNNEST() requires a single argument"));
+		return BindResult(BinderException(function, "UNNEST() requires a single argument"));
 	}
 	idx_t max_depth = 1;
 	if (function.children.size() != 1) {
@@ -44,7 +57,7 @@ BindResult SelectBinder::BindUnnest(FunctionExpression &function, idx_t depth, b
 		bool supported_argument = false;
 		for (idx_t i = 1; i < function.children.size(); i++) {
 			if (has_parameter) {
-				return BindResult(binder.FormatError(function, "UNNEST() only supports a single additional argument"));
+				return BindResult(BinderException(function, "UNNEST() only supports a single additional argument"));
 			}
 			if (function.children[i]->HasParameter()) {
 				throw ParameterNotAllowedException("Parameter not allowed in unnest parameter");
@@ -54,8 +67,8 @@ BindResult SelectBinder::BindUnnest(FunctionExpression &function, idx_t depth, b
 			}
 			auto alias = function.children[i]->alias;
 			BindChild(function.children[i], depth, error);
-			if (!error.empty()) {
-				return BindResult(error);
+			if (error.HasError()) {
+				return BindResult(std::move(error));
 			}
 			auto &const_child = BoundExpression::GetExpression(*function.children[i]);
 			auto value = ExpressionExecutor::EvaluateScalar(context, *const_child, true);
@@ -78,17 +91,18 @@ BindResult SelectBinder::BindUnnest(FunctionExpression &function, idx_t depth, b
 			supported_argument = true;
 		}
 		if (!supported_argument) {
-			return BindResult(binder.FormatError(function, "UNNEST - unsupported extra argument, unnest only supports "
-			                                               "recursive := [true/false] or max_depth := #"));
+			return BindResult(BinderException(function, "UNNEST - unsupported extra argument, unnest only supports "
+			                                            "recursive := [true/false] or max_depth := #"));
 		}
 	}
 	unnest_level++;
 	BindChild(function.children[0], depth, error);
-	if (!error.empty()) {
+	if (error.HasError()) {
 		// failed to bind
 		// try to bind correlated columns manually
-		if (!BindCorrelatedColumns(function.children[0])) {
-			return BindResult(error);
+		auto result = BindCorrelatedColumns(function.children[0], error);
+		if (result.HasError()) {
+			return BindResult(result.error);
 		}
 		auto &bound_expr = BoundExpression::GetExpression(*function.children[0]);
 		ExtractCorrelatedExpressions(binder, *bound_expr);
@@ -99,6 +113,7 @@ BindResult SelectBinder::BindUnnest(FunctionExpression &function, idx_t depth, b
 
 	if (unnest_level > 0) {
 		throw BinderException(
+		    function,
 		    "Nested UNNEST calls are not supported - use UNNEST(x, recursive := true) to unnest multiple levels");
 	}
 
@@ -110,7 +125,7 @@ BindResult SelectBinder::BindUnnest(FunctionExpression &function, idx_t depth, b
 	case LogicalTypeId::SQLNULL:
 		break;
 	default:
-		return BindResult(binder.FormatError(function, "UNNEST() can only be applied to lists, structs and NULL"));
+		return BindResult(BinderException(function, "UNNEST() can only be applied to lists, structs and NULL"));
 	}
 
 	idx_t list_unnests;
@@ -120,7 +135,7 @@ BindResult SelectBinder::BindUnnest(FunctionExpression &function, idx_t depth, b
 	if (child_type.id() == LogicalTypeId::SQLNULL) {
 		list_unnests = 1;
 	} else {
-		// first do all of the list unnests
+		// perform all LIST unnests
 		auto type = child_type;
 		list_unnests = 0;
 		while (type.id() == LogicalTypeId::LIST) {
@@ -130,16 +145,17 @@ BindResult SelectBinder::BindUnnest(FunctionExpression &function, idx_t depth, b
 				break;
 			}
 		}
-		// unnest structs all the way afterwards, if there are any
+		// unnest structs
 		if (type.id() == LogicalTypeId::STRUCT) {
 			struct_unnests = max_depth - list_unnests;
 		}
 	}
 	if (struct_unnests > 0 && !root_expression) {
-		return BindResult(binder.FormatError(
+		child = std::move(unnest_expr);
+		return BindResult(BinderException(
 		    function, "UNNEST() on a struct column can only be applied as the root element of a SELECT expression"));
 	}
-	// perform all of the list unnests first
+	// perform all LIST unnests
 	auto return_type = child_type;
 	for (idx_t current_depth = 0; current_depth < list_unnests; current_depth++) {
 		if (return_type.id() == LogicalTypeId::LIST) {
@@ -182,8 +198,15 @@ BindResult SelectBinder::BindUnnest(FunctionExpression &function, idx_t depth, b
 				if (expr->return_type.id() == LogicalTypeId::STRUCT) {
 					// struct! push a struct_extract
 					auto &child_types = StructType::GetChildTypes(expr->return_type);
-					for (auto &entry : child_types) {
-						new_expressions.push_back(CreateBoundStructExtract(context, expr->Copy(), entry.first));
+					if (StructType::IsUnnamed(expr->return_type)) {
+						for (idx_t child_index = 0; child_index < child_types.size(); child_index++) {
+							new_expressions.push_back(
+							    CreateBoundStructExtractIndex(context, expr->Copy(), child_index + 1));
+						}
+					} else {
+						for (auto &entry : child_types) {
+							new_expressions.push_back(CreateBoundStructExtract(context, expr->Copy(), entry.first));
+						}
 					}
 					has_structs = true;
 				} else {

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

@@ -1,4 +1,6 @@
 #include "duckdb/parser/expression/window_expression.hpp"
+#include "duckdb/parser/expression/constant_expression.hpp"
+#include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "duckdb/planner/expression/bound_cast_expression.hpp"
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
@@ -101,11 +103,11 @@ static LogicalType BindRangeExpression(ClientContext &context, const string &nam
 	auto &bound = BoundExpression::GetExpression(*expr);
 	children.emplace_back(std::move(bound));
 
-	string error;
+	ErrorData error;
 	FunctionBinder function_binder(context);
 	auto function = function_binder.BindScalarFunction(DEFAULT_SCHEMA, name, std::move(children), error, true);
 	if (!function) {
-		throw BinderException(error);
+		error.Throw();
 	}
 	bound = std::move(function);
 	return bound->return_type;
@@ -114,23 +116,24 @@ static LogicalType BindRangeExpression(ClientContext &context, const string &nam
 BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 	auto name = window.GetName();
 
-	QueryErrorContext error_context(binder.GetRootStatement(), window.query_location);
+	QueryErrorContext error_context(window.query_location);
 	if (inside_window) {
-		throw BinderException(error_context.FormatError("window function calls cannot be nested"));
+		throw BinderException(error_context, "window function calls cannot be nested");
 	}
 	if (depth > 0) {
-		throw BinderException(error_context.FormatError("correlated columns in window functions not supported"));
+		throw BinderException(error_context, "correlated columns in window functions not supported");
 	}
 	// If we have range expressions, then only one order by clause is allowed.
-	if ((window.start == WindowBoundary::EXPR_PRECEDING_RANGE || window.start == WindowBoundary::EXPR_FOLLOWING_RANGE ||
-	     window.end == WindowBoundary::EXPR_PRECEDING_RANGE || window.end == WindowBoundary::EXPR_FOLLOWING_RANGE) &&
-	    window.orders.size() != 1) {
-		throw BinderException(error_context.FormatError("RANGE frames must have only one ORDER BY expression"));
+	const auto is_range =
+	    (window.start == WindowBoundary::EXPR_PRECEDING_RANGE || window.start == WindowBoundary::EXPR_FOLLOWING_RANGE ||
+	     window.end == WindowBoundary::EXPR_PRECEDING_RANGE || window.end == WindowBoundary::EXPR_FOLLOWING_RANGE);
+	if (is_range && window.orders.size() != 1) {
+		throw BinderException(error_context, "RANGE frames must have only one ORDER BY expression");
 	}
 	// bind inside the children of the window function
 	// we set the inside_window flag to true to prevent binding nested window functions
 	this->inside_window = true;
-	string error;
+	ErrorData error;
 	for (auto &child : window.children) {
 		BindChild(child, depth, error);
 	}
@@ -139,6 +142,21 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 	}
 	for (auto &order : window.orders) {
 		BindChild(order.expression, depth, error);
+
+		//	If the frame is a RANGE frame and the type is a time,
+		//	then we have to convert the time to a timestamp to avoid wrapping.
+		if (!is_range) {
+			continue;
+		}
+		auto &order_expr = order.expression;
+		auto &bound_order = BoundExpression::GetExpression(*order_expr);
+		const auto type_id = bound_order->return_type.id();
+		if (type_id == LogicalTypeId::TIME || type_id == LogicalTypeId::TIME_TZ) {
+			//	Convert to time + epoch and rebind
+			unique_ptr<ParsedExpression> epoch = make_uniq<ConstantExpression>(Value::DATE(date_t::epoch()));
+			BindChild(epoch, depth, error);
+			BindRangeExpression(context, "+", order.expression, epoch);
+		}
 	}
 	BindChild(window.filter_expr, depth, error);
 	BindChild(window.start_expr, depth, error);
@@ -147,9 +165,9 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 	BindChild(window.default_expr, depth, error);
 
 	this->inside_window = false;
-	if (!error.empty()) {
+	if (error.HasError()) {
 		// failed to bind children of window function
-		return BindResult(error);
+		return BindResult(std::move(error));
 	}
 
 	//	Restore any collation expressions
@@ -179,6 +197,7 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 			if (argno == 1) {
 				bound = BoundCastExpression::AddCastToType(context, std::move(bound), LogicalType::BIGINT);
 			}
+			break;
 		default:
 			break;
 		}
@@ -196,11 +215,12 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 		D_ASSERT(func.type == CatalogType::AGGREGATE_FUNCTION_ENTRY);
 
 		// bind the aggregate
-		string error;
+		ErrorData error;
 		FunctionBinder function_binder(context);
 		auto best_function = function_binder.BindFunction(func.name, func.functions, types, error);
 		if (best_function == DConstants::INVALID_INDEX) {
-			throw BinderException(binder.FormatError(window, error));
+			error.AddQueryLocation(window);
+			error.Throw();
 		}
 		// found a matching function! bind it as an aggregate
 		auto bound_function = func.functions.GetFunctionByOffset(best_function);
@@ -220,6 +240,7 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 		result->partitions.push_back(GetExpression(child));
 	}
 	result->ignore_nulls = window.ignore_nulls;
+	result->distinct = window.distinct;
 
 	// Convert RANGE boundary expressions to ORDER +/- expressions.
 	// Note that PRECEEDING and FOLLOWING refer to the sequential order in the frame,
@@ -263,10 +284,10 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 		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);
+			order_type = LogicalType::MaxLogicalType(context, order_type, start_type);
 		}
 		if (window.end_expr) {
-			order_type = LogicalType::MaxLogicalType(order_type, end_type);
+			order_type = LogicalType::MaxLogicalType(context, order_type, end_type);
 		}
 
 		// Cast all three to match
@@ -289,6 +310,7 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 	result->default_expr = CastWindowExpression(window.default_expr, result->return_type);
 	result->start = window.start;
 	result->end = window.end;
+	result->exclude_clause = window.exclude_clause;
 
 	// create a BoundColumnRef that references this entry
 	auto colref = make_uniq<BoundColumnRefExpression>(std::move(name), result->return_type,

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

@@ -30,8 +30,19 @@ unique_ptr<BoundQueryNode> Binder::BindNode(CTENode &statement) {
 		result->names[i] = statement.aliases[i];
 	}
 
+	// Rename columns if duplicate names are detected
+	idx_t index = 1;
+	vector<string> names;
+	for (auto &n : result->names) {
+		string name = n;
+		while (find(names.begin(), names.end(), name) != names.end()) {
+			name = n + "_" + std::to_string(index++);
+		}
+		names.push_back(name);
+	}
+
 	// This allows the right side to reference the CTE
-	bind_context.AddGenericBinding(result->setop_index, statement.ctename, result->names, result->types);
+	bind_context.AddGenericBinding(result->setop_index, statement.ctename, names, result->types);
 
 	result->child_binder = Binder::CreateBinder(context, this);
 
@@ -43,17 +54,15 @@ unique_ptr<BoundQueryNode> Binder::BindNode(CTENode &statement) {
 	statement.modifiers.clear();
 
 	// Add bindings of left side to temporary CTE bindings context
-	result->child_binder->bind_context.AddCTEBinding(result->setop_index, statement.ctename, result->names,
-	                                                 result->types);
+	result->child_binder->bind_context.AddCTEBinding(result->setop_index, statement.ctename, names, result->types);
 	result->child = result->child_binder->BindNode(*statement.child);
+	for (auto &c : result->query_binder->correlated_columns) {
+		result->child_binder->AddCorrelatedColumn(c);
+	}
 
 	// the result types of the CTE are the types of the LHS
 	result->types = result->child->types;
-	// names are picked from the LHS, unless aliases are explicitly specified
 	result->names = result->child->names;
-	for (idx_t i = 0; i < statement.aliases.size() && i < result->names.size(); i++) {
-		result->names[i] = statement.aliases[i];
-	}
 
 	MoveCorrelatedExpressions(*result->query_binder);
 	MoveCorrelatedExpressions(*result->child_binder);

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

@@ -40,6 +40,9 @@ unique_ptr<BoundQueryNode> Binder::BindNode(RecursiveCTENode &statement) {
 	result->right_binder->bind_context.AddCTEBinding(result->setop_index, statement.ctename, result->names,
 	                                                 result->types);
 	result->right = result->right_binder->BindNode(*statement.right);
+	for (auto &c : result->left_binder->correlated_columns) {
+		result->right_binder->AddCorrelatedColumn(c);
+	}
 
 	// move the correlated expressions from the child binders to this binder
 	MoveCorrelatedExpressions(*result->left_binder);

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

@@ -24,11 +24,12 @@
 #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"
 
 namespace duckdb {
 
 unique_ptr<Expression> Binder::BindOrderExpression(OrderBinder &order_binder, unique_ptr<ParsedExpression> expr) {
-	// we treat the Distinct list as a order by
+	// we treat the distinct list as an ORDER BY
 	auto bound_expr = order_binder.Bind(std::move(expr));
 	if (!bound_expr) {
 		// DISTINCT ON non-integer constant
@@ -98,7 +99,7 @@ unique_ptr<BoundResultModifier> Binder::BindLimitPercent(OrderBinder &order_bind
 		if (!result->limit) {
 			result->limit_percent = val.IsNull() ? 100 : val.GetValue<double>();
 			if (result->limit_percent < 0.0) {
-				throw Exception("Limit percentage can't be negative value");
+				throw InvalidInputException("Limit percentage can't be negative value");
 			}
 		}
 	}
@@ -158,6 +159,36 @@ void Binder::BindModifiers(OrderBinder &order_binder, QueryNode &statement, Boun
 					order.orders = std::move(new_orders);
 				}
 			}
+#if 0
+			// When this verification is enabled, replace ORDER BY x, y with ORDER BY create_sort_key(x, y)
+			// note that we don't enable this during actual verification since it doesn't always work
+			// e.g. it breaks EXPLAIN output on queries
+			bool can_replace = true;
+			for (auto &order_node : order.orders) {
+				if (order_node.expression->type == ExpressionType::VALUE_CONSTANT) {
+					// we cannot replace the sort key when we order by literals (e.g. ORDER BY 1, 2`
+					can_replace = false;
+					break;
+				}
+			}
+			if (!order_binder.HasExtraList()) {
+				// we can only do the replacement when we can order by elements that are not in the selection list
+				can_replace = false;
+			}
+			if (can_replace) {
+				vector<unique_ptr<ParsedExpression>> sort_key_parameters;
+				for (auto &order_node : order.orders) {
+					sort_key_parameters.push_back(std::move(order_node.expression));
+					auto type = config.ResolveOrder(order_node.type);
+					auto null_order = config.ResolveNullOrder(type, order_node.null_order);
+					string sort_param = EnumUtil::ToString(type) + " " + EnumUtil::ToString(null_order);
+					sort_key_parameters.push_back(make_uniq<ConstantExpression>(Value(sort_param)));
+				}
+				order.orders.clear();
+				auto create_sort_key = make_uniq<FunctionExpression>("create_sort_key", std::move(sort_key_parameters));
+				order.orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_LAST, std::move(create_sort_key));
+			}
+#endif
 			for (auto &order_node : order.orders) {
 				vector<unique_ptr<ParsedExpression>> order_list;
 				order_binders[0]->ExpandStarExpression(std::move(order_node.expression), order_list);
@@ -184,7 +215,7 @@ void Binder::BindModifiers(OrderBinder &order_binder, QueryNode &statement, Boun
 			bound_modifier = BindLimitPercent(order_binder, mod->Cast<LimitPercentModifier>());
 			break;
 		default:
-			throw Exception("Unsupported result modifier");
+			throw InternalException("Unsupported result modifier");
 		}
 		if (bound_modifier) {
 			result.modifiers.push_back(std::move(bound_modifier));
@@ -203,7 +234,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 projection_index) {
+void Binder::BindModifierTypes(BoundQueryNode &result, const vector<LogicalType> &sql_types, idx_t,
+                               const vector<idx_t> &expansion_count) {
 	for (auto &bound_mod : result.modifiers) {
 		switch (bound_mod->type) {
 		case ResultModifierType::DISTINCT_MODIFIER: {
@@ -216,7 +248,13 @@ void Binder::BindModifierTypes(BoundQueryNode &result, const vector<LogicalType>
 				if (bound_colref.binding.column_index == DConstants::INVALID_INDEX) {
 					throw BinderException("Ambiguous name in DISTINCT ON!");
 				}
-				D_ASSERT(bound_colref.binding.column_index < sql_types.size());
+
+				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);
+				}
+
 				bound_colref.return_type = sql_types[bound_colref.binding.column_index];
 			}
 			for (auto &target_distinct : distinct.target_distincts) {
@@ -239,17 +277,30 @@ void Binder::BindModifierTypes(BoundQueryNode &result, const vector<LogicalType>
 			break;
 		}
 		case ResultModifierType::ORDER_MODIFIER: {
+
 			auto &order = bound_mod->Cast<BoundOrderModifier>();
 			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!");
 				}
-				D_ASSERT(bound_colref.binding.column_index < sql_types.size());
+
+				if (!expansion_count.empty() && bound_colref.return_type.id() != LogicalTypeId::ANY) {
+					bound_colref.binding.column_index = expansion_count[bound_colref.binding.column_index];
+				}
+
+				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);
+				}
+
 				const auto &sql_type = sql_types[bound_colref.binding.column_index];
-				bound_colref.return_type = sql_types[bound_colref.binding.column_index];
+				bound_colref.return_type = sql_type;
+
 				ExpressionBinder::PushCollation(context, order_node.expression, sql_type);
 			}
 			break;
@@ -434,9 +485,15 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 
 	// after that, we bind to the SELECT list
 	SelectBinder select_binder(*this, context, *result, info, alias_map);
-	vector<LogicalType> internal_sql_types;
+
+	// 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;
+
 	for (idx_t i = 0; i < statement.select_list.size(); i++) {
 		bool is_window = statement.select_list[i]->IsWindow();
 		idx_t unnest_count = result->unnests.size();
@@ -445,6 +502,7 @@ 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;
+
 		if (select_binder.HasExpandedExpressions()) {
 			if (!is_original_column) {
 				throw InternalException("Only original columns can have expanded expressions");
@@ -452,16 +510,26 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 			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();
 			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);
 				result->select_list.push_back(std::move(struct_expr));
 			}
+
 			struct_expressions.clear();
 			continue;
 		}
+
+		// not an expanded expression
+		modifier_expansion_count.push_back(modifier_sql_types.size());
+		modifier_sql_types.push_back(result_type);
+
 		if (can_group_by_all && select_binder.HasBoundColumns()) {
 			if (select_binder.BoundAggregates()) {
 				throw BinderException("Cannot mix aggregates with non-aggregated columns!");
@@ -476,16 +544,18 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 			// this entry becomes a group
 			group_by_all_indexes.push_back(i);
 		}
+
 		result->select_list.push_back(std::move(expr));
 		if (is_original_column) {
 			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();
 		}
 	}
+
 	// push the GROUP BY ALL expressions into the group set
 	for (auto &group_by_all_index : group_by_all_indexes) {
 		auto &expr = result->select_list[group_by_all_index];
@@ -523,13 +593,14 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 				if (statement.aggregate_handling == AggregateHandling::FORCE_AGGREGATES) {
 					error += "\nGROUP BY ALL will only group entries in the SELECT list. Add it to the SELECT list or "
 					         "GROUP BY this entry explicitly.";
+					throw BinderException(bound_columns[0].query_location, error, bound_columns[0].name);
 				} else {
 					error +=
 					    "\nEither add it to the GROUP BY list, or use \"ANY_VALUE(%s)\" if the exact value of \"%s\" "
 					    "is not important.";
+					throw BinderException(bound_columns[0].query_location, error, bound_columns[0].name,
+					                      bound_columns[0].name, bound_columns[0].name);
 				}
-				throw BinderException(FormatError(bound_columns[0].query_location, error, bound_columns[0].name,
-				                                  bound_columns[0].name, bound_columns[0].name));
 			}
 		}
 	}
@@ -541,7 +612,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, internal_sql_types, result->projection_index);
+	BindModifierTypes(*result, modifier_sql_types, result->projection_index, modifier_expansion_count);
 	return std::move(result);
 }