duckdb 0.10.1-dev6.0 → 0.10.1

package/src/duckdb/src/parser/transform/statement/transform_pivot_stmt.cpp

@@ -168,7 +168,8 @@ unique_ptr<QueryNode> Transformer::TransformPivotStatement(duckdb_libpgquery::PG
 	}
 
 	// generate CREATE TYPE statements for each of the columns that do not have an IN list
-	auto columns = TransformPivotList(*pivot->columns);
+	bool is_pivot = !pivot->unpivots;
+	auto columns = TransformPivotList(*pivot->columns, is_pivot);
 	auto pivot_idx = PivotEntryCount();
 	for (idx_t c = 0; c < columns.size(); c++) {
 		auto &col = columns[c];
@@ -209,6 +210,7 @@ unique_ptr<QueryNode> Transformer::TransformPivotStatement(duckdb_libpgquery::PG
 		pivot_ref->groups = TransformStringList(pivot->groups);
 	}
 	pivot_ref->pivots = std::move(columns);
+	SetQueryLocation(*pivot_ref, pivot->location);
 	select_node->from_table = std::move(pivot_ref);
 	// transform order by/limit modifiers
 	TransformModifiers(select, *select_node);

package/src/duckdb/src/parser/transform/statement/transform_show_select.cpp

@@ -9,14 +9,13 @@ namespace duckdb {
 
 unique_ptr<SelectStatement> Transformer::TransformShowSelect(duckdb_libpgquery::PGVariableShowSelectStmt &stmt) {
 	// we capture the select statement of SHOW
-	auto select_stmt = PGPointerCast<duckdb_libpgquery::PGSelectStmt>(stmt.stmt);
-
 	auto select_node = make_uniq<SelectNode>();
 	select_node->select_list.push_back(make_uniq<StarExpression>());
 
 	auto show_ref = make_uniq<ShowRef>();
 	show_ref->show_type = stmt.is_summary ? ShowType::SUMMARY : ShowType::DESCRIBE;
-	show_ref->query = TransformSelectNode(*select_stmt);
+	auto select = TransformSelect(stmt.stmt);
+	show_ref->query = std::move(select->node);
 	select_node->from_table = std::move(show_ref);
 
 	auto result = make_uniq<SelectStatement>();

package/src/duckdb/src/parser/transform/statement/ub_duckdb_transformer_statement.cpp

@@ -0,0 +1,37 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_alter_table.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_attach.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_detach.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_call.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_checkpoint.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_create_function.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_copy.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_create_table_as.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_create_index.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_create_schema.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_create_table.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_create_view.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_create_type.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_delete.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_explain.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_export.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_drop.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_import.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_insert.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_load.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_pragma.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_rename.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_select.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_select_node.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_set.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_pivot_stmt.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_prepare.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_show.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_show_select.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_transaction.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_update.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_upsert.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_use.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_create_sequence.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_vacuum.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/statement/transform_alter_sequence.cpp>

package/src/duckdb/src/parser/transform/tableref/transform_join.cpp

@@ -2,6 +2,9 @@
 #include "duckdb/parser/tableref/basetableref.hpp"
 #include "duckdb/parser/tableref/joinref.hpp"
 #include "duckdb/parser/transformer.hpp"
+#include "duckdb/parser/query_node/select_node.hpp"
+#include "duckdb/parser/tableref/subqueryref.hpp"
+#include "duckdb/parser/expression/star_expression.hpp"
 
 namespace duckdb {
 
@@ -70,6 +73,19 @@ unique_ptr<TableRef> Transformer::TransformJoin(duckdb_libpgquery::PGJoinExpr &r
 		result->ref_type = JoinRefType::CROSS;
 	}
 	result->condition = TransformExpression(root.quals);
+	if (root.alias) {
+		// join with an alias - wrap it in a subquery
+		auto select_node = make_uniq<SelectNode>();
+		select_node->select_list.push_back(make_uniq<StarExpression>());
+		select_node->from_table = std::move(result);
+		auto select = make_uniq<SelectStatement>();
+		select->node = std::move(select_node);
+		auto subquery = make_uniq<SubqueryRef>(std::move(select));
+		SetQueryLocation(*subquery, root.location);
+		// apply the alias to that subquery
+		subquery->alias = TransformAlias(root.alias, subquery->column_name_alias);
+		return std::move(subquery);
+	}
 	return std::move(result);
 }
 

package/src/duckdb/src/parser/transform/tableref/transform_pivot.cpp

@@ -7,42 +7,49 @@
 
 namespace duckdb {
 
-void Transformer::TransformPivotInList(unique_ptr<ParsedExpression> &expr, PivotColumnEntry &entry, bool root_entry) {
-	if (expr->type == ExpressionType::COLUMN_REF) {
+bool Transformer::TransformPivotInList(unique_ptr<ParsedExpression> &expr, PivotColumnEntry &entry, bool root_entry) {
+	switch (expr->type) {
+	case ExpressionType::COLUMN_REF: {
 		auto &colref = expr->Cast<ColumnRefExpression>();
 		if (colref.IsQualified()) {
-			throw ParserException("PIVOT IN list cannot contain qualified column references");
+			throw ParserException(expr->query_location, "PIVOT IN list cannot contain qualified column references");
 		}
 		entry.values.emplace_back(colref.GetColumnName());
-	} else if (root_entry && expr->type == ExpressionType::FUNCTION) {
+		return true;
+	}
+	case ExpressionType::FUNCTION: {
 		auto &function = expr->Cast<FunctionExpression>();
 		if (function.function_name != "row") {
-			throw ParserException("PIVOT IN list must contain columns or lists of columns");
+			return false;
 		}
 		for (auto &child : function.children) {
-			TransformPivotInList(child, entry, false);
+			if (!TransformPivotInList(child, entry, false)) {
+				return false;
+			}
 		}
-	} else if (root_entry && expr->type == ExpressionType::STAR) {
-		entry.star_expr = std::move(expr);
-	} else {
+		return true;
+	}
+	default: {
 		Value val;
 		if (!Transformer::ConstructConstantFromExpression(*expr, val)) {
-			throw ParserException("PIVOT IN list must contain columns or lists of columns");
+			return false;
 		}
 		entry.values.push_back(std::move(val));
+		return true;
+	}
 	}
 }
 
-PivotColumn Transformer::TransformPivotColumn(duckdb_libpgquery::PGPivot &pivot) {
+PivotColumn Transformer::TransformPivotColumn(duckdb_libpgquery::PGPivot &pivot, bool is_pivot) {
 	PivotColumn col;
 	if (pivot.pivot_columns) {
 		TransformExpressionList(*pivot.pivot_columns, col.pivot_expressions);
 		for (auto &expr : col.pivot_expressions) {
 			if (expr->IsScalar()) {
-				throw ParserException("Cannot pivot on constant value \"%s\"", expr->ToString());
+				throw ParserException(expr->query_location, "Cannot pivot on constant value \"%s\"", expr->ToString());
 			}
 			if (expr->HasSubquery()) {
-				throw ParserException("Cannot pivot on subquery \"%s\"", expr->ToString());
+				throw ParserException(expr->query_location, "Cannot pivot on subquery \"%s\"", expr->ToString());
 			}
 		}
 	} else if (pivot.unpivot_columns) {
@@ -56,7 +63,18 @@ PivotColumn Transformer::TransformPivotColumn(duckdb_libpgquery::PGPivot &pivot)
 			auto expr = TransformExpression(n);
 			PivotColumnEntry entry;
 			entry.alias = expr->alias;
-			TransformPivotInList(expr, entry);
+			auto transformed = TransformPivotInList(expr, entry);
+			if (!transformed) {
+				// could not transform into list of constant values
+				if (is_pivot) {
+					// for pivot - throw an exception
+					throw ParserException(expr->query_location,
+					                      "PIVOT IN list must contain columns or lists of columns");
+				} else {
+					// for unpivot - we can forward the expression immediately
+					entry.expr = std::move(expr);
+				}
+			}
 			col.entries.push_back(std::move(entry));
 		}
 	}
@@ -69,11 +87,11 @@ PivotColumn Transformer::TransformPivotColumn(duckdb_libpgquery::PGPivot &pivot)
 	return col;
 }
 
-vector<PivotColumn> Transformer::TransformPivotList(duckdb_libpgquery::PGList &list) {
+vector<PivotColumn> Transformer::TransformPivotList(duckdb_libpgquery::PGList &list, bool is_pivot) {
 	vector<PivotColumn> result;
 	for (auto node = list.head; node != nullptr; node = node->next) {
 		auto pivot = PGPointerCast<duckdb_libpgquery::PGPivot>(node->data.ptr_value);
-		result.push_back(TransformPivotColumn(*pivot));
+		result.push_back(TransformPivotColumn(*pivot, is_pivot));
 	}
 	return result;
 }
@@ -87,41 +105,40 @@ unique_ptr<TableRef> Transformer::TransformPivot(duckdb_libpgquery::PGPivotExpr
 	if (root.unpivots) {
 		result->unpivot_names = TransformStringList(root.unpivots);
 	}
-	result->pivots = TransformPivotList(*root.pivots);
-	if (!result->unpivot_names.empty() && result->pivots.size() > 1) {
+	auto is_pivot = result->unpivot_names.empty();
+	result->pivots = TransformPivotList(*root.pivots, is_pivot);
+	if (!is_pivot && result->pivots.size() > 1) {
 		throw ParserException("UNPIVOT requires a single pivot element");
 	}
 	if (root.groups) {
 		result->groups = TransformStringList(root.groups);
 	}
 	for (auto &pivot : result->pivots) {
-		idx_t expected_size;
-		bool is_pivot = result->unpivot_names.empty();
-		if (!result->unpivot_names.empty()) {
+		if (!is_pivot) {
 			// unpivot
 			if (pivot.unpivot_names.size() != 1) {
 				throw ParserException("UNPIVOT requires a single column name for the PIVOT IN clause");
 			}
 			D_ASSERT(pivot.pivot_expressions.empty());
-			expected_size = pivot.entries[0].values.size();
 		} else {
 			// pivot
-			expected_size = pivot.pivot_expressions.size();
+			auto expected_size = pivot.pivot_expressions.size();
 			D_ASSERT(pivot.unpivot_names.empty());
-		}
-		for (auto &entry : pivot.entries) {
-			if (entry.star_expr && is_pivot) {
-				throw ParserException("PIVOT IN list must contain columns or lists of columns - star expressions are "
-				                      "only supported for UNPIVOT");
-			}
-			if (entry.values.size() != expected_size) {
-				throw ParserException("PIVOT IN list - inconsistent amount of rows - expected %d but got %d",
-				                      expected_size, entry.values.size());
+			for (auto &entry : pivot.entries) {
+				if (entry.expr) {
+					throw ParserException("PIVOT IN list must contain columns or lists of columns - expressions are "
+					                      "only supported for UNPIVOT");
+				}
+				if (entry.values.size() != expected_size) {
+					throw ParserException("PIVOT IN list - inconsistent amount of rows - expected %d but got %d",
+					                      expected_size, entry.values.size());
+				}
 			}
 		}
 	}
 	result->include_nulls = root.include_nulls;
 	result->alias = TransformAlias(root.alias, result->column_name_alias);
+	SetQueryLocation(*result, root.location);
 	return std::move(result);
 }
 

package/src/duckdb/src/parser/transform/tableref/ub_duckdb_transformer_tableref.cpp

@@ -0,0 +1,8 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/parser/transform/tableref/transform_base_tableref.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/tableref/transform_join.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/tableref/transform_from.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/tableref/transform_pivot.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/tableref/transform_subquery.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/tableref/transform_table_function.cpp>
+#include </Users/carlo/duckdb/src/parser/transform/tableref/transform_tableref.cpp>

package/src/duckdb/src/parser/ub_duckdb_parser.cpp

@@ -0,0 +1,15 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/parser/base_expression.cpp>
+#include </Users/carlo/duckdb/src/parser/column_definition.cpp>
+#include </Users/carlo/duckdb/src/parser/column_list.cpp>
+#include </Users/carlo/duckdb/src/parser/constraint.cpp>
+#include </Users/carlo/duckdb/src/parser/expression_util.cpp>
+#include </Users/carlo/duckdb/src/parser/keyword_helper.cpp>
+#include </Users/carlo/duckdb/src/parser/parsed_expression.cpp>
+#include </Users/carlo/duckdb/src/parser/parsed_expression_iterator.cpp>
+#include </Users/carlo/duckdb/src/parser/parser.cpp>
+#include </Users/carlo/duckdb/src/parser/query_error_context.cpp>
+#include </Users/carlo/duckdb/src/parser/query_node.cpp>
+#include </Users/carlo/duckdb/src/parser/result_modifier.cpp>
+#include </Users/carlo/duckdb/src/parser/tableref.cpp>
+#include </Users/carlo/duckdb/src/parser/transformer.cpp>

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

@@ -65,11 +65,18 @@ void ExtractParameters(LambdaExpression &expr, vector<string> &column_names, vec
 BindResult ExpressionBinder::BindExpression(LambdaExpression &expr, idx_t depth, const LogicalType &list_child_type,
                                             optional_ptr<bind_lambda_function_t> bind_lambda_function) {
 
-	// this is for binding JSON
+	// This is not a lambda expression, but the JSON arrow operator.
 	if (!bind_lambda_function) {
-		auto lhs_expr = expr.lhs->Copy();
-		OperatorExpression arrow_expr(ExpressionType::ARROW, std::move(lhs_expr), expr.expr->Copy());
-		return BindExpression(arrow_expr, depth);
+		OperatorExpression arrow_expr(ExpressionType::ARROW, std::move(expr.lhs), std::move(expr.expr));
+		auto bind_result = BindExpression(arrow_expr, depth);
+
+		// The arrow_expr now contains bound nodes. We move these into the original expression.
+		if (bind_result.HasError()) {
+			D_ASSERT(arrow_expr.children.size() == 2);
+			expr.lhs = std::move(arrow_expr.children[0]);
+			expr.expr = std::move(arrow_expr.children[1]);
+		}
+		return bind_result;
 	}
 
 	// extract and verify lambda parameters to create dummy columns

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

@@ -88,7 +88,9 @@ BindResult ExpressionBinder::BindExpression(OperatorExpression &op, idx_t depth)
 	if (op.type == ExpressionType::GROUPING_FUNCTION) {
 		return BindGroupingFunction(op, depth);
 	}
-	// bind the children of the operator expression
+
+	// Bind the children of the operator expression. We already create bound expressions.
+	// Only those children that trigger an error are not yet bound.
 	ErrorData error;
 	for (idx_t i = 0; i < op.children.size(); i++) {
 		BindChild(op.children[i], depth, error);
@@ -96,6 +98,7 @@ BindResult ExpressionBinder::BindExpression(OperatorExpression &op, idx_t depth)
 	if (error.HasError()) {
 		return BindResult(std::move(error));
 	}
+
 	// all children bound successfully
 	string function_name;
 	switch (op.type) {

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

@@ -1,10 +1,12 @@
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/parser/expression/star_expression.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
+#include "duckdb/parser/expression/columnref_expression.hpp"
+#include "duckdb/parser/expression/operator_expression.hpp"
 #include "duckdb/planner/expression_binder/table_function_binder.hpp"
 #include "duckdb/parser/parsed_expression_iterator.hpp"
 #include "duckdb/execution/expression_executor.hpp"
-#include "re2/re2.h"
+#include "duckdb/function/scalar/regexp.hpp"
 
 namespace duckdb {
 
@@ -76,13 +78,54 @@ void Binder::ReplaceStarExpression(unique_ptr<ParsedExpression> &expr, unique_pt
 	D_ASSERT(expr);
 	if (expr->GetExpressionClass() == ExpressionClass::STAR) {
 		D_ASSERT(replacement);
+		auto alias = expr->alias;
 		expr = replacement->Copy();
+		if (!alias.empty()) {
+			expr->alias = std::move(alias);
+		}
 		return;
 	}
 	ParsedExpressionIterator::EnumerateChildren(
 	    *expr, [&](unique_ptr<ParsedExpression> &child_expr) { ReplaceStarExpression(child_expr, replacement); });
 }
 
+static string ReplaceColumnsAlias(const string &alias, const string &column_name, optional_ptr<duckdb_re2::RE2> regex) {
+	string result;
+	result.reserve(alias.size());
+	for (idx_t c = 0; c < alias.size(); c++) {
+		if (alias[c] == '\\') {
+			c++;
+			if (c >= alias.size()) {
+				throw BinderException("Unterminated backslash in COLUMNS(*) \"%s\" alias. Backslashes must either be "
+				                      "escaped or followed by a number",
+				                      alias);
+			}
+			if (alias[c] == '\\') {
+				result += "\\";
+				continue;
+			}
+			if (alias[c] < '0' || alias[c] > '9') {
+				throw BinderException("Invalid backslash code in COLUMNS(*) \"%s\" alias. Backslashes must either be "
+				                      "escaped or followed by a number",
+				                      alias);
+			}
+			if (alias[c] == '0') {
+				result += column_name;
+			} else if (!regex) {
+				throw BinderException(
+				    "Only the backslash escape code \\0 can be used when no regex is supplied to COLUMNS(*)");
+			} else {
+				string extracted;
+				RE2::Extract(column_name, *regex, "\\" + alias.substr(c, 1), &extracted);
+				result += extracted;
+			}
+		} else {
+			result += alias[c];
+		}
+	}
+	return result;
+}
+
 void Binder::ExpandStarExpression(unique_ptr<ParsedExpression> expr,
                                   vector<unique_ptr<ParsedExpression>> &new_select_list) {
 	StarExpression *star = nullptr;
@@ -97,6 +140,7 @@ void Binder::ExpandStarExpression(unique_ptr<ParsedExpression> expr,
 	// we have star expressions! expand the list of star expressions
 	bind_context.GenerateAllColumnExpressions(*star, star_list);
 
+	unique_ptr<duckdb_re2::RE2> regex;
 	if (star->expr) {
 		// COLUMNS with an expression
 		// two options:
@@ -120,15 +164,15 @@ void Binder::ExpandStarExpression(unique_ptr<ParsedExpression> expr,
 				throw BinderException("COLUMNS does not support NULL as regex argument");
 			}
 			auto &regex_str = StringValue::Get(val);
-			duckdb_re2::RE2 regex(regex_str);
-			if (!regex.error().empty()) {
-				auto err = StringUtil::Format("Failed to compile regex \"%s\": %s", regex_str, regex.error());
+			regex = make_uniq<duckdb_re2::RE2>(regex_str);
+			if (!regex->error().empty()) {
+				auto err = StringUtil::Format("Failed to compile regex \"%s\": %s", regex_str, regex->error());
 				throw BinderException(*star, err);
 			}
 			vector<unique_ptr<ParsedExpression>> new_list;
 			for (idx_t i = 0; i < star_list.size(); i++) {
 				auto &colref = star_list[i]->Cast<ColumnRefExpression>();
-				if (!RE2::PartialMatch(colref.GetColumnName(), regex)) {
+				if (!RE2::PartialMatch(colref.GetColumnName(), *regex)) {
 					continue;
 				}
 				new_list.push_back(std::move(star_list[i]));
@@ -180,6 +224,28 @@ void Binder::ExpandStarExpression(unique_ptr<ParsedExpression> expr,
 	for (idx_t i = 0; i < star_list.size(); i++) {
 		auto new_expr = expr->Copy();
 		ReplaceStarExpression(new_expr, star_list[i]);
+		if (star->columns) {
+			optional_ptr<ParsedExpression> expr = star_list[i].get();
+			while (expr) {
+				if (expr->type == ExpressionType::COLUMN_REF) {
+					break;
+				}
+				if (expr->type == ExpressionType::OPERATOR_COALESCE) {
+					expr = expr->Cast<OperatorExpression>().children[0].get();
+				} else {
+					// unknown expression
+					expr = nullptr;
+				}
+			}
+			if (expr) {
+				auto &colref = expr->Cast<ColumnRefExpression>();
+				if (new_expr->alias.empty()) {
+					new_expr->alias = colref.GetColumnName();
+				} else {
+					new_expr->alias = ReplaceColumnsAlias(new_expr->alias, colref.GetColumnName(), regex.get());
+				}
+			}
+		}
 		new_select_list.push_back(std::move(new_expr));
 	}
 }

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

@@ -88,6 +88,27 @@ static unique_ptr<Expression> CastWindowExpression(unique_ptr<ParsedExpression>
 	return std::move(bound);
 }
 
+static bool IsRangeType(const LogicalType &type) {
+	switch (type.InternalType()) {
+	case PhysicalType::INT8:
+	case PhysicalType::INT16:
+	case PhysicalType::INT32:
+	case PhysicalType::INT64:
+	case PhysicalType::UINT8:
+	case PhysicalType::UINT16:
+	case PhysicalType::UINT32:
+	case PhysicalType::UINT64:
+	case PhysicalType::INT128:
+	case PhysicalType::UINT128:
+	case PhysicalType::FLOAT:
+	case PhysicalType::DOUBLE:
+	case PhysicalType::INTERVAL:
+		return true;
+	default:
+		return false;
+	}
+}
+
 static LogicalType BindRangeExpression(ClientContext &context, const string &name, unique_ptr<ParsedExpression> &expr,
                                        unique_ptr<ParsedExpression> &order_expr) {
 
@@ -101,6 +122,10 @@ static LogicalType BindRangeExpression(ClientContext &context, const string &nam
 	D_ASSERT(expr.get());
 	D_ASSERT(expr->expression_class == ExpressionClass::BOUND_EXPRESSION);
 	auto &bound = BoundExpression::GetExpression(*expr);
+	QueryErrorContext error_context(bound->query_location);
+	if (bound->return_type == LogicalType::SQLNULL) {
+		throw BinderException(error_context, "Window RANGE expressions cannot be NULL");
+	}
 	children.emplace_back(std::move(bound));
 
 	ErrorData error;
@@ -109,6 +134,11 @@ static LogicalType BindRangeExpression(ClientContext &context, const string &nam
 	if (!function) {
 		error.Throw();
 	}
+	// +/- can be applied to non-scalar types,
+	// so we can't rely on function binding to catch all problems.
+	if (!IsRangeType(function->return_type)) {
+		throw BinderException(error_context, "Invalid type for Window RANGE expression");
+	}
 	bound = std::move(function);
 	return bound->return_type;
 }
@@ -145,7 +175,7 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 
 		//	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) {
+		if (!is_range || error.HasError()) {
 			continue;
 		}
 		auto &order_expr = order.expression;
@@ -171,6 +201,10 @@ 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);
+	}
 	for (auto &order : window.orders) {
 		auto &order_expr = order.expression;
 		auto &bound_order = BoundExpression::GetExpression(*order_expr);

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

@@ -0,0 +1,20 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/planner/binder/expression/bind_aggregate_expression.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/expression/bind_between_expression.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/expression/bind_case_expression.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/expression/bind_cast_expression.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/expression/bind_collate_expression.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/expression/bind_columnref_expression.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/expression/bind_comparison_expression.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/expression/bind_conjunction_expression.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/expression/bind_constant_expression.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/expression/bind_function_expression.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/expression/bind_lambda.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/expression/bind_macro_expression.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/expression/bind_operator_expression.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/expression/bind_parameter_expression.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/expression/bind_positional_reference_expression.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/expression/bind_star_expression.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/expression/bind_subquery_expression.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/expression/bind_unnest_expression.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/expression/bind_window_expression.cpp>