duckdb 0.7.2-dev0.0 → 0.7.2-dev1138.0

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

@@ -7,6 +7,7 @@
 #include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/operator/logical_any_join.hpp"
+#include "duckdb/planner/operator/logical_asof_join.hpp"
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
 #include "duckdb/planner/operator/logical_cross_product.hpp"
 #include "duckdb/planner/operator/logical_filter.hpp"
@@ -33,7 +34,7 @@ static bool CreateJoinCondition(Expression &expr, const unordered_set<idx_t> &le
 		if (left_side == JoinSide::RIGHT) {
 			// left = right, right = left, flip the comparison symbol and reverse sides
 			swap(left, right);
-			condition.comparison = FlipComparisionExpression(expr.type);
+			condition.comparison = FlipComparisonExpression(expr.type);
 		}
 		condition.left = std::move(left);
 		condition.right = std::move(right);
@@ -104,12 +105,43 @@ void LogicalComparisonJoin::ExtractJoinConditions(JoinType type, unique_ptr<Logi
 	return ExtractJoinConditions(type, left_child, right_child, expressions, conditions, arbitrary_expressions);
 }
 
-unique_ptr<LogicalOperator> LogicalComparisonJoin::CreateJoin(JoinType type, unique_ptr<LogicalOperator> left_child,
+unique_ptr<LogicalOperator> LogicalComparisonJoin::CreateJoin(JoinType type, JoinRefType reftype,
+                                                              unique_ptr<LogicalOperator> left_child,
                                                               unique_ptr<LogicalOperator> right_child,
                                                               vector<JoinCondition> conditions,
                                                               vector<unique_ptr<Expression>> arbitrary_expressions) {
+	// Validate the conditions
 	bool need_to_consider_arbitrary_expressions = true;
-	if (type == JoinType::INNER) {
+	switch (reftype) {
+	case JoinRefType::ASOF: {
+		need_to_consider_arbitrary_expressions = false;
+		auto asof_idx = conditions.size();
+		for (size_t c = 0; c < conditions.size(); ++c) {
+			auto &cond = conditions[c];
+			switch (cond.comparison) {
+			case ExpressionType::COMPARE_EQUAL:
+			case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
+				break;
+			case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
+				if (asof_idx < conditions.size()) {
+					throw BinderException("Multiple ASOF JOIN inequalities");
+				}
+				asof_idx = c;
+				break;
+			default:
+				throw BinderException("Invalid ASOF JOIN comparison");
+			}
+		}
+		if (asof_idx == conditions.size()) {
+			throw BinderException("Missing ASOF JOIN inequality");
+		}
+		break;
+	}
+	default:
+		break;
+	}
+
+	if (type == JoinType::INNER && reftype == JoinRefType::REGULAR) {
 		// for inner joins we can push arbitrary expressions as a filter
 		// here we prefer to create a comparison join if possible
 		// that way we can use the much faster hash join to process the main join
@@ -144,7 +176,12 @@ unique_ptr<LogicalOperator> LogicalComparisonJoin::CreateJoin(JoinType type, uni
 	} else {
 		// we successfully converted expressions into JoinConditions
 		// create a LogicalComparisonJoin
-		auto comp_join = make_unique<LogicalComparisonJoin>(type);
+		unique_ptr<LogicalComparisonJoin> comp_join;
+		if (reftype == JoinRefType::ASOF) {
+			comp_join = make_unique<LogicalAsOfJoin>(type);
+		} else {
+			comp_join = make_unique<LogicalComparisonJoin>(type);
+		}
 		comp_join->conditions = std::move(conditions);
 		comp_join->children.push_back(std::move(left_child));
 		comp_join->children.push_back(std::move(right_child));
@@ -179,15 +216,16 @@ static bool HasCorrelatedColumns(Expression &expression) {
 	return has_correlated_columns;
 }
 
-unique_ptr<LogicalOperator> LogicalComparisonJoin::CreateJoin(JoinType type, unique_ptr<LogicalOperator> left_child,
+unique_ptr<LogicalOperator> LogicalComparisonJoin::CreateJoin(JoinType type, JoinRefType reftype,
+                                                              unique_ptr<LogicalOperator> left_child,
                                                               unique_ptr<LogicalOperator> right_child,
                                                               unique_ptr<Expression> condition) {
 	vector<JoinCondition> conditions;
 	vector<unique_ptr<Expression>> arbitrary_expressions;
 	LogicalComparisonJoin::ExtractJoinConditions(type, left_child, right_child, std::move(condition), conditions,
 	                                             arbitrary_expressions);
-	return LogicalComparisonJoin::CreateJoin(type, std::move(left_child), std::move(right_child), std::move(conditions),
-	                                         std::move(arbitrary_expressions));
+	return LogicalComparisonJoin::CreateJoin(type, reftype, std::move(left_child), std::move(right_child),
+	                                         std::move(conditions), std::move(arbitrary_expressions));
 }
 
 unique_ptr<LogicalOperator> Binder::CreatePlan(BoundJoinRef &ref) {
@@ -201,7 +239,8 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundJoinRef &ref) {
 		// we reduce expression depth of all columns in the "ref.correlated_columns" set by 1
 		LateralBinder::ReduceExpressionDepth(*right, ref.correlated_columns);
 	}
-	if (ref.type == JoinType::RIGHT && ClientConfig::GetConfig(context).enable_optimizer) {
+	if (ref.type == JoinType::RIGHT && ref.ref_type != JoinRefType::ASOF &&
+	    ClientConfig::GetConfig(context).enable_optimizer) {
 		// we turn any right outer joins into left outer joins for optimization purposes
 		// they are the same but with sides flipped, so treating them the same simplifies life
 		ref.type = JoinType::LEFT;
@@ -220,7 +259,8 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundJoinRef &ref) {
 	default:
 		break;
 	}
-	if (ref.type == JoinType::INNER && (ref.condition->HasSubquery() || HasCorrelatedColumns(*ref.condition))) {
+	if (ref.type == JoinType::INNER && (ref.condition->HasSubquery() || HasCorrelatedColumns(*ref.condition)) &&
+	    ref.ref_type == JoinRefType::REGULAR) {
 		// inner join, generate a cross product + filter
 		// this will be later turned into a proper join by the join order optimizer
 		auto root = LogicalCrossProduct::Create(std::move(left), std::move(right));
@@ -235,8 +275,8 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundJoinRef &ref) {
 	}
 
 	// now create the join operator from the join condition
-	auto result =
-	    LogicalComparisonJoin::CreateJoin(ref.type, std::move(left), std::move(right), std::move(ref.condition));
+	auto result = LogicalComparisonJoin::CreateJoin(ref.type, ref.ref_type, std::move(left), std::move(right),
+	                                                std::move(ref.condition));
 
 	LogicalOperator *join;
 	if (result->type == LogicalOperatorType::LOGICAL_FILTER) {
@@ -254,7 +294,9 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundJoinRef &ref) {
 	}
 
 	// we visit the expressions depending on the type of join
-	if (join->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
+	switch (join->type) {
+	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
+	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
 		// comparison join
 		// in this join we visit the expressions on the LHS with the LHS as root node
 		// and the expressions on the RHS with the RHS as root node
@@ -263,12 +305,18 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundJoinRef &ref) {
 			PlanSubqueries(&comp_join.conditions[i].left, &comp_join.children[0]);
 			PlanSubqueries(&comp_join.conditions[i].right, &comp_join.children[1]);
 		}
-	} else if (join->type == LogicalOperatorType::LOGICAL_ANY_JOIN) {
+		break;
+	}
+	case LogicalOperatorType::LOGICAL_ANY_JOIN: {
 		auto &any_join = (LogicalAnyJoin &)*join;
 		// for the any join we just visit the condition
 		if (any_join.condition->HasSubquery()) {
 			throw NotImplementedException("Cannot perform non-inner join on subquery!");
 		}
+		break;
+	}
+	default:
+		break;
 	}
 	return result;
 }

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

@@ -3,8 +3,10 @@
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
 #include "duckdb/main/config.hpp"
+#include "duckdb/parser/parsed_expression_iterator.hpp"
 #include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/parser/statement/list.hpp"
+#include "duckdb/parser/tableref/joinref.hpp"
 #include "duckdb/parser/tableref/table_function_ref.hpp"
 #include "duckdb/planner/bound_query_node.hpp"
 #include "duckdb/planner/bound_tableref.hpp"
@@ -13,7 +15,6 @@
 #include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/planner/operator/logical_projection.hpp"
 #include "duckdb/planner/operator/logical_sample.hpp"
-#include "duckdb/parser/parsed_expression_iterator.hpp"
 
 #include <algorithm>
 
@@ -170,8 +171,12 @@ unique_ptr<BoundTableRef> Binder::Bind(TableRef &ref) {
 	case TableReferenceType::EXPRESSION_LIST:
 		result = Bind((ExpressionListRef &)ref);
 		break;
+	case TableReferenceType::PIVOT:
+		result = Bind((PivotRef &)ref);
+		break;
 	case TableReferenceType::CTE:
 	case TableReferenceType::INVALID:
+	default:
 		throw InternalException("Unknown table ref type");
 	}
 	result->sample = std::move(ref.sample);
@@ -203,6 +208,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundTableRef &ref) {
 		root = CreatePlan((BoundCTERef &)ref);
 		break;
 	case TableReferenceType::INVALID:
+	default:
 		throw InternalException("Unsupported bound table ref type");
 	}
 	// plan the sample clause
@@ -432,8 +438,8 @@ void VerifyNotExcluded(ParsedExpression &expr) {
 }
 
 BoundStatement Binder::BindReturning(vector<unique_ptr<ParsedExpression>> returning_list, TableCatalogEntry *table,
-                                     idx_t update_table_index, unique_ptr<LogicalOperator> child_operator,
-                                     BoundStatement result) {
+                                     const string &alias, idx_t update_table_index,
+                                     unique_ptr<LogicalOperator> child_operator, BoundStatement result) {
 
 	vector<LogicalType> types;
 	vector<std::string> names;
@@ -451,31 +457,20 @@ BoundStatement Binder::BindReturning(vector<unique_ptr<ParsedExpression>> return
 		column_count++;
 	}
 
-	binder->bind_context.AddBaseTable(update_table_index, table->name, names, types, bound_columns, table, false);
+	binder->bind_context.AddBaseTable(update_table_index, alias.empty() ? table->name : alias, names, types,
+	                                  bound_columns, table, false);
 	ReturningBinder returning_binder(*binder, context);
 
 	vector<unique_ptr<Expression>> projection_expressions;
 	LogicalType result_type;
-	for (auto &returning_expr : returning_list) {
-		auto expr_type = returning_expr->GetExpressionType();
-		if (expr_type == ExpressionType::STAR) {
-			auto generated_star_list = vector<unique_ptr<ParsedExpression>>();
-			binder->bind_context.GenerateAllColumnExpressions((StarExpression &)*returning_expr, generated_star_list);
-
-			for (auto &star_column : generated_star_list) {
-				auto star_expr = returning_binder.Bind(star_column, &result_type);
-				result.types.push_back(result_type);
-				result.names.push_back(star_expr->GetName());
-				projection_expressions.push_back(std::move(star_expr));
-			}
-		} else {
-			// TODO: accept 'excluded' in the RETURNING clause
-			VerifyNotExcluded(*returning_expr);
-			auto expr = returning_binder.Bind(returning_expr, &result_type);
-			result.names.push_back(expr->GetName());
-			result.types.push_back(result_type);
-			projection_expressions.push_back(std::move(expr));
-		}
+	vector<unique_ptr<ParsedExpression>> new_returning_list;
+	binder->ExpandStarExpressions(returning_list, new_returning_list);
+	for (auto &returning_expr : new_returning_list) {
+		VerifyNotExcluded(*returning_expr);
+		auto expr = returning_binder.Bind(returning_expr, &result_type);
+		result.names.push_back(expr->GetName());
+		result.types.push_back(result_type);
+		projection_expressions.push_back(std::move(expr));
 	}
 
 	auto projection = make_unique<LogicalProjection>(GenerateTableIndex(), std::move(projection_expressions));

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

@@ -19,7 +19,7 @@ BoundOrderByNode::BoundOrderByNode(OrderType type, OrderByNullType null_order, u
 
 BoundOrderByNode BoundOrderByNode::Copy() const {
 	if (stats) {
-		return BoundOrderByNode(type, null_order, expression->Copy(), stats->Copy());
+		return BoundOrderByNode(type, null_order, expression->Copy(), stats->ToUnique());
 	} else {
 		return BoundOrderByNode(type, null_order, expression->Copy());
 	}
@@ -80,6 +80,32 @@ BoundOrderByNode BoundOrderByNode::Deserialize(Deserializer &source, PlanDeseria
 	return BoundOrderByNode(type, null_order, std::move(expression));
 }
 
+unique_ptr<BoundOrderModifier> BoundOrderModifier::Copy() const {
+	auto result = make_unique<BoundOrderModifier>();
+	for (auto &order : orders) {
+		result->orders.push_back(order.Copy());
+	}
+	return result;
+}
+
+bool BoundOrderModifier::Equals(const BoundOrderModifier *left, const BoundOrderModifier *right) {
+	if (left == right) {
+		return true;
+	}
+	if (!left || !right) {
+		return false;
+	}
+	if (left->orders.size() != right->orders.size()) {
+		return false;
+	}
+	for (idx_t i = 0; i < left->orders.size(); i++) {
+		if (!left->orders[i].Equals(right->orders[i])) {
+			return false;
+		}
+	}
+	return true;
+}
+
 BoundLimitModifier::BoundLimitModifier() : BoundResultModifier(ResultModifierType::LIMIT_MODIFIER) {
 }
 

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

@@ -19,8 +19,8 @@ BoundAggregateExpression::BoundAggregateExpression(AggregateFunction function, v
 }
 
 string BoundAggregateExpression::ToString() const {
-	return FunctionExpression::ToString<BoundAggregateExpression, Expression>(*this, string(), function.name, false,
-	                                                                          IsDistinct(), filter.get());
+	return FunctionExpression::ToString<BoundAggregateExpression, Expression, BoundOrderModifier>(
+	    *this, string(), function.name, false, IsDistinct(), filter.get(), order_bys.get());
 }
 
 hash_t BoundAggregateExpression::Hash() const {
@@ -55,6 +55,9 @@ bool BoundAggregateExpression::Equals(const BaseExpression *other_p) const {
 	if (!FunctionData::Equals(bind_info.get(), other->bind_info.get())) {
 		return false;
 	}
+	if (!BoundOrderModifier::Equals(order_bys.get(), other->order_bys.get())) {
+		return false;
+	}
 	return true;
 }
 
@@ -74,12 +77,16 @@ unique_ptr<Expression> BoundAggregateExpression::Copy() {
 	auto copy = make_unique<BoundAggregateExpression>(function, std::move(new_children), std::move(new_filter),
 	                                                  std::move(new_bind_info), aggr_type);
 	copy->CopyProperties(*this);
+	copy->order_bys = order_bys ? order_bys->Copy() : nullptr;
 	return std::move(copy);
 }
 
 void BoundAggregateExpression::Serialize(FieldWriter &writer) const {
 	writer.WriteField(IsDistinct());
 	writer.WriteOptional(filter);
+	if (order_bys) {
+		throw NotImplementedException("Serialization of ORDER BY aggregate not yet supported");
+	}
 	FunctionSerializer::Serialize<AggregateFunction>(writer, function, return_type, children, bind_info.get());
 }
 

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

@@ -28,4 +28,8 @@ void BoundExpression::Serialize(FieldWriter &writer) const {
 	throw SerializationException("Cannot copy or serialize bound expression");
 }
 
+void BoundExpression::FormatSerialize(FormatSerializer &serializer) const {
+	throw SerializationException("Cannot copy or serialize bound expression");
+}
+
 } // namespace duckdb

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

@@ -102,7 +102,7 @@ unique_ptr<Expression> BoundWindowExpression::Copy() {
 	}
 	for (auto &ps : partitions_stats) {
 		if (ps) {
-			new_window->partitions_stats.push_back(ps->Copy());
+			new_window->partitions_stats.push_back(ps->ToUnique());
 		} else {
 			new_window->partitions_stats.push_back(nullptr);
 		}

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

@@ -0,0 +1,146 @@
+#include "duckdb/planner/expression_binder/base_select_binder.hpp"
+
+#include "duckdb/parser/expression/columnref_expression.hpp"
+#include "duckdb/parser/expression/window_expression.hpp"
+#include "duckdb/parser/parsed_expression_iterator.hpp"
+#include "duckdb/planner/expression/bound_columnref_expression.hpp"
+#include "duckdb/planner/expression/bound_window_expression.hpp"
+#include "duckdb/planner/expression_binder/aggregate_binder.hpp"
+#include "duckdb/planner/query_node/bound_select_node.hpp"
+#include "duckdb/parser/expression/operator_expression.hpp"
+#include "duckdb/common/string_util.hpp"
+#include "duckdb/planner/binder.hpp"
+
+namespace duckdb {
+
+BaseSelectBinder::BaseSelectBinder(Binder &binder, ClientContext &context, BoundSelectNode &node,
+                                   BoundGroupInformation &info, case_insensitive_map_t<idx_t> alias_map)
+    : ExpressionBinder(binder, context), inside_window(false), node(node), info(info), alias_map(std::move(alias_map)) {
+}
+
+BaseSelectBinder::BaseSelectBinder(Binder &binder, ClientContext &context, BoundSelectNode &node,
+                                   BoundGroupInformation &info)
+    : BaseSelectBinder(binder, context, node, info, case_insensitive_map_t<idx_t>()) {
+}
+
+BindResult BaseSelectBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
+	auto &expr = **expr_ptr;
+	// check if the expression binds to one of the groups
+	auto group_index = TryBindGroup(expr, depth);
+	if (group_index != DConstants::INVALID_INDEX) {
+		return BindGroup(expr, depth, group_index);
+	}
+	switch (expr.expression_class) {
+	case ExpressionClass::COLUMN_REF:
+		return BindColumnRef(expr_ptr, depth);
+	case ExpressionClass::DEFAULT:
+		return BindResult("SELECT clause cannot contain DEFAULT clause");
+	case ExpressionClass::WINDOW:
+		return BindWindow((WindowExpression &)expr, depth);
+	default:
+		return ExpressionBinder::BindExpression(expr_ptr, depth, root_expression);
+	}
+}
+
+idx_t BaseSelectBinder::TryBindGroup(ParsedExpression &expr, idx_t depth) {
+	// first check the group alias map, if expr is a ColumnRefExpression
+	if (expr.type == ExpressionType::COLUMN_REF) {
+		auto &colref = (ColumnRefExpression &)expr;
+		if (!colref.IsQualified()) {
+			auto alias_entry = info.alias_map.find(colref.column_names[0]);
+			if (alias_entry != info.alias_map.end()) {
+				// found entry!
+				return alias_entry->second;
+			}
+		}
+	}
+	// no alias reference found
+	// check the list of group columns for a match
+	auto entry = info.map.find(&expr);
+	if (entry != info.map.end()) {
+		return entry->second;
+	}
+#ifdef DEBUG
+	for (auto entry : info.map) {
+		D_ASSERT(!entry.first->Equals(&expr));
+		D_ASSERT(!expr.Equals(entry.first));
+	}
+#endif
+	return DConstants::INVALID_INDEX;
+}
+
+BindResult BaseSelectBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth) {
+	// first try to bind the column reference regularly
+	auto result = ExpressionBinder::BindExpression(expr_ptr, depth);
+	if (!result.HasError()) {
+		return result;
+	}
+	// binding failed
+	// check in the alias map
+	auto &colref = (ColumnRefExpression &)**expr_ptr;
+	if (!colref.IsQualified()) {
+		auto alias_entry = alias_map.find(colref.column_names[0]);
+		if (alias_entry != alias_map.end()) {
+			// found entry!
+			auto index = alias_entry->second;
+			if (index >= node.select_list.size()) {
+				throw BinderException("Column \"%s\" referenced that exists in the SELECT clause - but this column "
+				                      "cannot be referenced before it is defined",
+				                      colref.column_names[0]);
+			}
+			if (node.select_list[index]->HasSideEffects()) {
+				throw BinderException("Alias \"%s\" referenced in a SELECT clause - but the expression has side "
+				                      "effects. This is not yet supported.",
+				                      colref.column_names[0]);
+			}
+			if (node.select_list[index]->HasSubquery()) {
+				throw BinderException("Alias \"%s\" referenced in a SELECT clause - but the expression has a subquery."
+				                      " This is not yet supported.",
+				                      colref.column_names[0]);
+			}
+			auto result = BindResult(node.select_list[index]->Copy());
+			if (result.expression->type == ExpressionType::BOUND_COLUMN_REF) {
+				auto &result_expr = (BoundColumnRefExpression &)*result.expression;
+				result_expr.depth = depth;
+			}
+			return result;
+		}
+	}
+	// entry was not found in the alias map: return the original error
+	return result;
+}
+
+BindResult BaseSelectBinder::BindGroupingFunction(OperatorExpression &op, idx_t depth) {
+	if (op.children.empty()) {
+		throw InternalException("GROUPING requires at least one child");
+	}
+	if (node.groups.group_expressions.empty()) {
+		return BindResult(binder.FormatError(op, "GROUPING statement cannot be used without groups"));
+	}
+	if (op.children.size() >= 64) {
+		return BindResult(binder.FormatError(op, "GROUPING statement cannot have more than 64 groups"));
+	}
+	vector<idx_t> group_indexes;
+	group_indexes.reserve(op.children.size());
+	for (auto &child : op.children) {
+		ExpressionBinder::QualifyColumnNames(binder, child);
+		auto idx = TryBindGroup(*child, depth);
+		if (idx == DConstants::INVALID_INDEX) {
+			return BindResult(binder.FormatError(
+			    op, StringUtil::Format("GROUPING child \"%s\" must be a grouping column", child->GetName())));
+		}
+		group_indexes.push_back(idx);
+	}
+	auto col_idx = node.grouping_functions.size();
+	node.grouping_functions.push_back(std::move(group_indexes));
+	return BindResult(make_unique<BoundColumnRefExpression>(op.GetName(), LogicalType::BIGINT,
+	                                                        ColumnBinding(node.groupings_index, col_idx), depth));
+}
+
+BindResult BaseSelectBinder::BindGroup(ParsedExpression &expr, idx_t depth, idx_t group_index) {
+	auto &group = node.groups.group_expressions[group_index];
+	return BindResult(make_unique<BoundColumnRefExpression>(expr.GetName(), group->return_type,
+	                                                        ColumnBinding(node.group_index, group_index), depth));
+}
+
+} // namespace duckdb

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

@@ -10,7 +10,7 @@ namespace duckdb {
 
 HavingBinder::HavingBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info,
                            case_insensitive_map_t<idx_t> &alias_map, AggregateHandling aggregate_handling)
-    : SelectBinder(binder, context, node, info), column_alias_binder(node, alias_map),
+    : BaseSelectBinder(binder, context, node, info), column_alias_binder(node, alias_map),
       aggregate_handling(aggregate_handling) {
 	target_type = LogicalType(LogicalTypeId::BOOLEAN);
 }
@@ -19,13 +19,16 @@ BindResult HavingBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, i
 	auto &expr = (ColumnRefExpression &)**expr_ptr;
 	auto alias_result = column_alias_binder.BindAlias(*this, expr, depth, root_expression);
 	if (!alias_result.HasError()) {
+		if (depth > 0) {
+			throw BinderException("Having clause cannot reference alias in correlated subquery");
+		}
 		return alias_result;
 	}
 	if (aggregate_handling == AggregateHandling::FORCE_AGGREGATES) {
 		if (depth > 0) {
 			throw BinderException("Having clause cannot reference column in correlated subquery and group by all");
 		}
-		auto expr = duckdb::SelectBinder::BindExpression(expr_ptr, depth);
+		auto expr = duckdb::BaseSelectBinder::BindExpression(expr_ptr, depth);
 		if (expr.HasError()) {
 			return expr;
 		}
@@ -51,7 +54,7 @@ BindResult HavingBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr,
 	case ExpressionClass::COLUMN_REF:
 		return BindColumnRef(expr_ptr, depth, root_expression);
 	default:
-		return duckdb::SelectBinder::BindExpression(expr_ptr, depth);
+		return duckdb::BaseSelectBinder::BindExpression(expr_ptr, depth);
 	}
 }
 

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

@@ -10,13 +10,13 @@ namespace duckdb {
 
 QualifyBinder::QualifyBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info,
                              case_insensitive_map_t<idx_t> &alias_map)
-    : SelectBinder(binder, context, node, info), column_alias_binder(node, alias_map) {
+    : BaseSelectBinder(binder, context, node, info), column_alias_binder(node, alias_map) {
 	target_type = LogicalType(LogicalTypeId::BOOLEAN);
 }
 
 BindResult QualifyBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
 	auto &expr = (ColumnRefExpression &)**expr_ptr;
-	auto result = duckdb::SelectBinder::BindExpression(expr_ptr, depth);
+	auto result = duckdb::BaseSelectBinder::BindExpression(expr_ptr, depth);
 	if (!result.HasError()) {
 		return result;
 	}
@@ -43,7 +43,7 @@ BindResult QualifyBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr,
 	case ExpressionClass::COLUMN_REF:
 		return BindColumnRef(expr_ptr, depth, root_expression);
 	default:
-		return duckdb::SelectBinder::BindExpression(expr_ptr, depth);
+		return duckdb::BaseSelectBinder::BindExpression(expr_ptr, depth);
 	}
 }