duckdb 1.0.1-dev21.0 → 1.0.1-dev27.0

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

@@ -7,19 +7,21 @@
 
 namespace duckdb {
 
-unique_ptr<SelectStatement> Transformer::TransformShowSelect(duckdb_libpgquery::PGVariableShowSelectStmt &stmt) {
+unique_ptr<QueryNode> Transformer::TransformShowSelect(duckdb_libpgquery::PGVariableShowSelectStmt &stmt) {
 	// we capture the select statement of SHOW
 	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;
-	auto select = TransformSelect(stmt.stmt);
-	show_ref->query = std::move(select->node);
+	show_ref->query = TransformSelectNode(*stmt.stmt);
 	select_node->from_table = std::move(show_ref);
+	return std::move(select_node);
+}
 
+unique_ptr<SelectStatement> Transformer::TransformShowSelectStmt(duckdb_libpgquery::PGVariableShowSelectStmt &stmt) {
 	auto result = make_uniq<SelectStatement>();
-	result->node = std::move(select_node);
+	result->node = TransformShowSelect(stmt);
 	return result;
 }
 

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

@@ -3,18 +3,39 @@
 
 namespace duckdb {
 
-unique_ptr<TransactionStatement> Transformer::TransformTransaction(duckdb_libpgquery::PGTransactionStmt &stmt) {
-	switch (stmt.kind) {
+TransactionType TransformTransactionType(duckdb_libpgquery::PGTransactionStmtKind kind) {
+	switch (kind) {
 	case duckdb_libpgquery::PG_TRANS_STMT_BEGIN:
 	case duckdb_libpgquery::PG_TRANS_STMT_START:
-		return make_uniq<TransactionStatement>(TransactionType::BEGIN_TRANSACTION);
+		return TransactionType::BEGIN_TRANSACTION;
 	case duckdb_libpgquery::PG_TRANS_STMT_COMMIT:
-		return make_uniq<TransactionStatement>(TransactionType::COMMIT);
+		return TransactionType::COMMIT;
 	case duckdb_libpgquery::PG_TRANS_STMT_ROLLBACK:
-		return make_uniq<TransactionStatement>(TransactionType::ROLLBACK);
+		return TransactionType::ROLLBACK;
+	default:
+		throw NotImplementedException("Transaction type %d not implemented yet", kind);
+	}
+}
+
+TransactionModifierType TransformTransactionModifier(duckdb_libpgquery::PGTransactionStmtType type) {
+	switch (type) {
+	case duckdb_libpgquery::PG_TRANS_TYPE_DEFAULT:
+		return TransactionModifierType::TRANSACTION_DEFAULT_MODIFIER;
+	case duckdb_libpgquery::PG_TRANS_TYPE_READ_ONLY:
+		return TransactionModifierType::TRANSACTION_READ_ONLY;
+	case duckdb_libpgquery::PG_TRANS_TYPE_READ_WRITE:
+		return TransactionModifierType::TRANSACTION_READ_WRITE;
 	default:
-		throw NotImplementedException("Transaction type %d not implemented yet", stmt.kind);
+		throw NotImplementedException("Transaction modifier %d not implemented yet", type);
 	}
 }
 
+unique_ptr<TransactionStatement> Transformer::TransformTransaction(duckdb_libpgquery::PGTransactionStmt &stmt) {
+	//	stmt.transaction_type
+	auto type = TransformTransactionType(stmt.kind);
+	auto info = make_uniq<TransactionInfo>(type);
+	info->modifier = TransformTransactionModifier(stmt.transaction_type);
+	return make_uniq<TransactionStatement>(std::move(info));
+}
+
 } // namespace duckdb

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

@@ -1,5 +1,5 @@
-#include "duckdb/parser/statement/update_statement.hpp"
 #include "duckdb/parser/statement/update_extensions_statement.hpp"
+#include "duckdb/parser/statement/update_statement.hpp"
 #include "duckdb/parser/transformer.hpp"
 
 namespace duckdb {
@@ -7,13 +7,14 @@ namespace duckdb {
 unique_ptr<UpdateSetInfo> Transformer::TransformUpdateSetInfo(duckdb_libpgquery::PGList *target_list,
                                                               duckdb_libpgquery::PGNode *where_clause) {
 	auto result = make_uniq<UpdateSetInfo>();
-
 	auto root = target_list;
+
 	for (auto cell = root->head; cell != nullptr; cell = cell->next) {
 		auto target = PGPointerCast<duckdb_libpgquery::PGResTarget>(cell->data.ptr_value);
 		result->columns.emplace_back(target->name);
 		result->expressions.push_back(TransformExpression(target->val));
 	}
+
 	result->condition = TransformExpression(where_clause);
 	return result;
 }
@@ -21,21 +22,20 @@ unique_ptr<UpdateSetInfo> Transformer::TransformUpdateSetInfo(duckdb_libpgquery:
 unique_ptr<UpdateStatement> Transformer::TransformUpdate(duckdb_libpgquery::PGUpdateStmt &stmt) {
 	auto result = make_uniq<UpdateStatement>();
 	if (stmt.withClause) {
-		TransformCTE(*PGPointerCast<duckdb_libpgquery::PGWithClause>(stmt.withClause), result->cte_map);
+		auto with_clause = PGPointerCast<duckdb_libpgquery::PGWithClause>(stmt.withClause);
+		TransformCTE(*with_clause, result->cte_map);
 	}
 
 	result->table = TransformRangeVar(*stmt.relation);
 	if (stmt.fromClause) {
 		result->from_table = TransformFrom(stmt.fromClause);
 	}
-
 	result->set_info = TransformUpdateSetInfo(stmt.targetList, stmt.whereClause);
 
 	// Grab and transform the returning columns from the parser.
 	if (stmt.returningList) {
 		TransformExpressionList(*stmt.returningList, result->returning_list);
 	}
-
 	return result;
 }
 
@@ -46,14 +46,13 @@ Transformer::TransformUpdateExtensions(duckdb_libpgquery::PGUpdateExtensionsStmt
 
 	if (stmt.extensions) {
 		auto column_list = PGPointerCast<duckdb_libpgquery::PGList>(stmt.extensions);
-		for (auto c = column_list->head; c != nullptr; c = lnext(c)) {
-			auto extension = reinterpret_cast<duckdb_libpgquery::PGValue *>(c->data.ptr_value)->val.str;
-			info->extensions_to_update.emplace_back(extension);
+		for (auto c = column_list->head; c != nullptr; c = c->next) {
+			auto value = PGPointerCast<duckdb_libpgquery::PGValue>(c->data.ptr_value);
+			info->extensions_to_update.emplace_back(value->val.str);
 		}
 	}
 
 	result->info = std::move(info);
-
 	return result;
 }
 

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

@@ -1,5 +1,4 @@
 #include "duckdb/parser/statement/insert_statement.hpp"
-#include "duckdb/parser/statement/update_statement.hpp"
 #include "duckdb/parser/tableref/expressionlistref.hpp"
 #include "duckdb/parser/transformer.hpp"
 
@@ -67,23 +66,23 @@ unique_ptr<OnConflictInfo> Transformer::DummyOnConflictClause(duckdb_libpgquery:
 }
 
 unique_ptr<OnConflictInfo> Transformer::TransformOnConflictClause(duckdb_libpgquery::PGOnConflictClause *node,
-                                                                  const string &relname) {
-	auto stmt = reinterpret_cast<duckdb_libpgquery::PGOnConflictClause *>(node);
+                                                                  const string &) {
+
+	auto stmt = PGPointerCast<duckdb_libpgquery::PGOnConflictClause>(node);
 	D_ASSERT(stmt);
 
 	auto result = make_uniq<OnConflictInfo>();
-	result->action_type = TransformOnConflictAction(stmt);
+	result->action_type = TransformOnConflictAction(stmt.get());
+
 	if (stmt->infer) {
-		// A filter for the ON CONFLICT ... is specified
-		if (stmt->infer->indexElems) {
-			// Columns are specified
-			result->indexed_columns = TransformConflictTarget(*stmt->infer->indexElems);
-			if (stmt->infer->whereClause) {
-				result->condition = TransformExpression(stmt->infer->whereClause);
-			}
-		} else {
+		// A filter for the ON CONFLICT ... is specified.
+		if (!stmt->infer->indexElems) {
 			throw NotImplementedException("ON CONSTRAINT conflict target is not supported yet");
 		}
+		result->indexed_columns = TransformConflictTarget(*stmt->infer->indexElems);
+		if (stmt->infer->whereClause) {
+			result->condition = TransformExpression(stmt->infer->whereClause);
+		}
 	}
 
 	if (result->action_type == OnConflictAction::UPDATE) {

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

@@ -3,7 +3,7 @@
 
 namespace duckdb {
 
-VacuumOptions ParseOptions(int options) {
+VacuumOptions ParseOptions(const int32_t options) {
 	VacuumOptions result;
 	if (options & duckdb_libpgquery::PGVacuumOption::PG_VACOPT_VACUUM) {
 		result.vacuum = true;
@@ -43,8 +43,8 @@ unique_ptr<SQLStatement> Transformer::TransformVacuum(duckdb_libpgquery::PGVacuu
 	if (stmt.va_cols) {
 		D_ASSERT(result->info->has_table);
 		for (auto col_node = stmt.va_cols->head; col_node != nullptr; col_node = col_node->next) {
-			result->info->columns.emplace_back(
-			    reinterpret_cast<duckdb_libpgquery::PGValue *>(col_node->data.ptr_value)->val.str);
+			auto value = PGPointerCast<duckdb_libpgquery::PGValue>(col_node->data.ptr_value);
+			result->info->columns.emplace_back(value->val.str);
 		}
 	}
 	return std::move(result);

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

@@ -39,14 +39,14 @@ unique_ptr<TableRef> Transformer::TransformJoin(duckdb_libpgquery::PGJoinExpr &r
 		result->ref_type = JoinRefType::POSITIONAL;
 		break;
 	}
-	default: {
+	default:
 		throw NotImplementedException("Join type %d not supported\n", root.jointype);
 	}
-	}
 
-	// Check the type of left arg and right arg before transform
+	// Check the type of the left and right argument before transforming.
 	result->left = TransformTableRefNode(*root.larg);
 	result->right = TransformTableRefNode(*root.rarg);
+
 	switch (root.joinreftype) {
 	case duckdb_libpgquery::PG_JOIN_NATURAL:
 		result->ref_type = JoinRefType::NATURAL;
@@ -57,32 +57,38 @@ unique_ptr<TableRef> Transformer::TransformJoin(duckdb_libpgquery::PGJoinExpr &r
 	default:
 		break;
 	}
+
 	SetQueryLocation(*result, root.location);
 	if (root.usingClause && root.usingClause->length > 0) {
-		// usingClause is a list of strings
+		// usingClause is a list of strings.
 		for (auto node = root.usingClause->head; node != nullptr; node = node->next) {
-			auto target = reinterpret_cast<duckdb_libpgquery::PGNode *>(node->data.ptr_value);
+			auto target = PGPointerCast<duckdb_libpgquery::PGNode>(node->data.ptr_value);
 			D_ASSERT(target->type == duckdb_libpgquery::T_PGString);
-			auto column_name = string(reinterpret_cast<duckdb_libpgquery::PGValue *>(target)->val.str);
-			result->using_columns.push_back(column_name);
+			auto value = PGCast<duckdb_libpgquery::PGValue>(*target.get());
+			result->using_columns.push_back(string(value.val.str));
 		}
 		return std::move(result);
 	}
 
-	if (!root.quals && result->using_columns.empty() && result->ref_type == JoinRefType::REGULAR) { // CROSS PRODUCT
+	// Check if this is a cross product.
+	if (!root.quals && result->using_columns.empty() && result->ref_type == JoinRefType::REGULAR) {
 		result->ref_type = JoinRefType::CROSS;
 	}
 	result->condition = TransformExpression(root.quals);
+
 	if (root.alias) {
-		// join with an alias - wrap it in a subquery
+		// This is a join with an alias, so we 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
+
+		// Apply the alias to the subquery.
 		subquery->alias = TransformAlias(root.alias, subquery->column_name_alias);
 		return std::move(subquery);
 	}

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

@@ -79,7 +79,7 @@ PivotColumn Transformer::TransformPivotColumn(duckdb_libpgquery::PGPivot &pivot,
 		}
 	}
 	if (pivot.subquery) {
-		col.subquery = TransformSelectNode(*PGPointerCast<duckdb_libpgquery::PGSelectStmt>(pivot.subquery));
+		col.subquery = TransformSelectNode(*pivot.subquery);
 	}
 	if (pivot.pivot_enum) {
 		col.pivot_enum = pivot.pivot_enum;

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

@@ -5,7 +5,7 @@ namespace duckdb {
 
 unique_ptr<TableRef> Transformer::TransformRangeSubselect(duckdb_libpgquery::PGRangeSubselect &root) {
 	Transformer subquery_transformer(*this);
-	auto subquery = subquery_transformer.TransformSelect(root.subquery);
+	auto subquery = subquery_transformer.TransformSelectStmt(*root.subquery);
 	if (!subquery) {
 		return nullptr;
 	}

package/src/duckdb/src/parser/transformer.cpp

@@ -21,7 +21,7 @@ Transformer::~Transformer() {
 }
 
 void Transformer::Clear() {
-	SetParamCount(0);
+	ClearParameters();
 	pivot_entries.clear();
 }
 
@@ -35,7 +35,6 @@ bool Transformer::TransformParseTree(duckdb_libpgquery::PGList *tree, vector<uni
 		if (HasPivotEntries()) {
 			stmt = CreatePivotStatement(std::move(stmt));
 		}
-		stmt->n_param = ParamCount();
 		statements.push_back(std::move(stmt));
 	}
 	return true;
@@ -58,10 +57,9 @@ StackChecker<Transformer> Transformer::StackCheck(idx_t extra_stack) {
 
 unique_ptr<SQLStatement> Transformer::TransformStatement(duckdb_libpgquery::PGNode &stmt) {
 	auto result = TransformStatementInternal(stmt);
-	result->n_param = ParamCount();
 	if (!named_param_map.empty()) {
 		// Avoid overriding a previous move with nothing
-		result->named_param_map = std::move(named_param_map);
+		result->named_param_map = named_param_map;
 	}
 	return result;
 }
@@ -92,6 +90,12 @@ void Transformer::SetParamCount(idx_t new_count) {
 	root.prepared_statement_parameter_index = new_count;
 }
 
+void Transformer::ClearParameters() {
+	auto &root = RootTransformer();
+	root.prepared_statement_parameter_index = 0;
+	root.named_param_map.clear();
+}
+
 static void ParamTypeCheck(PreparedParamType last_type, PreparedParamType new_type) {
 	// Mixing positional/auto-increment and named parameters is not supported
 	if (last_type == PreparedParamType::INVALID) {
@@ -140,7 +144,7 @@ unique_ptr<SQLStatement> Transformer::TransformStatementInternal(duckdb_libpgque
 		return result;
 	}
 	case duckdb_libpgquery::T_PGSelectStmt:
-		return TransformSelect(PGCast<duckdb_libpgquery::PGSelectStmt>(stmt));
+		return TransformSelectStmt(PGCast<duckdb_libpgquery::PGSelectStmt>(stmt));
 	case duckdb_libpgquery::T_PGCreateStmt:
 		return TransformCreateTable(PGCast<duckdb_libpgquery::PGCreateStmt>(stmt));
 	case duckdb_libpgquery::T_PGCreateSchemaStmt:
@@ -190,9 +194,9 @@ unique_ptr<SQLStatement> Transformer::TransformStatementInternal(duckdb_libpgque
 	case duckdb_libpgquery::T_PGVacuumStmt:
 		return TransformVacuum(PGCast<duckdb_libpgquery::PGVacuumStmt>(stmt));
 	case duckdb_libpgquery::T_PGVariableShowStmt:
-		return TransformShow(PGCast<duckdb_libpgquery::PGVariableShowStmt>(stmt));
+		return TransformShowStmt(PGCast<duckdb_libpgquery::PGVariableShowStmt>(stmt));
 	case duckdb_libpgquery::T_PGVariableShowSelectStmt:
-		return TransformShowSelect(PGCast<duckdb_libpgquery::PGVariableShowSelectStmt>(stmt));
+		return TransformShowSelectStmt(PGCast<duckdb_libpgquery::PGVariableShowSelectStmt>(stmt));
 	case duckdb_libpgquery::T_PGCallStmt:
 		return TransformCall(PGCast<duckdb_libpgquery::PGCallStmt>(stmt));
 	case duckdb_libpgquery::T_PGVariableSetStmt:

package/src/duckdb/src/planner/bind_context.cpp

@@ -45,11 +45,11 @@ string BindContext::GetMatchingBinding(const string &column_name) {
 }
 
 vector<string> BindContext::GetSimilarBindings(const string &column_name) {
-	vector<pair<string, idx_t>> scores;
+	vector<pair<string, double>> scores;
 	for (auto &kv : bindings) {
 		auto binding = kv.second.get();
 		for (auto &name : binding->names) {
-			idx_t distance = StringUtil::SimilarityScore(name, column_name);
+			double distance = StringUtil::SimilarityRating(name, column_name);
 			scores.emplace_back(binding->alias + "." + name, distance);
 		}
 	}
@@ -246,7 +246,7 @@ optional_ptr<Binding> BindContext::GetBinding(const string &name, ErrorData &out
 			candidates.push_back(kv.first);
 		}
 		string candidate_str =
-		    StringUtil::CandidatesMessage(StringUtil::TopNLevenshtein(candidates, name), "Candidate tables");
+		    StringUtil::CandidatesMessage(StringUtil::TopNJaroWinkler(candidates, name), "Candidate tables");
 		out_error = ErrorData(ExceptionType::BINDER,
 		                      StringUtil::Format("Referenced table \"%s\" not found!%s", name, candidate_str));
 		return nullptr;

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

@@ -1,21 +1,22 @@
 #include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
-#include "duckdb/common/pair.hpp"
 #include "duckdb/common/operator/cast_operators.hpp"
+#include "duckdb/common/pair.hpp"
+#include "duckdb/execution/expression_executor.hpp"
+#include "duckdb/function/function_binder.hpp"
+#include "duckdb/function/scalar/generic_functions.hpp"
+#include "duckdb/main/config.hpp"
+#include "duckdb/parser/expression/constant_expression.hpp"
 #include "duckdb/parser/expression/function_expression.hpp"
+#include "duckdb/planner/binder.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"
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/planner/expression_binder/aggregate_binder.hpp"
 #include "duckdb/planner/expression_binder/base_select_binder.hpp"
+#include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/planner/query_node/bound_select_node.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/function/scalar/generic_functions.hpp"
-#include "duckdb/main/config.hpp"
-#include "duckdb/function/function_binder.hpp"
-#include "duckdb/planner/binder.hpp"
 
 namespace duckdb {
 
@@ -140,6 +141,19 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFu
 	// Bind the ORDER BYs, if any
 	if (aggr.order_bys && !aggr.order_bys->orders.empty()) {
 		for (auto &order : aggr.order_bys->orders) {
+			if (order.expression->type == ExpressionType::VALUE_CONSTANT) {
+				auto &const_expr = order.expression->Cast<ConstantExpression>();
+				if (!const_expr.value.type().IsIntegral()) {
+					auto &config = ClientConfig::GetConfig(context);
+					if (!config.order_by_non_integer_literal) {
+						throw BinderException(
+						    *order.expression,
+						    "ORDER BY non-integer literal has no effect.\n* SET order_by_non_integer_literal=true to "
+						    "allow this behavior.\n\nPerhaps you misplaced ORDER BY; ORDER BY must appear "
+						    "after all regular arguments of the aggregate.");
+					}
+				}
+			}
 			aggregate_binder.BindChild(order.expression, 0, error);
 		}
 	}
@@ -241,6 +255,7 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFu
 		auto &config = DBConfig::GetConfig(context);
 		for (auto &order : aggr.order_bys->orders) {
 			auto &order_expr = BoundExpression::GetExpression(*order.expression);
+			PushCollation(context, order_expr, order_expr->return_type);
 			const auto sense = config.ResolveOrder(order.type);
 			const auto null_order = config.ResolveNullOrder(sense, order.null_order);
 			order_bys->orders.emplace_back(sense, null_order, std::move(order_expr));

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

@@ -46,9 +46,9 @@ BindResult ExpressionBinder::BindExpression(BetweenExpression &expr, idx_t depth
 	lower = BoundCastExpression::AddCastToType(context, std::move(lower), input_type);
 	upper = BoundCastExpression::AddCastToType(context, std::move(upper), input_type);
 	// handle collation
-	PushCollation(context, input, input_type, false);
-	PushCollation(context, lower, input_type, false);
-	PushCollation(context, upper, input_type, false);
+	PushCollation(context, input, input_type);
+	PushCollation(context, lower, input_type);
+	PushCollation(context, upper, input_type);
 
 	if (!input->IsVolatile() && !input->HasParameter() && !input->HasSubquery()) {
 		// the expression does not have side effects and can be copied: create two comparisons

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

@@ -1,4 +1,5 @@
 #include "duckdb/parser/expression/collate_expression.hpp"
+#include "duckdb/planner/expression/bound_constant_expression.hpp"
 #include "duckdb/planner/expression/bound_parameter_expression.hpp"
 #include "duckdb/planner/expression_binder.hpp"
 
@@ -18,9 +19,9 @@ BindResult ExpressionBinder::BindExpression(CollateExpression &expr, idx_t depth
 		throw BinderException("collations are only supported for type varchar");
 	}
 	// Validate the collation, but don't use it
-	auto child_copy = child->Copy();
+	auto collation_test = make_uniq_base<Expression, BoundConstantExpression>(Value(child->return_type));
 	auto collation_type = LogicalType::VARCHAR_COLLATION(expr.collation);
-	PushCollation(context, child_copy, collation_type, false);
+	PushCollation(context, collation_test, collation_type);
 	child->return_type = collation_type;
 	return BindResult(std::move(child));
 }

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

@@ -155,10 +155,9 @@ void ExpressionBinder::QualifyColumnNames(unique_ptr<ParsedExpression> &expr,
 		break;
 	}
 	case ExpressionType::FUNCTION: {
-		// special-handling for lambdas, which are inside function expressions,
+		// Special-handling for lambdas, which are inside function expressions.
 		auto &function = expr->Cast<FunctionExpression>();
-		if (IsLambdaFunction(function)) {
-			// special case
+		if (function.IsLambdaFunction()) {
 			return QualifyColumnNamesInLambda(function, lambda_params);
 		}
 
@@ -413,7 +412,7 @@ BindResult ExpressionBinder::BindExpression(LambdaRefExpression &lambda_ref, idx
 	return (*lambda_bindings)[lambda_ref.lambda_idx].Bind(lambda_ref, depth);
 }
 
-BindResult ExpressionBinder::BindExpression(ColumnRefExpression &col_ref_p, idx_t depth) {
+BindResult ExpressionBinder::BindExpression(ColumnRefExpression &col_ref_p, idx_t depth, bool root_expression) {
 	if (binder.GetBindingMode() == BindingMode::EXTRACT_NAMES) {
 		return BindResult(make_uniq<BoundConstantExpression>(Value(LogicalType::SQLNULL)));
 	}
@@ -422,6 +421,14 @@ BindResult ExpressionBinder::BindExpression(ColumnRefExpression &col_ref_p, idx_
 	auto expr = QualifyColumnName(col_ref_p, error);
 	if (!expr) {
 		if (!col_ref_p.IsQualified()) {
+			// column was not found
+			// first try to bind it as an alias
+			BindResult alias_result;
+			auto found_alias = TryBindAlias(col_ref_p, root_expression, alias_result);
+			if (found_alias) {
+				return alias_result;
+			}
+
 			// column was not found - check if it is a SQL value function
 			auto value_function = GetSQLValueFunction(col_ref_p.GetColumnName());
 			if (value_function) {

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

@@ -11,61 +11,14 @@
 #include "duckdb/function/scalar/string_functions.hpp"
 
 #include "duckdb/common/types/decimal.hpp"
-
-#include "duckdb/main/config.hpp"
-#include "duckdb/catalog/catalog.hpp"
-#include "duckdb/function/function_binder.hpp"
+#include "duckdb/planner/collation_binding.hpp"
 
 namespace duckdb {
 
 bool ExpressionBinder::PushCollation(ClientContext &context, unique_ptr<Expression> &source,
-                                     const LogicalType &sql_type, bool equality_only) {
-	if (sql_type.id() != LogicalTypeId::VARCHAR) {
-		// only VARCHAR columns require collation
-		return false;
-	}
-	// replace default collation with system collation
-	auto str_collation = StringType::GetCollation(sql_type);
-	string collation;
-	if (str_collation.empty()) {
-		collation = DBConfig::GetConfig(context).options.collation;
-	} else {
-		collation = str_collation;
-	}
-	collation = StringUtil::Lower(collation);
-	// bind the collation
-	if (collation.empty() || collation == "binary" || collation == "c" || collation == "posix") {
-		// no collation or binary collation: skip
-		return false;
-	}
-	auto &catalog = Catalog::GetSystemCatalog(context);
-	auto splits = StringUtil::Split(StringUtil::Lower(collation), ".");
-	vector<reference<CollateCatalogEntry>> entries;
-	for (auto &collation_argument : splits) {
-		auto &collation_entry = catalog.GetEntry<CollateCatalogEntry>(context, DEFAULT_SCHEMA, collation_argument);
-		if (collation_entry.combinable) {
-			entries.insert(entries.begin(), collation_entry);
-		} else {
-			if (!entries.empty() && !entries.back().get().combinable) {
-				throw BinderException("Cannot combine collation types \"%s\" and \"%s\"", entries.back().get().name,
-				                      collation_entry.name);
-			}
-			entries.push_back(collation_entry);
-		}
-	}
-	for (auto &entry : entries) {
-		auto &collation_entry = entry.get();
-		if (equality_only && collation_entry.not_required_for_equality) {
-			continue;
-		}
-		vector<unique_ptr<Expression>> children;
-		children.push_back(std::move(source));
-
-		FunctionBinder function_binder(context);
-		auto function = function_binder.BindScalarFunction(collation_entry.function, std::move(children));
-		source = std::move(function);
-	}
-	return true;
+                                     const LogicalType &sql_type) {
+	auto &collation_binding = CollationBinding::Get(context);
+	return collation_binding.PushCollation(context, source, sql_type);
 }
 
 void ExpressionBinder::TestCollation(ClientContext &context, const string &collation) {
@@ -192,7 +145,9 @@ LogicalType ExpressionBinder::GetExpressionReturnType(const Expression &expr) {
 		}
 		if (expr.return_type.IsIntegral()) {
 			auto &constant = expr.Cast<BoundConstantExpression>();
-			return LogicalType::INTEGER_LITERAL(constant.value);
+			if (!constant.value.IsNull()) {
+				return LogicalType::INTEGER_LITERAL(constant.value);
+			}
 		}
 	}
 	return expr.return_type;
@@ -226,8 +181,8 @@ BindResult ExpressionBinder::BindExpression(ComparisonExpression &expr, idx_t de
 	right = BoundCastExpression::AddCastToType(context, std::move(right), input_type,
 	                                           input_type.id() == LogicalTypeId::ENUM);
 
-	PushCollation(context, left, input_type, expr.type == ExpressionType::COMPARE_EQUAL);
-	PushCollation(context, right, input_type, expr.type == ExpressionType::COMPARE_EQUAL);
+	PushCollation(context, left, input_type);
+	PushCollation(context, right, input_type);
 
 	// now create the bound comparison expression
 	return BindResult(make_uniq<BoundComparisonExpression>(expr.type, std::move(left), std::move(right)));

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

@@ -87,9 +87,7 @@ BindResult ExpressionBinder::BindExpression(FunctionExpression &function, idx_t
 
 	switch (func->type) {
 	case CatalogType::SCALAR_FUNCTION_ENTRY: {
-		// scalar function
-		if (IsLambdaFunction(function)) {
-			// special case
+		if (function.IsLambdaFunction()) {
 			return TryBindLambdaOrJson(function, depth, *func);
 		}
 		return BindFunction(function, func->Cast<ScalarFunctionCatalogEntry>(), depth);
@@ -265,11 +263,11 @@ BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function, Sc
 
 BindResult ExpressionBinder::BindAggregate(FunctionExpression &expr, AggregateFunctionCatalogEntry &function,
                                            idx_t depth) {
-	return BindResult(BinderException(expr, UnsupportedAggregateMessage()));
+	return BindUnsupportedExpression(expr, depth, UnsupportedAggregateMessage());
 }
 
 BindResult ExpressionBinder::BindUnnest(FunctionExpression &expr, idx_t depth, bool root_expression) {
-	return BindResult(BinderException(expr, UnsupportedUnnestMessage()));
+	return BindUnsupportedExpression(expr, depth, UnsupportedUnnestMessage());
 }
 
 string ExpressionBinder::UnsupportedAggregateMessage() {