duckdb 1.1.2-dev6.0 → 1.1.4-dev11.0

package/src/duckdb/src/parser/query_error_context.cpp

@@ -9,6 +9,7 @@ namespace duckdb {
 
 string QueryErrorContext::Format(const string &query, const string &error_message, optional_idx error_loc,
                                  bool add_line_indicator) {
+	static constexpr idx_t MAX_LINE_RENDER_WIDTH = 120;
 	if (!error_loc.IsValid()) {
 		// no location in query provided
 		return error_message;
@@ -58,6 +59,7 @@ string QueryErrorContext::Format(const string &query, const string &error_messag
 	idx_t len = end_pos - start_pos;
 	vector<idx_t> render_widths;
 	vector<idx_t> positions;
+	vector<idx_t> natural_break;
 	if (Utf8Proc::IsValid(buf, len)) {
 		// for unicode awareness, we traverse the graphemes of the current line and keep track of their render widths
 		// and of their position in the string
@@ -65,6 +67,8 @@ string QueryErrorContext::Format(const string &query, const string &error_messag
 			auto char_render_width = Utf8Proc::RenderWidth(buf, len, cpos);
 			positions.push_back(cpos);
 			render_widths.push_back(char_render_width);
+			natural_break.push_back(StringUtil::CharacterIsOperator(buf[cpos]) ||
+			                        StringUtil::CharacterIsSpace(buf[cpos]));
 			cpos = Utf8Proc::NextGraphemeCluster(buf, len, cpos);
 		}
 	} else { // LCOV_EXCL_START
@@ -73,6 +77,8 @@ string QueryErrorContext::Format(const string &query, const string &error_messag
 		for (idx_t cpos = 0; cpos < len; cpos++) {
 			positions.push_back(cpos);
 			render_widths.push_back(1);
+			natural_break.push_back(StringUtil::CharacterIsOperator(buf[cpos]) ||
+			                        StringUtil::CharacterIsSpace(buf[cpos]));
 		}
 	} // LCOV_EXCL_STOP
 	// now we want to find the (unicode aware) start and end position
@@ -88,13 +94,25 @@ string QueryErrorContext::Format(const string &query, const string &error_messag
 	bool truncate_end = false;
 	idx_t spos = 0;
 	// now we iterate backwards from the error location
-	// we show max 40 render width before the error location
+	// we show max 60 render width before the error location
+	idx_t error_line_start = start_pos;
 	idx_t current_render_width = 0;
 	for (idx_t i = epos; i > 0; i--) {
 		current_render_width += render_widths[i];
-		if (current_render_width >= 40) {
+		if (current_render_width >= MAX_LINE_RENDER_WIDTH / 2) {
+			// we're exceeding the render width - truncate the beginning
+			// try to break at a "nice" point (i.e. a space, bracket, etc)
+			// try to find a natural break that is within 4 bytes of here
+			idx_t start_scan = i > 4 ? i - 4 : 0;
+			idx_t end_scan = MinValue<idx_t>(i + 4, epos);
+			for (idx_t k = start_scan; k < end_scan; k++) {
+				if (natural_break[k]) {
+					i = k;
+					break;
+				}
+			}
 			truncate_beginning = true;
-			start_pos = positions[i];
+			start_pos += positions[i];
 			spos = i;
 			break;
 		}
@@ -103,9 +121,20 @@ string QueryErrorContext::Format(const string &query, const string &error_messag
 	current_render_width = 0;
 	for (idx_t i = epos; i < positions.size(); i++) {
 		current_render_width += render_widths[i];
-		if (current_render_width >= 40) {
+		if (current_render_width >= MAX_LINE_RENDER_WIDTH / 2) {
+			// we're exceeding the render width - truncate the end
+			// try to break at a "nice" point (i.e. a space, bracket, etc)
+			// try to find a natural break that is within 4 bytes of here
+			idx_t start_scan = i > epos + 4 ? i - 4 : epos;
+			idx_t end_scan = MinValue<idx_t>(i + 4, positions.size());
+			for (idx_t k = start_scan; k < end_scan; k++) {
+				if (natural_break[k]) {
+					i = k;
+					break;
+				}
+			}
 			truncate_end = true;
-			end_pos = positions[i];
+			end_pos = error_line_start + positions[i];
 			break;
 		}
 	}
@@ -125,7 +154,7 @@ string QueryErrorContext::Format(const string &query, const string &error_messag
 
 	// now first print the error message plus the current line (or a subset of the line)
 	string result = error_message;
-	result += "\n" + line_indicator + begin_trunc + query.substr(start_pos, end_pos - start_pos) + end_trunc;
+	result += "\n\n" + line_indicator + begin_trunc + query.substr(start_pos, end_pos - start_pos) + end_trunc;
 	// print an arrow pointing at the error location
 	result += "\n" + string(error_render_width, ' ') + "^";
 	return result;

package/src/duckdb/src/parser/query_node/select_node.cpp

@@ -41,8 +41,8 @@ string SelectNode::ToString() const {
 			result += ", ";
 		}
 		result += select_list[i]->ToString();
-		if (!select_list[i]->alias.empty()) {
-			result += StringUtil::Format(" AS %s", SQLIdentifier(select_list[i]->alias));
+		if (!select_list[i]->GetAlias().empty()) {
+			result += StringUtil::Format(" AS %s", SQLIdentifier(select_list[i]->GetAlias()));
 		}
 	}
 	if (from_table && from_table->type != TableReferenceType::EMPTY_FROM) {
@@ -101,8 +101,8 @@ string SelectNode::ToString() const {
 			result += "%";
 		}
 		result += " (" + EnumUtil::ToString(sample->method);
-		if (sample->seed >= 0) {
-			result += ", " + std::to_string(sample->seed);
+		if (sample->seed.IsValid()) {
+			result += ", " + std::to_string(sample->seed.GetIndex());
 		}
 		result += ")";
 	}

package/src/duckdb/src/parser/statement/delete_statement.cpp

@@ -43,7 +43,12 @@ string DeleteStatement::ToString() const {
 			if (i > 0) {
 				result += ", ";
 			}
-			result += returning_list[i]->ToString();
+			auto column = returning_list[i]->ToString();
+			if (!returning_list[i]->GetAlias().empty()) {
+				column +=
+				    StringUtil::Format(" AS %s", KeywordHelper::WriteOptionallyQuoted(returning_list[i]->GetAlias()));
+			}
+			result += column;
 		}
 	}
 	return result;

package/src/duckdb/src/parser/statement/insert_statement.cpp

@@ -157,8 +157,9 @@ string InsertStatement::ToString() const {
 				result += ", ";
 			}
 			auto column = returning_list[i]->ToString();
-			if (!returning_list[i]->alias.empty()) {
-				column += StringUtil::Format(" AS %s", KeywordHelper::WriteOptionallyQuoted(returning_list[i]->alias));
+			if (!returning_list[i]->GetAlias().empty()) {
+				column +=
+				    StringUtil::Format(" AS %s", KeywordHelper::WriteOptionallyQuoted(returning_list[i]->GetAlias()));
 			}
 			result += column;
 		}
@@ -190,7 +191,7 @@ optional_ptr<ExpressionListRef> InsertStatement::GetValuesList() const {
 	if (node.aggregate_handling != AggregateHandling::STANDARD_HANDLING) {
 		return nullptr;
 	}
-	if (node.select_list.size() != 1 || node.select_list[0]->type != ExpressionType::STAR) {
+	if (node.select_list.size() != 1 || node.select_list[0]->GetExpressionType() != ExpressionType::STAR) {
 		return nullptr;
 	}
 	if (!node.from_table || node.from_table->type != TableReferenceType::EXPRESSION_LIST) {

package/src/duckdb/src/parser/statement/update_statement.cpp

@@ -65,7 +65,12 @@ string UpdateStatement::ToString() const {
 			if (i > 0) {
 				result += ", ";
 			}
-			result += returning_list[i]->ToString();
+			auto column = returning_list[i]->ToString();
+			if (!returning_list[i]->GetAlias().empty()) {
+				column +=
+				    StringUtil::Format(" AS %s", KeywordHelper::WriteOptionallyQuoted(returning_list[i]->GetAlias()));
+			}
+			result += column;
 		}
 	}
 	return result;

package/src/duckdb/src/parser/tableref/pivotref.cpp

@@ -143,8 +143,8 @@ string PivotRef::ToString() const {
 				result += ", ";
 			}
 			result += aggregates[aggr_idx]->ToString();
-			if (!aggregates[aggr_idx]->alias.empty()) {
-				result += " AS " + KeywordHelper::WriteOptionallyQuoted(aggregates[aggr_idx]->alias);
+			if (!aggregates[aggr_idx]->GetAlias().empty()) {
+				result += " AS " + KeywordHelper::WriteOptionallyQuoted(aggregates[aggr_idx]->GetAlias());
 			}
 		}
 	} else {

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

@@ -31,8 +31,8 @@ string TableRef::BaseToString(string result, const vector<string> &column_name_a
 	if (sample) {
 		result += " TABLESAMPLE " + EnumUtil::ToString(sample->method);
 		result += "(" + sample->sample_size.ToString() + " " + string(sample->is_percentage ? "PERCENT" : "ROWS") + ")";
-		if (sample->seed >= 0) {
-			result += "REPEATABLE (" + to_string(sample->seed) + ")";
+		if (sample->seed.IsValid()) {
+			result += "REPEATABLE (" + to_string(sample->seed.GetIndex()) + ")";
 		}
 	}
 

package/src/duckdb/src/parser/transform/constraint/transform_constraint.cpp

@@ -68,50 +68,42 @@ TransformForeignKeyConstraint(duckdb_libpgquery::PGConstraint &constraint,
 	return make_uniq<ForeignKeyConstraint>(pk_columns, fk_columns, std::move(fk_info));
 }
 
-unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGListCell &cell) {
-
-	auto constraint = PGPointerCast<duckdb_libpgquery::PGConstraint>(cell.data.ptr_value);
-	D_ASSERT(constraint);
-
-	switch (constraint->contype) {
+unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGConstraint &constraint) {
+	switch (constraint.contype) {
 	case duckdb_libpgquery::PG_CONSTR_UNIQUE:
 	case duckdb_libpgquery::PG_CONSTR_PRIMARY: {
-		bool is_primary_key = constraint->contype == duckdb_libpgquery::PG_CONSTR_PRIMARY;
-		if (!constraint->keys) {
+		bool is_primary_key = constraint.contype == duckdb_libpgquery::PG_CONSTR_PRIMARY;
+		if (!constraint.keys) {
 			throw ParserException("UNIQUE USING INDEX is not supported");
 		}
 		vector<string> columns;
-		for (auto kc = constraint->keys->head; kc; kc = kc->next) {
+		for (auto kc = constraint.keys->head; kc; kc = kc->next) {
 			auto value = PGPointerCast<duckdb_libpgquery::PGValue>(kc->data.ptr_value);
 			columns.emplace_back(value->val.str);
 		}
 		return make_uniq<UniqueConstraint>(columns, is_primary_key);
 	}
 	case duckdb_libpgquery::PG_CONSTR_CHECK: {
-		auto expression = TransformExpression(constraint->raw_expr);
+		auto expression = TransformExpression(constraint.raw_expr);
 		if (expression->HasSubquery()) {
 			throw ParserException("subqueries prohibited in CHECK constraints");
 		}
-		return make_uniq<CheckConstraint>(TransformExpression(constraint->raw_expr));
+		return make_uniq<CheckConstraint>(TransformExpression(constraint.raw_expr));
 	}
 	case duckdb_libpgquery::PG_CONSTR_FOREIGN:
-		return TransformForeignKeyConstraint(*constraint.get());
+		return TransformForeignKeyConstraint(constraint);
 	default:
 		throw NotImplementedException("Constraint type not handled yet!");
 	}
 }
 
-unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGListCell &cell, ColumnDefinition &column,
-                                                        idx_t index) {
-
-	auto constraint = PGPointerCast<duckdb_libpgquery::PGConstraint>(cell.data.ptr_value);
-	D_ASSERT(constraint);
-
-	switch (constraint->contype) {
+unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGConstraint &constraint,
+                                                        ColumnDefinition &column, idx_t index) {
+	switch (constraint.contype) {
 	case duckdb_libpgquery::PG_CONSTR_NOTNULL:
 		return make_uniq<NotNullConstraint>(LogicalIndex(index));
 	case duckdb_libpgquery::PG_CONSTR_CHECK:
-		return TransformConstraint(cell);
+		return TransformConstraint(constraint);
 	case duckdb_libpgquery::PG_CONSTR_PRIMARY:
 		return make_uniq<UniqueConstraint>(LogicalIndex(index), true);
 	case duckdb_libpgquery::PG_CONSTR_UNIQUE:
@@ -123,23 +115,23 @@ unique_ptr<Constraint> Transformer::TransformConstraint(duckdb_libpgquery::PGLis
 			throw InvalidInputException("\"%s\" has a DEFAULT value set, it can not become a GENERATED column",
 			                            column.Name());
 		}
-		column.SetGeneratedExpression(TransformExpression(constraint->raw_expr));
+		column.SetGeneratedExpression(TransformExpression(constraint.raw_expr));
 		return nullptr;
 	}
 	case duckdb_libpgquery::PG_CONSTR_GENERATED_STORED:
 		throw InvalidInputException("Can not create a STORED generated column!");
 	case duckdb_libpgquery::PG_CONSTR_DEFAULT:
-		column.SetDefaultValue(TransformExpression(constraint->raw_expr));
+		column.SetDefaultValue(TransformExpression(constraint.raw_expr));
 		return nullptr;
 	case duckdb_libpgquery::PG_CONSTR_COMPRESSION:
-		column.SetCompressionType(CompressionTypeFromString(constraint->compression_name));
+		column.SetCompressionType(CompressionTypeFromString(constraint.compression_name));
 		if (column.CompressionType() == CompressionType::COMPRESSION_AUTO) {
 			throw ParserException("Unrecognized option for column compression, expected none, uncompressed, rle, "
 			                      "dictionary, pfor, bitpacking or fsst");
 		}
 		return nullptr;
 	case duckdb_libpgquery::PG_CONSTR_FOREIGN:
-		return TransformForeignKeyConstraint(*constraint.get(), &column.Name());
+		return TransformForeignKeyConstraint(constraint, &column.Name());
 	default:
 		throw NotImplementedException("Constraint not implemented!");
 	}

package/src/duckdb/src/parser/transform/expression/transform_array_access.cpp

@@ -60,7 +60,7 @@ unique_ptr<ParsedExpression> Transformer::TransformArrayAccess(duckdb_libpgquery
 		case duckdb_libpgquery::T_PGFuncCall: {
 			auto func = PGCast<duckdb_libpgquery::PGFuncCall>(*target.get());
 			auto function = TransformFuncCall(func);
-			if (function->type != ExpressionType::FUNCTION) {
+			if (function->GetExpressionType() != ExpressionType::FUNCTION) {
 				throw ParserException("%s.%s() call must be a function", result->ToString(), function->ToString());
 			}
 			auto &function_expr = function->Cast<FunctionExpression>();

package/src/duckdb/src/parser/transform/expression/transform_bool_expr.cpp

@@ -29,15 +29,15 @@ unique_ptr<ParsedExpression> Transformer::TransformBoolExpr(duckdb_libpgquery::P
 			break;
 		}
 		case duckdb_libpgquery::PG_NOT_EXPR: {
-			if (next->type == ExpressionType::COMPARE_IN) {
+			if (next->GetExpressionType() == ExpressionType::COMPARE_IN) {
 				// convert COMPARE_IN to COMPARE_NOT_IN
-				next->type = ExpressionType::COMPARE_NOT_IN;
+				next->SetExpressionTypeUnsafe(ExpressionType::COMPARE_NOT_IN);
 				result = std::move(next);
-			} else if (next->type >= ExpressionType::COMPARE_EQUAL &&
-			           next->type <= ExpressionType::COMPARE_GREATERTHANOREQUALTO) {
+			} else if (next->GetExpressionType() >= ExpressionType::COMPARE_EQUAL &&
+			           next->GetExpressionType() <= ExpressionType::COMPARE_GREATERTHANOREQUALTO) {
 				// NOT on a comparison: we can negate the comparison
 				// e.g. NOT(x > y) is equivalent to x <= y
-				next->type = NegateComparisonExpression(next->type);
+				next->SetExpressionTypeUnsafe(NegateComparisonExpression(next->GetExpressionType()));
 				result = std::move(next);
 			} else {
 				result = make_uniq<OperatorExpression>(ExpressionType::OPERATOR_NOT, std::move(next));

package/src/duckdb/src/parser/transform/expression/transform_columnref.cpp

@@ -6,17 +6,44 @@
 
 namespace duckdb {
 
+QualifiedColumnName TransformQualifiedColumnName(duckdb_libpgquery::PGList &list) {
+	QualifiedColumnName result;
+	switch (list.length) {
+	case 1:
+		result.column = const_char_ptr_cast(list.head->data.ptr_value);
+		break;
+	case 2:
+		result.table = const_char_ptr_cast(list.head->data.ptr_value);
+		result.column = const_char_ptr_cast(list.head->next->data.ptr_value);
+		break;
+	case 3:
+		result.schema = const_char_ptr_cast(list.head->data.ptr_value);
+		result.table = const_char_ptr_cast(list.head->next->data.ptr_value);
+		result.column = const_char_ptr_cast(list.head->next->next->data.ptr_value);
+		break;
+	case 4:
+		result.catalog = const_char_ptr_cast(list.head->data.ptr_value);
+		result.schema = const_char_ptr_cast(list.head->next->data.ptr_value);
+		result.table = const_char_ptr_cast(list.head->next->next->data.ptr_value);
+		result.column = const_char_ptr_cast(list.head->next->next->next->data.ptr_value);
+		break;
+	default:
+		throw ParserException("Qualified column name must have between 1 and 4 elements");
+	}
+	return result;
+}
+
 unique_ptr<ParsedExpression> Transformer::TransformStarExpression(duckdb_libpgquery::PGAStar &star) {
 	auto result = make_uniq<StarExpression>(star.relation ? star.relation : string());
 	if (star.except_list) {
 		for (auto head = star.except_list->head; head; head = head->next) {
-			auto value = PGPointerCast<duckdb_libpgquery::PGValue>(head->data.ptr_value);
-			D_ASSERT(value->type == duckdb_libpgquery::T_PGString);
-			string exclude_entry = value->val.str;
-			if (result->exclude_list.find(exclude_entry) != result->exclude_list.end()) {
-				throw ParserException("Duplicate entry \"%s\" in EXCLUDE list", exclude_entry);
+			auto exclude_column_list = PGPointerCast<duckdb_libpgquery::PGList>(head->data.ptr_value);
+			auto exclude_column = TransformQualifiedColumnName(*exclude_column_list);
+			// qualified - add to exclude list
+			if (result->exclude_list.find(exclude_column) != result->exclude_list.end()) {
+				throw ParserException("Duplicate entry \"%s\" in EXCLUDE list", exclude_column.ToString());
 			}
-			result->exclude_list.insert(std::move(exclude_entry));
+			result->exclude_list.insert(std::move(exclude_column));
 		}
 	}
 	if (star.replace_list) {
@@ -27,14 +54,35 @@ unique_ptr<ParsedExpression> Transformer::TransformStarExpression(duckdb_libpgqu
 			    TransformExpression(PGPointerCast<duckdb_libpgquery::PGNode>(list->head->data.ptr_value));
 			auto value = PGPointerCast<duckdb_libpgquery::PGValue>(list->tail->data.ptr_value);
 			D_ASSERT(value->type == duckdb_libpgquery::T_PGString);
-			string exclude_entry = value->val.str;
-			if (result->replace_list.find(exclude_entry) != result->replace_list.end()) {
-				throw ParserException("Duplicate entry \"%s\" in REPLACE list", exclude_entry);
+			string replace_entry = value->val.str;
+			if (result->replace_list.find(replace_entry) != result->replace_list.end()) {
+				throw ParserException("Duplicate entry \"%s\" in REPLACE list", replace_entry);
+			}
+			if (result->exclude_list.find(QualifiedColumnName(replace_entry)) != result->exclude_list.end()) {
+				throw ParserException("Column \"%s\" cannot occur in both EXCLUDE and REPLACE list", replace_entry);
+			}
+			result->replace_list.insert(make_pair(std::move(replace_entry), std::move(replace_expression)));
+		}
+	}
+	if (star.rename_list) {
+		for (auto head = star.rename_list->head; head; head = head->next) {
+			auto list = PGPointerCast<duckdb_libpgquery::PGList>(head->data.ptr_value);
+			D_ASSERT(list->length == 2);
+			auto rename_column_list = PGPointerCast<duckdb_libpgquery::PGList>(list->head->data.ptr_value);
+			auto rename_column = TransformQualifiedColumnName(*rename_column_list);
+			string new_name = char_ptr_cast(list->tail->data.ptr_value);
+			if (result->rename_list.find(rename_column) != result->rename_list.end()) {
+				throw ParserException("Duplicate entry \"%s\" in EXCLUDE list", rename_column.ToString());
+			}
+			if (result->exclude_list.find(rename_column) != result->exclude_list.end()) {
+				throw ParserException("Column \"%s\" cannot occur in both EXCLUDE and RENAME list",
+				                      rename_column.ToString());
 			}
-			if (result->exclude_list.find(exclude_entry) != result->exclude_list.end()) {
-				throw ParserException("Column \"%s\" cannot occur in both EXCEPT and REPLACE list", exclude_entry);
+			if (result->replace_list.find(rename_column.column) != result->replace_list.end()) {
+				throw ParserException("Column \"%s\" cannot occur in both REPLACE and RENAME list",
+				                      rename_column.ToString());
 			}
-			result->replace_list.insert(make_pair(std::move(exclude_entry), std::move(replace_expression)));
+			result->rename_list.insert(make_pair(std::move(rename_column), std::move(new_name)));
 		}
 	}
 	if (star.expr) {
@@ -49,7 +97,7 @@ unique_ptr<ParsedExpression> Transformer::TransformStarExpression(duckdb_libpgqu
 			result->exclude_list = std::move(child_star.exclude_list);
 			result->replace_list = std::move(child_star.replace_list);
 			result->expr.reset();
-		} else if (result->expr->type == ExpressionType::LAMBDA) {
+		} else if (result->expr->GetExpressionType() == ExpressionType::LAMBDA) {
 			vector<unique_ptr<ParsedExpression>> children;
 			children.push_back(make_uniq<StarExpression>());
 			children.push_back(std::move(result->expr));

package/src/duckdb/src/parser/transform/expression/transform_constant.cpp

@@ -55,6 +55,12 @@ unique_ptr<ConstantExpression> Transformer::TransformValue(duckdb_libpgquery::PG
 				// successfully cast to bigint: bigint value
 				return make_uniq<ConstantExpression>(Value::HUGEINT(hugeint_value));
 			}
+			uhugeint_t uhugeint_value;
+			// if that is not successful; try to cast as uhugeint
+			if (TryCast::Operation<string_t, uhugeint_t>(str_val, uhugeint_value)) {
+				// successfully cast to bigint: bigint value
+				return make_uniq<ConstantExpression>(Value::UHUGEINT(uhugeint_value));
+			}
 		}
 		idx_t decimal_offset = val.val.str[0] == '-' ? 3 : 2;
 		if (try_cast_as_decimal && decimal_position.IsValid() &&
@@ -91,7 +97,7 @@ unique_ptr<ParsedExpression> Transformer::TransformConstant(duckdb_libpgquery::P
 
 bool Transformer::ConstructConstantFromExpression(const ParsedExpression &expr, Value &value) {
 	// We have to construct it like this because we don't have the ClientContext for binding/executing the expr here
-	switch (expr.type) {
+	switch (expr.GetExpressionType()) {
 	case ExpressionType::FUNCTION: {
 		auto &function = expr.Cast<FunctionExpression>();
 		if (function.function_name == "struct_pack") {
@@ -99,14 +105,14 @@ bool Transformer::ConstructConstantFromExpression(const ParsedExpression &expr,
 			child_list_t<Value> values;
 			values.reserve(function.children.size());
 			for (const auto &child : function.children) {
-				if (!unique_names.insert(child->alias).second) {
-					throw BinderException("Duplicate struct entry name \"%s\"", child->alias);
+				if (!unique_names.insert(child->GetAlias()).second) {
+					throw BinderException("Duplicate struct entry name \"%s\"", child->GetAlias());
 				}
 				Value child_value;
 				if (!ConstructConstantFromExpression(*child, child_value)) {
 					return false;
 				}
-				values.emplace_back(child->alias, std::move(child_value));
+				values.emplace_back(child->GetAlias(), std::move(child_value));
 			}
 			value = Value::STRUCT(std::move(values));
 			return true;

package/src/duckdb/src/parser/transform/expression/transform_expression.cpp

@@ -10,7 +10,7 @@ unique_ptr<ParsedExpression> Transformer::TransformResTarget(duckdb_libpgquery::
 		return nullptr;
 	}
 	if (root.name) {
-		expr->alias = string(root.name);
+		expr->SetAlias(root.name);
 	}
 	return expr;
 }
@@ -19,7 +19,7 @@ unique_ptr<ParsedExpression> Transformer::TransformNamedArg(duckdb_libpgquery::P
 
 	auto expr = TransformExpression(PGPointerCast<duckdb_libpgquery::PGNode>(root.arg));
 	if (root.name) {
-		expr->alias = string(root.name);
+		expr->SetAlias(root.name);
 	}
 	return expr;
 }

package/src/duckdb/src/parser/transform/expression/transform_function.cpp

@@ -90,7 +90,7 @@ void Transformer::TransformWindowFrame(duckdb_libpgquery::PGWindowDef &window_sp
 }
 
 bool Transformer::ExpressionIsEmptyStar(ParsedExpression &expr) {
-	if (expr.expression_class != ExpressionClass::STAR) {
+	if (expr.GetExpressionClass() != ExpressionClass::STAR) {
 		return false;
 	}
 	auto &star = expr.Cast<StarExpression>();
@@ -110,6 +110,27 @@ bool Transformer::InWindowDefinition() {
 	return false;
 }
 
+static bool IsOrderableWindowFunction(ExpressionType type) {
+	switch (type) {
+	case ExpressionType::WINDOW_FIRST_VALUE:
+	case ExpressionType::WINDOW_LAST_VALUE:
+	case ExpressionType::WINDOW_NTH_VALUE:
+	case ExpressionType::WINDOW_RANK:
+	case ExpressionType::WINDOW_PERCENT_RANK:
+	case ExpressionType::WINDOW_ROW_NUMBER:
+	case ExpressionType::WINDOW_NTILE:
+	case ExpressionType::WINDOW_CUME_DIST:
+	case ExpressionType::WINDOW_LEAD:
+	case ExpressionType::WINDOW_LAG:
+	case ExpressionType::WINDOW_AGGREGATE:
+		return true;
+	case ExpressionType::WINDOW_RANK_DENSE:
+		return false;
+	default:
+		throw InternalException("Unknown orderable window type %s", ExpressionTypeToString(type).c_str());
+	}
+}
+
 unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::PGFuncCall &root) {
 	auto name = root.funcname;
 	string catalog, schema, function_name;
@@ -157,8 +178,8 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 			throw ParserException("DISTINCT is not implemented for non-aggregate window functions!");
 		}
 
-		if (root.agg_order) {
-			throw ParserException("ORDER BY is not implemented for window functions!");
+		if (root.agg_order && !IsOrderableWindowFunction(win_fun_type)) {
+			throw ParserException("ORDER BY is not supported for the window function \"%s\"", lowercase_name.c_str());
 		}
 
 		if (win_fun_type != ExpressionType::WINDOW_AGGREGATE && root.agg_filter) {
@@ -182,6 +203,12 @@ unique_ptr<ParsedExpression> Transformer::TransformFuncCall(duckdb_libpgquery::P
 			expr->filter_expr = std::move(filter_expr);
 		}
 
+		if (root.agg_order) {
+			auto order_bys = make_uniq<OrderModifier>();
+			TransformOrderBy(root.agg_order, order_bys->orders);
+			expr->arg_orders = std::move(order_bys->orders);
+		}
+
 		if (win_fun_type == ExpressionType::WINDOW_AGGREGATE) {
 			expr->children = std::move(children);
 		} else {

package/src/duckdb/src/parser/transform/expression/transform_operator.cpp

@@ -168,7 +168,7 @@ unique_ptr<ParsedExpression> Transformer::TransformAExprInternal(duckdb_libpgque
 		auto &similar_func = right_expr->Cast<FunctionExpression>();
 		D_ASSERT(similar_func.function_name == "similar_escape");
 		D_ASSERT(similar_func.children.size() == 2);
-		if (similar_func.children[1]->type != ExpressionType::VALUE_CONSTANT) {
+		if (similar_func.children[1]->GetExpressionType() != ExpressionType::VALUE_CONSTANT) {
 			throw NotImplementedException("Custom escape in SIMILAR TO");
 		}
 		auto &constant = similar_func.children[1]->Cast<ConstantExpression>();

package/src/duckdb/src/parser/transform/expression/transform_subquery.cpp

@@ -74,16 +74,30 @@ unique_ptr<ParsedExpression> Transformer::TransformSubquery(duckdb_libpgquery::P
 	case duckdb_libpgquery::PG_ARRAY_SUBLINK: {
 		// ARRAY expression
 		// wrap subquery into
-		// "SELECT CASE WHEN ARRAY_AGG(COLUMNS(*)) IS NULL THEN [] ELSE ARRAY_AGG(COLUMNS(*)) END FROM (...) tbl"
+		// "SELECT CASE WHEN ARRAY_AGG(col) IS NULL THEN [] ELSE ARRAY_AGG(col) END FROM (...) tbl"
 		auto select_node = make_uniq<SelectNode>();
 
-		// COLUMNS(*)
-		auto columns_star = make_uniq<StarExpression>();
-		columns_star->columns = true;
+		unique_ptr<ParsedExpression> array_agg_child;
+		optional_ptr<SelectNode> sub_select;
+		if (subquery_expr->subquery->node->type == QueryNodeType::SELECT_NODE) {
+			// easy case - subquery is a SELECT
+			sub_select = subquery_expr->subquery->node->Cast<SelectNode>();
+			if (sub_select->select_list.size() != 1) {
+				throw BinderException(*subquery_expr, "Subquery returns %zu columns - expected 1",
+				                      sub_select->select_list.size());
+			}
+			array_agg_child = make_uniq<PositionalReferenceExpression>(1ULL);
+		} else {
+			// subquery is not a SELECT but a UNION or CTE
+			// we can still support this but it is more challenging since we can't push columns for the ORDER BY
+			auto columns_star = make_uniq<StarExpression>();
+			columns_star->columns = true;
+			array_agg_child = std::move(columns_star);
+		}
 
 		// ARRAY_AGG(COLUMNS(*))
 		vector<unique_ptr<ParsedExpression>> children;
-		children.push_back(std::move(columns_star));
+		children.push_back(std::move(array_agg_child));
 		auto aggr = make_uniq<FunctionExpression>("array_agg", std::move(children));
 		// push ORDER BY modifiers into the array_agg
 		for (auto &modifier : subquery_expr->subquery->node->modifiers) {
@@ -95,7 +109,7 @@ unique_ptr<ParsedExpression> Transformer::TransformSubquery(duckdb_libpgquery::P
 		// transform constants (e.g. ORDER BY 1) into positional references (ORDER BY #1)
 		if (aggr->order_bys) {
 			for (auto &order : aggr->order_bys->orders) {
-				if (order.expression->type == ExpressionType::VALUE_CONSTANT) {
+				if (order.expression->GetExpressionType() == ExpressionType::VALUE_CONSTANT) {
 					auto &constant_expr = order.expression->Cast<ConstantExpression>();
 					Value bigint_value;
 					string error;
@@ -104,7 +118,12 @@ unique_ptr<ParsedExpression> Transformer::TransformSubquery(duckdb_libpgquery::P
 						idx_t positional_index = order_index < 0 ? NumericLimits<idx_t>::Maximum() : idx_t(order_index);
 						order.expression = make_uniq<PositionalReferenceExpression>(positional_index);
 					}
+				} else if (sub_select) {
+					// if we have a SELECT we can push the ORDER BY clause into the SELECT list and reference it
+					sub_select->select_list.push_back(std::move(order.expression));
+					order.expression = make_uniq<PositionalReferenceExpression>(sub_select->select_list.size() - 1);
 				} else {
+					// otherwise we remove order qualifications
 					RemoveOrderQualificationRecursive(order.expression);
 				}
 			}

package/src/duckdb/src/parser/transform/helpers/transform_groupby.cpp

@@ -40,7 +40,7 @@ static void MergeGroupingSet(GroupingSet &result, GroupingSet &other) {
 
 void Transformer::AddGroupByExpression(unique_ptr<ParsedExpression> expression, GroupingExpressionMap &map,
                                        GroupByNode &result, vector<idx_t> &result_set) {
-	if (expression->type == ExpressionType::FUNCTION) {
+	if (expression->GetExpressionType() == ExpressionType::FUNCTION) {
 		auto &func = expression->Cast<FunctionExpression>();
 		if (func.function_name == "row") {
 			for (auto &child : func.children) {

package/src/duckdb/src/parser/transform/helpers/transform_sample.cpp

@@ -25,7 +25,13 @@ unique_ptr<SampleOptions> Transformer::TransformSampleOptions(optional_ptr<duckd
 	auto result = make_uniq<SampleOptions>();
 	auto &sample_options = PGCast<duckdb_libpgquery::PGSampleOptions>(*options);
 	auto &sample_size = *PGPointerCast<duckdb_libpgquery::PGSampleSize>(sample_options.sample_size);
-	auto sample_value = TransformValue(sample_size.sample_size)->value;
+	auto sample_expression = TransformExpression(sample_size.sample_size);
+	if (sample_expression->GetExpressionType() != ExpressionType::VALUE_CONSTANT) {
+		throw ParserException(sample_expression->GetQueryLocation(),
+		                      "Only constants are supported in sample clause currently");
+	}
+	auto &const_expr = sample_expression->Cast<ConstantExpression>();
+	auto &sample_value = const_expr.value;
 	result->is_percentage = sample_size.is_percentage;
 	if (sample_size.is_percentage) {
 		// sample size is given in sample_size: use system sampling
@@ -47,8 +53,9 @@ unique_ptr<SampleOptions> Transformer::TransformSampleOptions(optional_ptr<duckd
 	if (sample_options.method) {
 		result->method = GetSampleMethod(sample_options.method);
 	}
-	if (sample_options.has_seed) {
-		result->seed = sample_options.seed;
+	if (sample_options.has_seed && sample_options.seed >= 0) {
+		result->seed = static_cast<idx_t>(sample_options.seed);
+		result->repeatable = true;
 	}
 	return result;
 }