duckdb 0.7.2-dev225.0 → 0.7.2-dev2320.0

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

@@ -7,7 +7,7 @@
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
 #include "duckdb/planner/expression_binder/aggregate_binder.hpp"
-#include "duckdb/planner/expression_binder/select_binder.hpp"
+#include "duckdb/planner/expression_binder/base_select_binder.hpp"
 #include "duckdb/planner/query_node/bound_select_node.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/function/scalar/generic_functions.hpp"
@@ -75,13 +75,13 @@ static void NegatePercentileFractions(ClientContext &context, unique_ptr<ParsedE
 		if (values.empty()) {
 			throw BinderException("Empty list in percentile not allowed");
 		}
-		bound.expr = make_unique<BoundConstantExpression>(Value::LIST(values));
+		bound.expr = make_uniq<BoundConstantExpression>(Value::LIST(values));
 	} else {
-		bound.expr = make_unique<BoundConstantExpression>(NegatePercentileValue(value, desc));
+		bound.expr = make_uniq<BoundConstantExpression>(NegatePercentileValue(value, desc));
 	}
 }
 
-BindResult SelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFunctionCatalogEntry *func, idx_t depth) {
+BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFunctionCatalogEntry *func, idx_t depth) {
 	// first bind the child of the aggregate expression (if any)
 	this->bound_aggregate = true;
 	unique_ptr<Expression> bound_filter;
@@ -208,8 +208,9 @@ BindResult SelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFuncti
 	auto bound_function = func->functions.GetFunctionByOffset(best_function);
 
 	// Bind any sort columns, unless the aggregate is order-insensitive
-	auto order_bys = make_unique<BoundOrderModifier>();
+	unique_ptr<BoundOrderModifier> order_bys;
 	if (!aggr.order_bys->orders.empty()) {
+		order_bys = make_uniq<BoundOrderModifier>();
 		auto &config = DBConfig::GetConfig(context);
 		for (auto &order : aggr.order_bys->orders) {
 			auto &order_expr = (BoundExpression &)*order.expression;
@@ -218,24 +219,25 @@ BindResult SelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFuncti
 			const auto null_order = (order.null_order == OrderByNullType::ORDER_DEFAULT)
 			                            ? config.options.default_null_order
 			                            : order.null_order;
-			order_bys->orders.emplace_back(BoundOrderByNode(sense, null_order, std::move(order_expr.expr)));
+			order_bys->orders.emplace_back(sense, null_order, std::move(order_expr.expr));
 		}
 	}
 
-	auto aggregate = function_binder.BindAggregateFunction(
-	    bound_function, std::move(children), std::move(bound_filter),
-	    aggr.distinct ? AggregateType::DISTINCT : AggregateType::NON_DISTINCT, std::move(order_bys));
+	auto aggregate =
+	    function_binder.BindAggregateFunction(bound_function, std::move(children), std::move(bound_filter),
+	                                          aggr.distinct ? AggregateType::DISTINCT : AggregateType::NON_DISTINCT);
 	if (aggr.export_state) {
 		aggregate = ExportAggregateFunction::Bind(std::move(aggregate));
 	}
+	aggregate->order_bys = std::move(order_bys);
 
 	// check for all the aggregates if this aggregate already exists
 	idx_t aggr_index;
-	auto entry = node.aggregate_map.find(aggregate.get());
+	auto entry = node.aggregate_map.find(*aggregate);
 	if (entry == node.aggregate_map.end()) {
 		// new aggregate: insert into aggregate list
 		aggr_index = node.aggregates.size();
-		node.aggregate_map.insert(make_pair(aggregate.get(), aggr_index));
+		node.aggregate_map[*aggregate] = aggr_index;
 		node.aggregates.push_back(std::move(aggregate));
 	} else {
 		// duplicate aggregate: simplify refer to this aggregate
@@ -243,7 +245,7 @@ BindResult SelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFuncti
 	}
 
 	// now create a column reference referring to the aggregate
-	auto colref = make_unique<BoundColumnRefExpression>(
+	auto colref = make_uniq<BoundColumnRefExpression>(
 	    aggr.alias.empty() ? node.aggregates[aggr_index]->ToString() : aggr.alias,
 	    node.aggregates[aggr_index]->return_type, ColumnBinding(node.aggregate_index, aggr_index), depth);
 	// move the aggregate expression into the set of bound aggregates

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

@@ -45,17 +45,17 @@ BindResult ExpressionBinder::BindExpression(BetweenExpression &expr, idx_t depth
 		// the expression does not have side effects and can be copied: create two comparisons
 		// the reason we do this is that individual comparisons are easier to handle in optimizers
 		// if both comparisons remain they will be folded together again into a single BETWEEN in the optimizer
-		auto left_compare = make_unique<BoundComparisonExpression>(ExpressionType::COMPARE_GREATERTHANOREQUALTO,
-		                                                           input.expr->Copy(), std::move(lower.expr));
-		auto right_compare = make_unique<BoundComparisonExpression>(ExpressionType::COMPARE_LESSTHANOREQUALTO,
-		                                                            std::move(input.expr), std::move(upper.expr));
-		return BindResult(make_unique<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND,
-		                                                          std::move(left_compare), std::move(right_compare)));
+		auto left_compare = make_uniq<BoundComparisonExpression>(ExpressionType::COMPARE_GREATERTHANOREQUALTO,
+		                                                         input.expr->Copy(), std::move(lower.expr));
+		auto right_compare = make_uniq<BoundComparisonExpression>(ExpressionType::COMPARE_LESSTHANOREQUALTO,
+		                                                          std::move(input.expr), std::move(upper.expr));
+		return BindResult(make_uniq<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND,
+		                                                        std::move(left_compare), std::move(right_compare)));
 	} else {
 		// expression has side effects: we cannot duplicate it
 		// create a bound_between directly
-		return BindResult(make_unique<BoundBetweenExpression>(std::move(input.expr), std::move(lower.expr),
-		                                                      std::move(upper.expr), true, true));
+		return BindResult(make_uniq<BoundBetweenExpression>(std::move(input.expr), std::move(lower.expr),
+		                                                    std::move(upper.expr), true, true));
 	}
 }
 

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

@@ -25,7 +25,7 @@ BindResult ExpressionBinder::BindExpression(CaseExpression &expr, idx_t depth) {
 	}
 
 	// bind all the individual components of the CASE statement
-	auto result = make_unique<BoundCaseExpression>(return_type);
+	auto result = make_uniq<BoundCaseExpression>(return_type);
 	for (idx_t i = 0; i < expr.case_checks.size(); i++) {
 		auto &check = expr.case_checks[i];
 		auto &when_expr = (BoundExpression &)*check.when_expr;

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

@@ -17,6 +17,44 @@
 
 namespace duckdb {
 
+string GetSQLValueFunctionName(const string &column_name) {
+	auto lcase = StringUtil::Lower(column_name);
+	if (lcase == "current_catalog") {
+		return "current_catalog";
+	} else if (lcase == "current_date") {
+		return "current_date";
+	} else if (lcase == "current_schema") {
+		return "current_schema";
+	} else if (lcase == "current_role") {
+		return "current_role";
+	} else if (lcase == "current_time") {
+		return "get_current_time";
+	} else if (lcase == "current_timestamp") {
+		return "get_current_timestamp";
+	} else if (lcase == "current_user") {
+		return "current_user";
+	} else if (lcase == "localtime") {
+		return "current_localtime";
+	} else if (lcase == "localtimestamp") {
+		return "current_localtimestamp";
+	} else if (lcase == "session_user") {
+		return "session_user";
+	} else if (lcase == "user") {
+		return "user";
+	}
+	return string();
+}
+
+unique_ptr<ParsedExpression> ExpressionBinder::GetSQLValueFunction(const string &column_name) {
+	auto value_function = GetSQLValueFunctionName(column_name);
+	if (value_function.empty()) {
+		return nullptr;
+	}
+
+	vector<unique_ptr<ParsedExpression>> children;
+	return make_uniq<FunctionExpression>(value_function, std::move(children));
+}
+
 unique_ptr<ParsedExpression> ExpressionBinder::QualifyColumnName(const string &column_name, string &error_message) {
 	auto using_binding = binder.bind_context.GetUsingBinding(column_name);
 	if (using_binding) {
@@ -28,10 +66,10 @@ unique_ptr<ParsedExpression> ExpressionBinder::QualifyColumnName(const string &c
 			return binder.bind_context.CreateColumnReference(using_binding->primary_binding, column_name);
 		} else {
 			// // we cannot! we need to bind this as a coalesce between all the relevant columns
-			auto coalesce = make_unique<OperatorExpression>(ExpressionType::OPERATOR_COALESCE);
+			auto coalesce = make_uniq<OperatorExpression>(ExpressionType::OPERATOR_COALESCE);
 			coalesce->children.reserve(using_binding->bindings.size());
 			for (auto &entry : using_binding->bindings) {
-				coalesce->children.push_back(make_unique<ColumnRefExpression>(column_name, entry));
+				coalesce->children.push_back(make_uniq<ColumnRefExpression>(column_name, entry));
 			}
 			return std::move(coalesce);
 		}
@@ -59,17 +97,22 @@ unique_ptr<ParsedExpression> ExpressionBinder::QualifyColumnName(const string &c
 				}
 
 				D_ASSERT(!(*lambda_bindings)[i].alias.empty());
-				return make_unique<ColumnRefExpression>(column_name, (*lambda_bindings)[i].alias);
+				return make_uniq<ColumnRefExpression>(column_name, (*lambda_bindings)[i].alias);
 			}
 		}
 	}
 
 	if (is_macro_column) {
 		D_ASSERT(!binder.macro_binding->alias.empty());
-		return make_unique<ColumnRefExpression>(column_name, binder.macro_binding->alias);
+		return make_uniq<ColumnRefExpression>(column_name, binder.macro_binding->alias);
 	}
 	// see if it's a column
 	if (table_name.empty()) {
+		// column was not found - check if it is a SQL value function
+		auto value_function = GetSQLValueFunction(column_name);
+		if (value_function) {
+			return value_function;
+		}
 		// it's not, find candidates and error
 		auto similar_bindings = binder.bind_context.GetSimilarBindings(column_name);
 		string candidate_str = StringUtil::CandidatesMessage(similar_bindings, "Candidate bindings");
@@ -83,7 +126,7 @@ unique_ptr<ParsedExpression> ExpressionBinder::QualifyColumnName(const string &c
 void ExpressionBinder::QualifyColumnNames(unique_ptr<ParsedExpression> &expr) {
 	switch (expr->type) {
 	case ExpressionType::COLUMN_REF: {
-		auto &colref = (ColumnRefExpression &)*expr;
+		auto &colref = expr->Cast<ColumnRefExpression>();
 		string error_message;
 		auto new_expr = QualifyColumnName(colref, error_message);
 		if (new_expr) {
@@ -96,7 +139,7 @@ void ExpressionBinder::QualifyColumnNames(unique_ptr<ParsedExpression> &expr) {
 		break;
 	}
 	case ExpressionType::POSITIONAL_REFERENCE: {
-		auto &ref = (PositionalReferenceExpression &)*expr;
+		auto &ref = expr->Cast<PositionalReferenceExpression>();
 		if (ref.alias.empty()) {
 			string table_name, column_name;
 			auto error = binder.bind_context.BindColumn(ref, table_name, column_name);
@@ -124,7 +167,7 @@ unique_ptr<ParsedExpression> ExpressionBinder::CreateStructExtract(unique_ptr<Pa
 	// we need to transform the struct extract if it is inside a lambda expression
 	// because we cannot bind to an existing table, so we remove the dummy table also
 	if (lambda_bindings && base->type == ExpressionType::COLUMN_REF) {
-		auto &lambda_column_ref = (ColumnRefExpression &)*base;
+		auto &lambda_column_ref = base->Cast<ColumnRefExpression>();
 		D_ASSERT(!lambda_column_ref.column_names.empty());
 
 		if (lambda_column_ref.column_names[0].find(DummyBinding::DUMMY_NAME) != string::npos) {
@@ -137,8 +180,8 @@ unique_ptr<ParsedExpression> ExpressionBinder::CreateStructExtract(unique_ptr<Pa
 
 	vector<unique_ptr<ParsedExpression>> children;
 	children.push_back(std::move(base));
-	children.push_back(make_unique_base<ParsedExpression, ConstantExpression>(Value(std::move(field_name))));
-	auto extract_fun = make_unique<OperatorExpression>(ExpressionType::STRUCT_EXTRACT, std::move(children));
+	children.push_back(make_uniq_base<ParsedExpression, ConstantExpression>(Value(std::move(field_name))));
+	auto extract_fun = make_uniq<OperatorExpression>(ExpressionType::STRUCT_EXTRACT, std::move(children));
 	return std::move(extract_fun);
 }
 
@@ -175,11 +218,12 @@ unique_ptr<ParsedExpression> ExpressionBinder::CreateStructPack(ColumnRefExpress
 		}
 	}
 	// We found the table, now create the struct_pack expression
-	vector<unique_ptr<ParsedExpression>> child_exprs;
+	vector<unique_ptr<ParsedExpression>> child_expressions;
+	child_expressions.reserve(binding->names.size());
 	for (const auto &column_name : binding->names) {
-		child_exprs.push_back(make_unique<ColumnRefExpression>(column_name, table_name));
+		child_expressions.push_back(make_uniq<ColumnRefExpression>(column_name, table_name));
 	}
-	return make_unique<FunctionExpression>("struct_pack", std::move(child_exprs));
+	return make_uniq<FunctionExpression>("struct_pack", std::move(child_expressions));
 }
 
 unique_ptr<ParsedExpression> ExpressionBinder::QualifyColumnName(ColumnRefExpression &colref, string &error_message) {
@@ -209,7 +253,7 @@ unique_ptr<ParsedExpression> ExpressionBinder::QualifyColumnName(ColumnRefExpres
 			return binder.bind_context.CreateColumnReference(colref.column_names[0], colref.column_names[1]);
 		} else {
 			// otherwise check if we can turn this into a struct extract
-			auto new_colref = make_unique<ColumnRefExpression>(colref.column_names[0]);
+			auto new_colref = make_uniq<ColumnRefExpression>(colref.column_names[0]);
 			string other_error;
 			auto qualified_colref = QualifyColumnName(colref.column_names[0], other_error);
 			if (qualified_colref) {
@@ -284,7 +328,7 @@ unique_ptr<ParsedExpression> ExpressionBinder::QualifyColumnName(ColumnRefExpres
 
 BindResult ExpressionBinder::BindExpression(ColumnRefExpression &colref_p, idx_t depth) {
 	if (binder.GetBindingMode() == BindingMode::EXTRACT_NAMES) {
-		return BindResult(make_unique<BoundConstantExpression>(Value(LogicalType::SQLNULL)));
+		return BindResult(make_uniq<BoundConstantExpression>(Value(LogicalType::SQLNULL)));
 	}
 	string error_message;
 	auto expr = QualifyColumnName(colref_p, error_message);
@@ -303,7 +347,7 @@ BindResult ExpressionBinder::BindExpression(ColumnRefExpression &colref_p, idx_t
 		return result;
 	}
 
-	auto &colref = (ColumnRefExpression &)*expr;
+	auto &colref = expr->Cast<ColumnRefExpression>();
 	D_ASSERT(colref.IsQualified());
 	auto &table_name = colref.GetTableName();
 

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

@@ -63,7 +63,7 @@ unique_ptr<Expression> ExpressionBinder::PushCollation(ClientContext &context, u
 }
 
 void ExpressionBinder::TestCollation(ClientContext &context, const string &collation) {
-	PushCollation(context, make_unique<BoundConstantExpression>(Value("")), collation);
+	PushCollation(context, make_uniq<BoundConstantExpression>(Value("")), collation);
 }
 
 LogicalType BoundComparisonExpression::BindComparison(LogicalType left_type, LogicalType right_type) {
@@ -140,7 +140,7 @@ BindResult ExpressionBinder::BindExpression(ComparisonExpression &expr, idx_t de
 		    PushCollation(context, std::move(right.expr), collation, expr.type == ExpressionType::COMPARE_EQUAL);
 	}
 	// now create the bound comparison expression
-	return BindResult(make_unique<BoundComparisonExpression>(expr.type, std::move(left.expr), std::move(right.expr)));
+	return BindResult(make_uniq<BoundComparisonExpression>(expr.type, std::move(left.expr), std::move(right.expr)));
 }
 
 } // namespace duckdb

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

@@ -17,7 +17,7 @@ BindResult ExpressionBinder::BindExpression(ConjunctionExpression &expr, idx_t d
 	// the children have been successfully resolved
 	// cast the input types to boolean (if necessary)
 	// and construct the bound conjunction expression
-	auto result = make_unique<BoundConjunctionExpression>(expr.type);
+	auto result = make_uniq<BoundConjunctionExpression>(expr.type);
 	for (auto &child_expr : expr.children) {
 		auto &child = (BoundExpression &)*child_expr;
 		result->children.push_back(

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

@@ -5,7 +5,7 @@
 namespace duckdb {
 
 BindResult ExpressionBinder::BindExpression(ConstantExpression &expr, idx_t depth) {
-	return BindResult(make_unique<BoundConstantExpression>(expr.value));
+	return BindResult(make_uniq<BoundConstantExpression>(expr.value));
 }
 
 } // namespace duckdb

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

@@ -18,13 +18,6 @@ BindResult ExpressionBinder::BindExpression(FunctionExpression &function, idx_t
                                             unique_ptr<ParsedExpression> *expr_ptr) {
 	// lookup the function in the catalog
 	QueryErrorContext error_context(binder.root_statement, function.query_location);
-
-	if (function.function_name == "unnest" || function.function_name == "unlist") {
-		// special case, not in catalog
-		// TODO make sure someone does not create such a function OR
-		// have unnest live in catalog, too
-		return BindUnnest(function, depth);
-	}
 	auto func = Catalog::GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, function.catalog, function.schema,
 	                              function.function_name, true, error_context);
 	if (!func) {
@@ -38,10 +31,28 @@ BindResult ExpressionBinder::BindExpression(FunctionExpression &function, idx_t
 			                       "function has to be called in a FROM clause (similar to a table).",
 			                       function.function_name)));
 		}
-		// not a table function - search again without if_exists to throw the error
-		Catalog::GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, function.catalog, function.schema,
-		                  function.function_name, false, error_context);
-		throw InternalException("Catalog::GetEntry for scalar function did not throw a second time");
+		// not a table function - check if the schema is set
+		if (!function.schema.empty()) {
+			// the schema is set - check if we can turn this the schema into a column ref
+			string error;
+			unique_ptr<ColumnRefExpression> colref;
+			if (function.catalog.empty()) {
+				colref = make_uniq<ColumnRefExpression>(function.schema);
+			} else {
+				colref = make_uniq<ColumnRefExpression>(function.schema, function.catalog);
+			}
+			auto new_colref = QualifyColumnName(*colref, error);
+			if (error.empty()) {
+				// we can! transform this into a function call on the column
+				// i.e. "x.lower()" becomes "lower(x)"
+				function.children.insert(function.children.begin(), std::move(colref));
+				function.catalog = INVALID_CATALOG;
+				function.schema = INVALID_SCHEMA;
+			}
+		}
+		// rebind the function
+		func = Catalog::GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, function.catalog, function.schema,
+		                         function.function_name, false, error_context);
 	}
 
 	if (func->type != CatalogType::AGGREGATE_FUNCTION_ENTRY &&
@@ -90,7 +101,7 @@ BindResult ExpressionBinder::BindFunction(FunctionExpression &function, ScalarFu
 		return BindResult(error);
 	}
 	if (binder.GetBindingMode() == BindingMode::EXTRACT_NAMES) {
-		return BindResult(make_unique<BoundConstantExpression>(Value(LogicalType::SQLNULL)));
+		return BindResult(make_uniq<BoundConstantExpression>(Value(LogicalType::SQLNULL)));
 	}
 
 	// all children bound successfully
@@ -144,7 +155,7 @@ BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function, Sc
 	}
 
 	// bind the lambda parameter
-	auto &lambda_expr = (LambdaExpression &)*function.children[1];
+	auto &lambda_expr = function.children[1]->Cast<LambdaExpression>();
 	BindResult bind_lambda_result = BindExpression(lambda_expr, depth, true, list_child_type);
 
 	if (bind_lambda_result.HasError()) {
@@ -152,12 +163,11 @@ BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function, Sc
 	} else {
 		// successfully bound: replace the node with a BoundExpression
 		auto alias = function.children[1]->alias;
-		function.children[1] = make_unique<BoundExpression>(std::move(bind_lambda_result.expression));
-		auto be = (BoundExpression *)function.children[1].get();
-		D_ASSERT(be);
-		be->alias = alias;
+		function.children[1] = make_uniq<BoundExpression>(std::move(bind_lambda_result.expression));
+		auto &be = function.children[1]->Cast<BoundExpression>();
+		be.alias = alias;
 		if (!alias.empty()) {
-			be->expr->alias = alias;
+			be.expr->alias = alias;
 		}
 	}
 
@@ -165,7 +175,7 @@ BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function, Sc
 		return BindResult(error);
 	}
 	if (binder.GetBindingMode() == BindingMode::EXTRACT_NAMES) {
-		return BindResult(make_unique<BoundConstantExpression>(Value(LogicalType::SQLNULL)));
+		return BindResult(make_uniq<BoundConstantExpression>(Value(LogicalType::SQLNULL)));
 	}
 
 	// all children bound successfully
@@ -188,7 +198,7 @@ BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function, Sc
 		throw BinderException(binder.FormatError(function, error));
 	}
 
-	auto &bound_function_expr = (BoundFunctionExpression &)*result;
+	auto &bound_function_expr = result->Cast<BoundFunctionExpression>();
 	D_ASSERT(bound_function_expr.children.size() == 2);
 
 	// remove the lambda expression from the children
@@ -209,7 +219,7 @@ BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function, Sc
 
 			bound_function_expr.function.arguments.push_back(binding.types[0]);
 			auto bound_lambda_param =
-			    make_unique<BoundReferenceExpression>(binding.names[0], binding.types[0], lambda_index);
+			    make_uniq<BoundReferenceExpression>(binding.names[0], binding.types[0], lambda_index);
 			bound_function_expr.children.push_back(std::move(bound_lambda_param));
 		}
 	}
@@ -228,7 +238,7 @@ BindResult ExpressionBinder::BindAggregate(FunctionExpression &expr, AggregateFu
 	return BindResult(binder.FormatError(expr, UnsupportedAggregateMessage()));
 }
 
-BindResult ExpressionBinder::BindUnnest(FunctionExpression &expr, idx_t depth) {
+BindResult ExpressionBinder::BindUnnest(FunctionExpression &expr, idx_t depth, bool root_expression) {
 	return BindResult(binder.FormatError(expr, UnsupportedUnnestMessage()));
 }
 

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

@@ -34,7 +34,7 @@ BindResult ExpressionBinder::BindExpression(LambdaExpression &expr, idx_t depth,
 	if (expr.lhs->expression_class == ExpressionClass::COLUMN_REF) {
 		expr.params.push_back(std::move(expr.lhs));
 	} else {
-		auto &func_expr = (FunctionExpression &)*expr.lhs;
+		auto &func_expr = expr.lhs->Cast<FunctionExpression>();
 		for (idx_t i = 0; i < func_expr.children.size(); i++) {
 			expr.params.push_back(std::move(func_expr.children[i]));
 		}
@@ -48,12 +48,11 @@ BindResult ExpressionBinder::BindExpression(LambdaExpression &expr, idx_t depth,
 
 	// positional parameters as column references
 	for (idx_t i = 0; i < expr.params.size(); i++) {
-
 		if (expr.params[i]->GetExpressionClass() != ExpressionClass::COLUMN_REF) {
 			throw BinderException("Parameter must be a column name.");
 		}
 
-		auto column_ref = (ColumnRefExpression &)*expr.params[i];
+		auto column_ref = expr.params[i]->Cast<ColumnRefExpression>();
 		if (column_ref.IsQualified()) {
 			throw BinderException("Invalid parameter name '%s': must be unqualified", column_ref.ToString());
 		}
@@ -80,7 +79,9 @@ BindResult ExpressionBinder::BindExpression(LambdaExpression &expr, idx_t depth,
 	// bind the parameter expressions
 	for (idx_t i = 0; i < expr.params.size(); i++) {
 		auto result = BindExpression(&expr.params[i], depth, false);
-		D_ASSERT(!result.HasError());
+		if (result.HasError()) {
+			throw InternalException("Error during lambda binding: %s", result.error);
+		}
 	}
 
 	auto result = BindExpression(&expr.expr, depth, false);
@@ -96,8 +97,8 @@ BindResult ExpressionBinder::BindExpression(LambdaExpression &expr, idx_t depth,
 		throw BinderException(result.error);
 	}
 
-	return BindResult(make_unique<BoundLambdaExpression>(ExpressionType::LAMBDA, LogicalType::LAMBDA,
-	                                                     std::move(result.expression), params_strings.size()));
+	return BindResult(make_uniq<BoundLambdaExpression>(ExpressionType::LAMBDA, LogicalType::LAMBDA,
+	                                                   std::move(result.expression), params_strings.size()));
 }
 
 void ExpressionBinder::TransformCapturedLambdaColumn(unique_ptr<Expression> &original,
@@ -121,12 +122,12 @@ void ExpressionBinder::TransformCapturedLambdaColumn(unique_ptr<Expression> &ori
 			D_ASSERT(lambda_binding.types.size() == 1);
 			// refers to a lambda parameter outside of the current lambda function
 			replacement =
-			    make_unique<BoundReferenceExpression>(lambda_binding.names[0], lambda_binding.types[0],
-			                                          lambda_bindings->size() - bound_lambda_ref.lambda_index + 1);
+			    make_uniq<BoundReferenceExpression>(lambda_binding.names[0], lambda_binding.types[0],
+			                                        lambda_bindings->size() - bound_lambda_ref.lambda_index + 1);
 
 		} else {
 			// refers to current lambda parameter
-			replacement = make_unique<BoundReferenceExpression>(alias, list_child_type, 0);
+			replacement = make_uniq<BoundReferenceExpression>(alias, list_child_type, 0);
 		}
 
 	} else {
@@ -137,8 +138,8 @@ void ExpressionBinder::TransformCapturedLambdaColumn(unique_ptr<Expression> &ori
 		}
 
 		// this is not a lambda parameter, so we need to create a new argument for the arguments vector
-		replacement = make_unique<BoundReferenceExpression>(original->alias, original->return_type,
-		                                                    captures.size() + index_offset + 1);
+		replacement = make_uniq<BoundReferenceExpression>(original->alias, original->return_type,
+		                                                  captures.size() + index_offset + 1);
 		captures.push_back(std::move(original));
 	}
 }

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

@@ -13,7 +13,7 @@ void ExpressionBinder::ReplaceMacroParametersRecursive(unique_ptr<ParsedExpressi
 	switch (expr->GetExpressionClass()) {
 	case ExpressionClass::COLUMN_REF: {
 		// if expr is a parameter, replace it with its argument
-		auto &colref = (ColumnRefExpression &)*expr;
+		auto &colref = expr->Cast<ColumnRefExpression>();
 		bool bind_macro_parameter = false;
 		if (colref.IsQualified()) {
 			bind_macro_parameter = false;
@@ -31,7 +31,7 @@ void ExpressionBinder::ReplaceMacroParametersRecursive(unique_ptr<ParsedExpressi
 	}
 	case ExpressionClass::SUBQUERY: {
 		// replacing parameters within a subquery is slightly different
-		auto &sq = ((SubqueryExpression &)*expr).subquery;
+		auto &sq = (expr->Cast<SubqueryExpression>()).subquery;
 		ParsedExpressionIterator::EnumerateQueryNodeChildren(
 		    *sq->node, [&](unique_ptr<ParsedExpression> &child) { ReplaceMacroParametersRecursive(child); });
 		break;
@@ -65,7 +65,7 @@ BindResult ExpressionBinder::BindMacro(FunctionExpression &function, ScalarMacro
 	// positional parameters
 	for (idx_t i = 0; i < macro_def.parameters.size(); i++) {
 		types.emplace_back(LogicalType::SQLNULL);
-		auto &param = (ColumnRefExpression &)*macro_def.parameters[i];
+		auto &param = macro_def.parameters[i]->Cast<ColumnRefExpression>();
 		names.push_back(param.GetColumnName());
 	}
 	// default parameters
@@ -75,7 +75,7 @@ BindResult ExpressionBinder::BindMacro(FunctionExpression &function, ScalarMacro
 		// now push the defaults into the positionals
 		positionals.push_back(std::move(defaults[it->first]));
 	}
-	auto new_macro_binding = make_unique<DummyBinding>(types, names, macro_func->name);
+	auto new_macro_binding = make_uniq<DummyBinding>(types, names, macro_func->name);
 	new_macro_binding->arguments = &positionals;
 	macro_binding = new_macro_binding.get();
 

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

@@ -21,8 +21,21 @@ static LogicalType ResolveInType(OperatorExpression &op, vector<BoundExpression
 	}
 	// get the maximum type from the children
 	LogicalType max_type = children[0]->expr->return_type;
+	bool any_varchar = children[0]->expr->return_type == LogicalType::VARCHAR;
+	bool any_enum = children[0]->expr->return_type.id() == LogicalTypeId::ENUM;
 	for (idx_t i = 1; i < children.size(); i++) {
 		max_type = LogicalType::MaxLogicalType(max_type, children[i]->expr->return_type);
+		if (children[i]->expr->return_type == LogicalType::VARCHAR) {
+			any_varchar = true;
+		}
+		if (children[i]->expr->return_type.id() == LogicalTypeId::ENUM) {
+			any_enum = true;
+		}
+	}
+	if (any_varchar && any_enum) {
+		// For the coalesce function, we must be sure we always upcast the parameters to VARCHAR, if there are at least
+		// one enum and one varchar
+		max_type = LogicalType::VARCHAR;
 	}
 
 	// cast all children to the same type
@@ -114,7 +127,7 @@ BindResult ExpressionBinder::BindExpression(OperatorExpression &op, idx_t depth)
 		break;
 	}
 	if (!function_name.empty()) {
-		auto function = make_unique<FunctionExpression>(function_name, std::move(op.children));
+		auto function = make_uniq<FunctionExpression>(function_name, std::move(op.children));
 		return BindExpression(*function, depth, nullptr);
 	}
 
@@ -134,7 +147,7 @@ BindResult ExpressionBinder::BindExpression(OperatorExpression &op, idx_t depth)
 		}
 	}
 
-	auto result = make_unique<BoundOperatorExpression>(op.type, result_type);
+	auto result = make_uniq<BoundOperatorExpression>(op.type, result_type);
 	for (auto &child : children) {
 		result->children.push_back(std::move(child->expr));
 	}

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

@@ -8,7 +8,7 @@ namespace duckdb {
 
 BindResult ExpressionBinder::BindExpression(ParameterExpression &expr, idx_t depth) {
 	D_ASSERT(expr.parameter_nr > 0);
-	auto bound_parameter = make_unique<BoundParameterExpression>(expr.parameter_nr);
+	auto bound_parameter = make_uniq<BoundParameterExpression>(expr.parameter_nr);
 	bound_parameter->alias = expr.alias;
 	if (!binder.parameters) {
 		throw BinderException("Unexpected prepared parameter. This type of statement can't be prepared!");
@@ -18,7 +18,7 @@ BindResult ExpressionBinder::BindExpression(ParameterExpression &expr, idx_t dep
 	if (parameter_idx <= binder.parameters->parameter_data.size()) {
 		// it has! emit a constant directly
 		auto &data = binder.parameters->parameter_data[parameter_idx - 1];
-		auto constant = make_unique<BoundConstantExpression>(data.value);
+		auto constant = make_uniq<BoundConstantExpression>(data.value);
 		constant->alias = expr.alias;
 		return BindResult(std::move(constant));
 	}