duckdb 0.10.1-dev22.0 → 0.10.1-dev26.0

package/src/duckdb/src/planner/binder/tableref/bind_pivot.cpp

@@ -80,16 +80,16 @@ static unique_ptr<SelectNode> ConstructInitialGrouping(PivotRef &ref, vector<uni
 			auto &columnref = entry->Cast<ColumnRefExpression>();
 			if (handled_columns.find(columnref.GetColumnName()) == handled_columns.end()) {
 				// not handled - add to grouping set
-				subquery->groups.group_expressions.push_back(
-				    make_uniq<ConstantExpression>(Value::INTEGER(subquery->select_list.size() + 1)));
+				subquery->groups.group_expressions.push_back(make_uniq<ConstantExpression>(
+				    Value::INTEGER(UnsafeNumericCast<int32_t>(subquery->select_list.size() + 1))));
 				subquery->select_list.push_back(make_uniq<ColumnRefExpression>(columnref.GetColumnName()));
 			}
 		}
 	} else {
 		// if rows are specified only the columns mentioned in rows are added as groups
 		for (auto &row : ref.groups) {
-			subquery->groups.group_expressions.push_back(
-			    make_uniq<ConstantExpression>(Value::INTEGER(subquery->select_list.size() + 1)));
+			subquery->groups.group_expressions.push_back(make_uniq<ConstantExpression>(
+			    Value::INTEGER(UnsafeNumericCast<uint32_t>(subquery->select_list.size() + 1))));
 			subquery->select_list.push_back(make_uniq<ColumnRefExpression>(row));
 		}
 	}
@@ -165,8 +165,8 @@ static unique_ptr<SelectNode> PivotInitialAggregate(PivotBindState &bind_state,
 				pivot_expr->alias = "__internal_pivot_ref" + std::to_string(++pivot_count);
 			}
 			auto pivot_alias = pivot_expr->alias;
-			subquery_stage1->groups.group_expressions.push_back(
-			    make_uniq<ConstantExpression>(Value::INTEGER(subquery_stage1->select_list.size() + 1)));
+			subquery_stage1->groups.group_expressions.push_back(make_uniq<ConstantExpression>(
+			    Value::INTEGER(UnsafeNumericCast<uint32_t>(subquery_stage1->select_list.size() + 1))));
 			subquery_stage1->select_list.push_back(std::move(pivot_expr));
 			pivot_expr = make_uniq<ColumnRefExpression>(std::move(pivot_alias));
 		}
@@ -202,8 +202,8 @@ static unique_ptr<SelectNode> PivotListAggregate(PivotBindState &bind_state, Piv
 
 	// add all of the groups
 	for (idx_t gr = 0; gr < bind_state.internal_group_names.size(); gr++) {
-		subquery_stage2->groups.group_expressions.push_back(
-		    make_uniq<ConstantExpression>(Value::INTEGER(subquery_stage2->select_list.size() + 1)));
+		subquery_stage2->groups.group_expressions.push_back(make_uniq<ConstantExpression>(
+		    Value::INTEGER(UnsafeNumericCast<uint32_t>(subquery_stage2->select_list.size() + 1))));
 		auto group_reference = make_uniq<ColumnRefExpression>(bind_state.internal_group_names[gr]);
 		group_reference->alias = bind_state.internal_group_names[gr];
 		subquery_stage2->select_list.push_back(std::move(group_reference));
@@ -396,7 +396,7 @@ unique_ptr<SelectNode> Binder::BindPivot(PivotRef &ref, vector<unique_ptr<Parsed
 		}
 		value_set_t pivots;
 		for (auto &entry : pivot.entries) {
-			D_ASSERT(!entry.star_expr);
+			D_ASSERT(!entry.expr);
 			Value val;
 			if (entry.values.size() == 1) {
 				val = entry.values[0];
@@ -464,13 +464,63 @@ unique_ptr<SelectNode> Binder::BindPivot(PivotRef &ref, vector<unique_ptr<Parsed
 	return pivot_node;
 }
 
+struct UnpivotEntry {
+	string alias;
+	vector<string> column_names;
+	vector<unique_ptr<ParsedExpression>> expressions;
+};
+
+void Binder::ExtractUnpivotEntries(Binder &child_binder, PivotColumnEntry &entry,
+                                   vector<UnpivotEntry> &unpivot_entries) {
+	if (!entry.expr) {
+		// pivot entry without an expression - generate one
+		UnpivotEntry unpivot_entry;
+		unpivot_entry.alias = entry.alias;
+		for (auto &val : entry.values) {
+			auto column_name = val.ToString();
+			if (column_name.empty()) {
+				throw BinderException("UNPIVOT - empty column name not supported");
+			}
+			unpivot_entry.expressions.push_back(make_uniq<ColumnRefExpression>(column_name));
+		}
+		unpivot_entries.push_back(std::move(unpivot_entry));
+		return;
+	}
+	D_ASSERT(entry.values.empty());
+	// expand star expressions (if any)
+	vector<unique_ptr<ParsedExpression>> star_columns;
+	child_binder.ExpandStarExpression(std::move(entry.expr), star_columns);
+
+	for (auto &expr : star_columns) {
+		// create one pivot entry per result column
+		UnpivotEntry unpivot_entry;
+		if (!expr->alias.empty()) {
+			unpivot_entry.alias = std::move(expr->alias);
+		}
+		unpivot_entry.expressions.push_back(std::move(expr));
+		unpivot_entries.push_back(std::move(unpivot_entry));
+	}
+}
+
+void Binder::ExtractUnpivotColumnName(ParsedExpression &expr, vector<string> &result) {
+	if (expr.type == ExpressionType::COLUMN_REF) {
+		auto &colref = expr.Cast<ColumnRefExpression>();
+		result.push_back(colref.GetColumnName());
+		return;
+	}
+	if (expr.type == ExpressionType::SUBQUERY) {
+		throw BinderException(expr, "UNPIVOT list cannot contain subqueries");
+	}
+	ParsedExpressionIterator::EnumerateChildren(
+	    expr, [&](ParsedExpression &child) { ExtractUnpivotColumnName(child, result); });
+}
+
 unique_ptr<SelectNode> Binder::BindUnpivot(Binder &child_binder, PivotRef &ref,
                                            vector<unique_ptr<ParsedExpression>> all_columns,
                                            unique_ptr<ParsedExpression> &where_clause) {
 	D_ASSERT(ref.groups.empty());
 	D_ASSERT(ref.pivots.size() == 1);
 
-	unique_ptr<ParsedExpression> expr;
 	auto select_node = make_uniq<SelectNode>();
 	select_node->from_table = std::move(ref.source);
 
@@ -478,34 +528,32 @@ unique_ptr<SelectNode> Binder::BindUnpivot(Binder &child_binder, PivotRef &ref,
 	auto &unpivot = ref.pivots[0];
 
 	// handle star expressions in any entries
-	vector<PivotColumnEntry> new_entries;
+	vector<UnpivotEntry> unpivot_entries;
 	for (auto &entry : unpivot.entries) {
-		if (entry.star_expr) {
-			D_ASSERT(entry.values.empty());
-			vector<unique_ptr<ParsedExpression>> star_columns;
-			child_binder.ExpandStarExpression(std::move(entry.star_expr), star_columns);
-
-			for (auto &col : star_columns) {
-				if (col->type != ExpressionType::COLUMN_REF) {
-					throw InternalException("Unexpected child of unpivot star - not a ColumnRef");
-				}
-				auto &columnref = col->Cast<ColumnRefExpression>();
-				PivotColumnEntry new_entry;
-				new_entry.values.emplace_back(columnref.GetColumnName());
-				new_entry.alias = columnref.GetColumnName();
-				new_entries.push_back(std::move(new_entry));
-			}
-		} else {
-			new_entries.push_back(std::move(entry));
-		}
+		ExtractUnpivotEntries(child_binder, entry, unpivot_entries);
 	}
-	unpivot.entries = std::move(new_entries);
 
 	case_insensitive_set_t handled_columns;
 	case_insensitive_map_t<string> name_map;
-	for (auto &entry : unpivot.entries) {
-		for (auto &value : entry.values) {
-			handled_columns.insert(value.ToString());
+	for (auto &entry : unpivot_entries) {
+		for (auto &unpivot_expr : entry.expressions) {
+			vector<string> result;
+			ExtractUnpivotColumnName(*unpivot_expr, result);
+			if (result.empty()) {
+
+				throw BinderException(
+				    *unpivot_expr,
+				    "UNPIVOT clause must contain exactly one column - expression \"%s\" does not contain any",
+				    unpivot_expr->ToString());
+			}
+			if (result.size() > 1) {
+				throw BinderException(
+				    *unpivot_expr,
+				    "UNPIVOT clause must contain exactly one column - expression \"%s\" contains multiple (%s)",
+				    unpivot_expr->ToString(), StringUtil::Join(result, ", "));
+			}
+			handled_columns.insert(result[0]);
+			entry.column_names.push_back(std::move(result[0]));
 		}
 	}
 
@@ -531,10 +579,11 @@ unique_ptr<SelectNode> Binder::BindUnpivot(Binder &child_binder, PivotRef &ref,
 		}
 	}
 	vector<Value> unpivot_names;
-	for (auto &entry : unpivot.entries) {
+	for (auto &entry : unpivot_entries) {
 		string generated_name;
-		for (auto &val : entry.values) {
-			auto name_entry = name_map.find(val.ToString());
+		D_ASSERT(entry.expressions.size() == entry.column_names.size());
+		for (idx_t c = 0; c < entry.expressions.size(); c++) {
+			auto name_entry = name_map.find(entry.column_names[c]);
 			if (name_entry == name_map.end()) {
 				throw InternalException("Unpivot - could not find column name in name map");
 			}
@@ -546,21 +595,20 @@ unique_ptr<SelectNode> Binder::BindUnpivot(Binder &child_binder, PivotRef &ref,
 		unpivot_names.emplace_back(!entry.alias.empty() ? entry.alias : generated_name);
 	}
 	vector<vector<unique_ptr<ParsedExpression>>> unpivot_expressions;
-	for (idx_t v_idx = 1; v_idx < unpivot.entries.size(); v_idx++) {
-		if (unpivot.entries[v_idx].values.size() != unpivot.entries[0].values.size()) {
+	for (idx_t v_idx = 1; v_idx < unpivot_entries.size(); v_idx++) {
+		if (unpivot_entries[v_idx].expressions.size() != unpivot_entries[0].expressions.size()) {
 			throw BinderException(
 			    ref,
 			    "UNPIVOT value count mismatch - entry has %llu values, but expected all entries to have %llu values",
-			    unpivot.entries[v_idx].values.size(), unpivot.entries[0].values.size());
+			    unpivot_entries[v_idx].expressions.size(), unpivot_entries[0].expressions.size());
 		}
 	}
 
-	for (idx_t v_idx = 0; v_idx < unpivot.entries[0].values.size(); v_idx++) {
+	for (idx_t v_idx = 0; v_idx < unpivot_entries[0].expressions.size(); v_idx++) {
 		vector<unique_ptr<ParsedExpression>> expressions;
-		expressions.reserve(unpivot.entries.size());
-		for (auto &entry : unpivot.entries) {
-			auto colref = make_uniq<ColumnRefExpression>(entry.values[v_idx].ToString());
-			expressions.push_back(std::move(colref));
+		expressions.reserve(unpivot_entries.size());
+		for (auto &entry : unpivot_entries) {
+			expressions.push_back(std::move(entry.expressions[v_idx]));
 		}
 		unpivot_expressions.push_back(std::move(expressions));
 	}
@@ -580,7 +628,7 @@ unique_ptr<SelectNode> Binder::BindUnpivot(Binder &child_binder, PivotRef &ref,
 		                      ref.unpivot_names.size(), unpivot_expressions.size());
 	}
 	for (idx_t i = 0; i < unpivot_expressions.size(); i++) {
-		auto list_expr = make_uniq<FunctionExpression>("list_value", std::move(unpivot_expressions[i]));
+		auto list_expr = make_uniq<FunctionExpression>("unpivot_list", std::move(unpivot_expressions[i]));
 		vector<unique_ptr<ParsedExpression>> unnest_val_children;
 		unnest_val_children.push_back(std::move(list_expr));
 		auto unnest_val_expr = make_uniq<FunctionExpression>("unnest", std::move(unnest_val_children));

package/src/duckdb/src/planner/binder/tableref/bind_subqueryref.cpp

@@ -15,7 +15,12 @@ unique_ptr<BoundTableRef> Binder::Bind(SubqueryRef &ref, optional_ptr<CommonTabl
 	idx_t bind_index = subquery->GetRootIndex();
 	string subquery_alias;
 	if (ref.alias.empty()) {
-		subquery_alias = "unnamed_subquery" + to_string(bind_index);
+		auto index = unnamed_subquery_index++;
+		subquery_alias = "unnamed_subquery";
+		;
+		if (index > 1) {
+			subquery_alias += to_string(index);
+		}
 	} else {
 		subquery_alias = ref.alias;
 	}

package/src/duckdb/src/planner/binder/tableref/ub_duckdb_bind_tableref.cpp

@@ -0,0 +1,17 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/planner/binder/tableref/bind_basetableref.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/tableref/bind_emptytableref.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/tableref/bind_expressionlistref.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/tableref/bind_joinref.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/tableref/bind_pivot.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/tableref/bind_subqueryref.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/tableref/bind_table_function.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/tableref/bind_named_parameters.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/tableref/plan_basetableref.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/tableref/plan_dummytableref.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/tableref/plan_expressionlistref.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/tableref/plan_joinref.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/tableref/plan_subqueryref.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/tableref/plan_table_function.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/tableref/plan_cteref.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/tableref/plan_pivotref.cpp>

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

@@ -21,20 +21,20 @@
 
 namespace duckdb {
 
-Binder *Binder::GetRootBinder() {
-	Binder *root = this;
-	while (root->parent) {
-		root = root->parent.get();
+Binder &Binder::GetRootBinder() {
+	reference<Binder> root = *this;
+	while (root.get().parent) {
+		root = *root.get().parent;
 	}
-	return root;
+	return root.get();
 }
 
 idx_t Binder::GetBinderDepth() const {
-	const Binder *root = this;
+	const_reference<Binder> root = *this;
 	idx_t depth = 1;
-	while (root->parent) {
+	while (root.get().parent) {
 		depth++;
-		root = root->parent.get();
+		root = *root.get().parent;
 	}
 	return depth;
 }
@@ -299,8 +299,8 @@ void Binder::AddBoundView(ViewCatalogEntry &view) {
 }
 
 idx_t Binder::GenerateTableIndex() {
-	auto root_binder = GetRootBinder();
-	return root_binder->bound_tables++;
+	auto &root_binder = GetRootBinder();
+	return root_binder.bound_tables++;
 }
 
 void Binder::PushExpressionBinder(ExpressionBinder &binder) {
@@ -326,13 +326,13 @@ bool Binder::HasActiveBinder() {
 }
 
 vector<reference<ExpressionBinder>> &Binder::GetActiveBinders() {
-	auto root_binder = GetRootBinder();
-	return root_binder->active_binders;
+	auto &root_binder = GetRootBinder();
+	return root_binder.active_binders;
 }
 
 void Binder::AddUsingBindingSet(unique_ptr<UsingColumnSet> set) {
-	auto root_binder = GetRootBinder();
-	root_binder->bind_context.AddUsingBindingSet(std::move(set));
+	auto &root_binder = GetRootBinder();
+	root_binder.bind_context.AddUsingBindingSet(std::move(set));
 }
 
 void Binder::MoveCorrelatedExpressions(Binder &other) {
@@ -401,14 +401,13 @@ bool Binder::HasMatchingBinding(const string &catalog_name, const string &schema
 }
 
 void Binder::SetBindingMode(BindingMode mode) {
-	auto root_binder = GetRootBinder();
-	// FIXME: this used to also set the 'mode' for the current binder, was that necessary?
-	root_binder->mode = mode;
+	auto &root_binder = GetRootBinder();
+	root_binder.mode = mode;
 }
 
 BindingMode Binder::GetBindingMode() {
-	auto root_binder = GetRootBinder();
-	return root_binder->mode;
+	auto &root_binder = GetRootBinder();
+	return root_binder.mode;
 }
 
 void Binder::SetCanContainNulls(bool can_contain_nulls_p) {
@@ -428,13 +427,13 @@ void Binder::SetAlwaysRequireRebind() {
 }
 
 void Binder::AddTableName(string table_name) {
-	auto root_binder = GetRootBinder();
-	root_binder->table_names.insert(std::move(table_name));
+	auto &root_binder = GetRootBinder();
+	root_binder.table_names.insert(std::move(table_name));
 }
 
 const unordered_set<string> &Binder::GetTableNames() {
-	auto root_binder = GetRootBinder();
-	return root_binder->table_names;
+	auto &root_binder = GetRootBinder();
+	return root_binder.table_names;
 }
 
 // FIXME: this is extremely naive

package/src/duckdb/src/planner/bound_result_modifier.cpp

@@ -116,6 +116,73 @@ bool BoundOrderModifier::Simplify(const vector<unique_ptr<Expression>> &groups)
 	return orders.empty();
 }
 
+BoundLimitNode::BoundLimitNode(LimitNodeType type, idx_t constant_integer, double constant_percentage,
+                               unique_ptr<Expression> expression_p)
+    : type(type), constant_integer(constant_integer), constant_percentage(constant_percentage),
+      expression(std::move(expression_p)) {
+}
+
+BoundLimitNode::BoundLimitNode() : type(LimitNodeType::UNSET) {
+}
+
+BoundLimitNode::BoundLimitNode(int64_t constant_value)
+    : type(LimitNodeType::CONSTANT_VALUE), constant_integer(constant_value) {
+}
+
+BoundLimitNode::BoundLimitNode(double percentage_value)
+    : type(LimitNodeType::CONSTANT_PERCENTAGE), constant_percentage(percentage_value) {
+}
+
+BoundLimitNode::BoundLimitNode(unique_ptr<Expression> expression_p, bool is_percentage)
+    : type(is_percentage ? LimitNodeType::EXPRESSION_PERCENTAGE : LimitNodeType::EXPRESSION_VALUE),
+      expression(std::move(expression_p)) {
+}
+
+BoundLimitNode BoundLimitNode::ConstantValue(int64_t value) {
+	return BoundLimitNode(value);
+}
+
+BoundLimitNode BoundLimitNode::ConstantPercentage(double percentage) {
+	return BoundLimitNode(percentage);
+}
+
+BoundLimitNode BoundLimitNode::ExpressionValue(unique_ptr<Expression> expression) {
+	return BoundLimitNode(std::move(expression), false);
+}
+
+BoundLimitNode BoundLimitNode::ExpressionPercentage(unique_ptr<Expression> expression) {
+	return BoundLimitNode(std::move(expression), true);
+}
+
+idx_t BoundLimitNode::GetConstantValue() const {
+	if (Type() != LimitNodeType::CONSTANT_VALUE) {
+		throw InternalException("BoundLimitNode::GetConstantValue called but limit is not a constant value");
+	}
+	return constant_integer;
+}
+
+double BoundLimitNode::GetConstantPercentage() const {
+	if (Type() != LimitNodeType::CONSTANT_PERCENTAGE) {
+		throw InternalException("BoundLimitNode::GetConstantPercentage called but limit is not a constant percentage");
+	}
+	return constant_percentage;
+}
+
+const Expression &BoundLimitNode::GetValueExpression() const {
+	if (Type() != LimitNodeType::EXPRESSION_VALUE) {
+		throw InternalException("BoundLimitNode::GetValueExpression called but limit is not an expression value");
+	}
+	return *expression;
+}
+
+const Expression &BoundLimitNode::GetPercentageExpression() const {
+	if (Type() != LimitNodeType::EXPRESSION_PERCENTAGE) {
+		throw InternalException(
+		    "BoundLimitNode::GetPercentageExpression called but limit is not an expression percentage");
+	}
+	return *expression;
+}
+
 BoundLimitModifier::BoundLimitModifier() : BoundResultModifier(ResultModifierType::LIMIT_MODIFIER) {
 }
 
@@ -125,8 +192,4 @@ BoundOrderModifier::BoundOrderModifier() : BoundResultModifier(ResultModifierTyp
 BoundDistinctModifier::BoundDistinctModifier() : BoundResultModifier(ResultModifierType::DISTINCT_MODIFIER) {
 }
 
-BoundLimitPercentModifier::BoundLimitPercentModifier()
-    : BoundResultModifier(ResultModifierType::LIMIT_PERCENT_MODIFIER) {
-}
-
 } // namespace duckdb

package/src/duckdb/src/planner/expression/bound_cast_expression.cpp

@@ -40,7 +40,9 @@ unique_ptr<Expression> AddCastExpressionInternal(unique_ptr<Expression> expr, co
 			return expr;
 		}
 	}
-	return make_uniq<BoundCastExpression>(std::move(expr), target_type, std::move(bound_cast), try_cast);
+	auto result = make_uniq<BoundCastExpression>(std::move(expr), target_type, std::move(bound_cast), try_cast);
+	result->query_location = result->child->query_location;
+	return std::move(result);
 }
 
 unique_ptr<Expression> AddCastToTypeInternal(unique_ptr<Expression> expr, const LogicalType &target_type,
@@ -93,6 +95,7 @@ unique_ptr<Expression> BoundCastExpression::AddDefaultCastToType(unique_ptr<Expr
                                                                  const LogicalType &target_type, bool try_cast) {
 	CastFunctionSet default_set;
 	GetCastFunctionInput get_input;
+	get_input.query_location = expr->query_location;
 	return AddCastToTypeInternal(std::move(expr), target_type, default_set, get_input, try_cast);
 }
 
@@ -100,6 +103,7 @@ unique_ptr<Expression> BoundCastExpression::AddCastToType(ClientContext &context
                                                           const LogicalType &target_type, bool try_cast) {
 	auto &cast_functions = DBConfig::GetConfig(context).GetCastFunctions();
 	GetCastFunctionInput get_input(context);
+	get_input.query_location = expr->query_location;
 	return AddCastToTypeInternal(std::move(expr), target_type, cast_functions, get_input, try_cast);
 }
 

package/src/duckdb/src/planner/expression/bound_window_expression.cpp

@@ -56,6 +56,9 @@ bool BoundWindowExpression::Equals(const BaseExpression &other_p) const {
 	if (!Expression::ListEquals(children, other.children)) {
 		return false;
 	}
+	if (!Expression::ListEquals(partitions, other.partitions)) {
+		return false;
+	}
 	// check if the filter expressions are equivalent
 	if (!Expression::Equals(filter_expr, other.filter_expr)) {
 		return false;

package/src/duckdb/src/planner/expression/ub_duckdb_planner_expression.cpp

@@ -0,0 +1,19 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/planner/expression/bound_expression.cpp>
+#include </Users/carlo/duckdb/src/planner/expression/bound_aggregate_expression.cpp>
+#include </Users/carlo/duckdb/src/planner/expression/bound_between_expression.cpp>
+#include </Users/carlo/duckdb/src/planner/expression/bound_case_expression.cpp>
+#include </Users/carlo/duckdb/src/planner/expression/bound_cast_expression.cpp>
+#include </Users/carlo/duckdb/src/planner/expression/bound_columnref_expression.cpp>
+#include </Users/carlo/duckdb/src/planner/expression/bound_comparison_expression.cpp>
+#include </Users/carlo/duckdb/src/planner/expression/bound_conjunction_expression.cpp>
+#include </Users/carlo/duckdb/src/planner/expression/bound_constant_expression.cpp>
+#include </Users/carlo/duckdb/src/planner/expression/bound_function_expression.cpp>
+#include </Users/carlo/duckdb/src/planner/expression/bound_lambda_expression.cpp>
+#include </Users/carlo/duckdb/src/planner/expression/bound_lambdaref_expression.cpp>
+#include </Users/carlo/duckdb/src/planner/expression/bound_operator_expression.cpp>
+#include </Users/carlo/duckdb/src/planner/expression/bound_parameter_expression.cpp>
+#include </Users/carlo/duckdb/src/planner/expression/bound_reference_expression.cpp>
+#include </Users/carlo/duckdb/src/planner/expression/bound_subquery_expression.cpp>
+#include </Users/carlo/duckdb/src/planner/expression/bound_unnest_expression.cpp>
+#include </Users/carlo/duckdb/src/planner/expression/bound_window_expression.cpp>

package/src/duckdb/src/planner/expression_binder/column_alias_binder.cpp

@@ -12,16 +12,20 @@ ColumnAliasBinder::ColumnAliasBinder(BoundSelectNode &node, const case_insensiti
     : node(node), alias_map(alias_map), visited_select_indexes() {
 }
 
-bool ColumnAliasBinder::BindAlias(ExpressionBinder &enclosing_binder, ColumnRefExpression &expr, idx_t depth,
-                                  bool root_expression, BindResult &result) {
+bool ColumnAliasBinder::BindAlias(ExpressionBinder &enclosing_binder, unique_ptr<ParsedExpression> &expr_ptr,
+                                  idx_t depth, bool root_expression, BindResult &result) {
+
+	D_ASSERT(expr_ptr->GetExpressionClass() == ExpressionClass::COLUMN_REF);
+	auto &expr = expr_ptr->Cast<ColumnRefExpression>();
+
+	// Qualified columns cannot be aliases.
 	if (expr.IsQualified()) {
-		// qualified columns cannot be aliases
 		return false;
 	}
 
+	// We try to find the alias in the alias_map and return false, if no alias exists.
 	auto alias_entry = alias_map.find(expr.column_names[0]);
 	if (alias_entry == alias_map.end()) {
-		// no alias found
 		return false;
 	}
 
@@ -30,13 +34,14 @@ bool ColumnAliasBinder::BindAlias(ExpressionBinder &enclosing_binder, ColumnRefE
 		return false;
 	}
 
-	// found an alias: bind the alias expression
-	auto expression = node.original_expressions[alias_entry->second]->Copy();
+	// We found an alias, so we copy the alias expression into this expression.
+	auto original_expr = node.original_expressions[alias_entry->second]->Copy();
+	expr_ptr = std::move(original_expr);
 	visited_select_indexes.insert(alias_entry->second);
 
-	// since the alias has been found, pass a depth of 0. See Issue 4978 (#16)
-	// ColumnAliasBinders are only in Having, Qualify and Where Binders
-	result = enclosing_binder.BindExpression(expression, depth, root_expression);
+	// Since the alias has been found, we pass a depth of 0. See issue 4978 (#16).
+	// Only HAVING, QUALIFY, and WHERE binders contain ColumnAliasBinders.
+	result = enclosing_binder.BindExpression(expr_ptr, depth, root_expression);
 	visited_select_indexes.erase(alias_entry->second);
 	return true;
 }

package/src/duckdb/src/planner/expression_binder/having_binder.cpp

@@ -16,13 +16,17 @@ HavingBinder::HavingBinder(Binder &binder, ClientContext &context, BoundSelectNo
 }
 
 BindResult HavingBinder::BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = expr_ptr->Cast<ColumnRefExpression>();
+
+	// Keep the original column name to return a meaningful error message.
+	auto column_name = expr_ptr->Cast<ColumnRefExpression>().GetColumnName();
+
+	// Bind the alias.
 	BindResult alias_result;
-	auto found_alias = column_alias_binder.BindAlias(*this, expr, depth, root_expression, alias_result);
+	auto found_alias = column_alias_binder.BindAlias(*this, expr_ptr, depth, root_expression, alias_result);
+
 	if (found_alias) {
 		if (depth > 0) {
-			throw BinderException("Having clause cannot reference alias \"%s\" in correlated subquery",
-			                      expr.GetColumnName());
+			throw BinderException("Having clause cannot reference alias \"%s\" in correlated subquery", column_name);
 		}
 		return alias_result;
 	}
@@ -30,20 +34,24 @@ BindResult HavingBinder::BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, i
 	if (aggregate_handling == AggregateHandling::FORCE_AGGREGATES) {
 		if (depth > 0) {
 			throw BinderException(
-			    "Having clause cannot reference column \"%s\" in correlated subquery and group by all",
-			    expr.GetColumnName());
+			    "Having clause cannot reference column \"%s\" in correlated subquery and group by all", column_name);
 		}
+
 		auto expr = duckdb::BaseSelectBinder::BindExpression(expr_ptr, depth);
 		if (expr.HasError()) {
 			return expr;
 		}
-		auto group_ref = make_uniq<BoundColumnRefExpression>(
-		    expr.expression->return_type, ColumnBinding(node.group_index, node.groups.group_expressions.size()));
+
+		// Return a GROUP BY column reference expression.
+		auto return_type = expr.expression->return_type;
+		auto column_binding = ColumnBinding(node.group_index, node.groups.group_expressions.size());
+		auto group_ref = make_uniq<BoundColumnRefExpression>(return_type, column_binding);
 		node.groups.group_expressions.push_back(std::move(expr.expression));
 		return BindResult(std::move(group_ref));
 	}
+
 	return BindResult(StringUtil::Format(
-	    "column %s must appear in the GROUP BY clause or be used in an aggregate function", expr.ToString()));
+	    "column %s must appear in the GROUP BY clause or be used in an aggregate function", column_name));
 }
 
 BindResult HavingBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {