duckdb 0.7.2-dev886.0 → 0.7.2-dev899.0

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

@@ -3,21 +3,86 @@
 #include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/planner/expression/bound_aggregate_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/bound_parameter_expression.hpp"
 #include "duckdb/planner/expression_binder/aggregate_binder.hpp"
 #include "duckdb/planner/expression_binder/select_binder.hpp"
 #include "duckdb/planner/query_node/bound_select_node.hpp"
 #include "duckdb/planner/expression/bound_unnest_expression.hpp"
 #include "duckdb/planner/binder.hpp"
+#include "duckdb/function/scalar/nested_functions.hpp"
+#include "duckdb/execution/expression_executor.hpp"
 
 namespace duckdb {
 
-BindResult SelectBinder::BindUnnest(FunctionExpression &function, idx_t depth) {
+unique_ptr<Expression> CreateBoundStructExtract(ClientContext &context, unique_ptr<Expression> expr, string key) {
+	vector<unique_ptr<Expression>> arguments;
+	arguments.push_back(std::move(expr));
+	arguments.push_back(make_unique<BoundConstantExpression>(Value(key)));
+	auto extract_function = StructExtractFun::GetFunction();
+	auto bind_info = extract_function.bind(context, extract_function, arguments);
+	auto return_type = extract_function.return_type;
+	auto result = make_unique<BoundFunctionExpression>(return_type, std::move(extract_function), std::move(arguments),
+	                                                   std::move(bind_info));
+	result->alias = std::move(key);
+	return std::move(result);
+}
+
+BindResult SelectBinder::BindUnnest(FunctionExpression &function, idx_t depth, bool root_expression) {
 	// bind the children of the function expression
+	if (depth > 0) {
+		return BindResult(binder.FormatError(function, "UNNEST() for correlated expressions is not supported yet"));
+	}
 	string error;
+	if (function.children.empty()) {
+		return BindResult(binder.FormatError(function, "UNNEST() requires a single argument"));
+	}
+	idx_t max_depth = 1;
 	if (function.children.size() != 1) {
-		return BindResult(binder.FormatError(function, "Unnest() needs exactly one child expressions"));
+		bool has_parameter = false;
+		bool supported_argument = false;
+		for (idx_t i = 1; i < function.children.size(); i++) {
+			if (has_parameter) {
+				return BindResult(binder.FormatError(function, "UNNEST() only supports a single additional argument"));
+			}
+			if (function.children[i]->HasParameter()) {
+				throw ParameterNotAllowedException("Parameter not allowed in unnest parameter");
+			}
+			if (!function.children[i]->IsScalar()) {
+				break;
+			}
+			auto alias = function.children[i]->alias;
+			BindChild(function.children[i], depth, error);
+			if (!error.empty()) {
+				return BindResult(error);
+			}
+			auto &const_child = (BoundExpression &)*function.children[i];
+			auto value = ExpressionExecutor::EvaluateScalar(context, *const_child.expr, true);
+			if (alias == "recursive") {
+				auto recursive = value.GetValue<bool>();
+				if (recursive) {
+					max_depth = NumericLimits<idx_t>::Maximum();
+				}
+			} else if (alias == "max_depth") {
+				max_depth = value.GetValue<uint32_t>();
+				if (max_depth == 0) {
+					throw BinderException("UNNEST cannot have a max depth of 0");
+				}
+			} else if (!alias.empty()) {
+				throw BinderException("Unsupported parameter \"%s\" for unnest", alias);
+			} else {
+				break;
+			}
+			has_parameter = true;
+			supported_argument = true;
+		}
+		if (!supported_argument) {
+			return BindResult(binder.FormatError(function, "UNNEST - unsupported extra argument, unnest only supports "
+			                                               "recursive := [true/false] or max_depth := #"));
+		}
 	}
+	unnest_level++;
 	BindChild(function.children[0], depth, error);
 	if (!error.empty()) {
 		// failed to bind
@@ -30,37 +95,111 @@ BindResult SelectBinder::BindUnnest(FunctionExpression &function, idx_t depth) {
 	}
 	auto &child = (BoundExpression &)*function.children[0];
 	auto &child_type = child.expr->return_type;
+	unnest_level--;
 
-	if (child_type.id() != LogicalTypeId::LIST && child_type.id() != LogicalTypeId::SQLNULL &&
-	    child_type.id() != LogicalTypeId::UNKNOWN) {
-		return BindResult(binder.FormatError(function, "Unnest() can only be applied to lists and NULL"));
-	}
-
-	if (depth > 0) {
-		throw BinderException(binder.FormatError(function, "Unnest() for correlated expressions is not supported yet"));
+	if (unnest_level > 0) {
+		throw BinderException(
+		    "Nested UNNEST calls are not supported - use UNNEST(x, recursive := true) to unnest multiple levels");
 	}
 
-	auto return_type = LogicalType(LogicalTypeId::SQLNULL);
-	if (child_type.id() == LogicalTypeId::LIST) {
-		return_type = ListType::GetChildType(child_type);
-	} else if (child_type.id() == LogicalTypeId::UNKNOWN) {
+	switch (child_type.id()) {
+	case LogicalTypeId::UNKNOWN:
 		throw ParameterNotResolvedException();
+	case LogicalTypeId::LIST:
+	case LogicalTypeId::STRUCT:
+	case LogicalTypeId::SQLNULL:
+		break;
+	default:
+		return BindResult(binder.FormatError(function, "UNNEST() can only be applied to lists, structs and NULL"));
 	}
 
-	auto result = make_unique<BoundUnnestExpression>(return_type);
-	result->child = std::move(child.expr);
+	idx_t list_unnests;
+	idx_t struct_unnests = 0;
 
-	auto unnest_index = node.unnests.size();
-	node.unnests.push_back(std::move(result));
-
-	// TODO what if we have multiple unnests in the same projection list? ignore for now
+	auto unnest_expr = std::move(child.expr);
+	if (child_type.id() == LogicalTypeId::SQLNULL) {
+		list_unnests = 1;
+	} else {
+		// first do all of the list unnests
+		auto type = child_type;
+		list_unnests = 0;
+		while (type.id() == LogicalTypeId::LIST) {
+			type = ListType::GetChildType(type);
+			list_unnests++;
+			if (list_unnests >= max_depth) {
+				break;
+			}
+		}
+		// unnest structs all the way afterwards, if there are any
+		if (type.id() == LogicalTypeId::STRUCT) {
+			struct_unnests = max_depth - list_unnests;
+		}
+	}
+	if (struct_unnests > 0 && !root_expression) {
+		return BindResult(binder.FormatError(
+		    function, "UNNEST() on a struct column can only be applied as the root element of a SELECT expression"));
+	}
+	// perform all of the list unnests first
+	auto return_type = child_type;
+	for (idx_t current_depth = 0; current_depth < list_unnests; current_depth++) {
+		if (return_type.id() == LogicalTypeId::LIST) {
+			return_type = ListType::GetChildType(return_type);
+		}
+		auto result = make_unique<BoundUnnestExpression>(return_type);
+		result->child = std::move(unnest_expr);
+		auto alias = function.alias.empty() ? result->ToString() : function.alias;
 
-	// now create a column reference referring to the unnest
-	auto colref = make_unique<BoundColumnRefExpression>(
-	    function.alias.empty() ? node.unnests[unnest_index]->ToString() : function.alias, return_type,
-	    ColumnBinding(node.unnest_index, unnest_index), depth);
+		auto current_level = unnest_level + list_unnests - current_depth - 1;
+		auto entry = node.unnests.find(current_level);
+		idx_t unnest_table_index;
+		idx_t unnest_column_index;
+		if (entry == node.unnests.end()) {
+			BoundUnnestNode unnest_node;
+			unnest_node.index = binder.GenerateTableIndex();
+			unnest_node.expressions.push_back(std::move(result));
+			unnest_table_index = unnest_node.index;
+			unnest_column_index = 0;
+			node.unnests.insert(make_pair(current_level, std::move(unnest_node)));
+		} else {
+			unnest_table_index = entry->second.index;
+			unnest_column_index = entry->second.expressions.size();
+			entry->second.expressions.push_back(std::move(result));
+		}
+		// now create a column reference referring to the unnest
+		unnest_expr = make_unique<BoundColumnRefExpression>(
+		    std::move(alias), return_type, ColumnBinding(unnest_table_index, unnest_column_index), depth);
+	}
+	// now perform struct unnests, if any
+	if (struct_unnests > 0) {
+		vector<unique_ptr<Expression>> struct_expressions;
+		struct_expressions.push_back(std::move(unnest_expr));
 
-	return BindResult(std::move(colref));
+		for (idx_t i = 0; i < struct_unnests; i++) {
+			vector<unique_ptr<Expression>> new_expressions;
+			// check if there are any structs left
+			bool has_structs = false;
+			for (auto &expr : struct_expressions) {
+				if (expr->return_type.id() == LogicalTypeId::STRUCT) {
+					// struct! push a struct_extract
+					auto &child_types = StructType::GetChildTypes(expr->return_type);
+					for (auto &entry : child_types) {
+						new_expressions.push_back(CreateBoundStructExtract(context, expr->Copy(), entry.first));
+					}
+					has_structs = true;
+				} else {
+					// not a struct - push as-is
+					new_expressions.push_back(std::move(expr));
+				}
+			}
+			struct_expressions = std::move(new_expressions);
+			if (!has_structs) {
+				break;
+			}
+		}
+		expanded_expressions = std::move(struct_expressions);
+		unnest_expr = make_unique<BoundConstantExpression>(Value(42));
+	}
+	return BindResult(std::move(unnest_expr));
 }
 
 } // namespace duckdb

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

@@ -119,10 +119,10 @@ static LogicalType BindRangeExpression(ClientContext &context, const string &nam
 	return bound.expr->return_type;
 }
 
-BindResult SelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
+BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 	auto name = window.GetName();
 
-	QueryErrorContext error_context(binder.root_statement, window.query_location);
+	QueryErrorContext error_context(binder.GetRootStatement(), window.query_location);
 	if (inside_window) {
 		throw BinderException(error_context.FormatError("window function calls cannot be nested"));
 	}

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

@@ -316,7 +316,6 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 	result->aggregate_index = GenerateTableIndex();
 	result->groupings_index = GenerateTableIndex();
 	result->window_index = GenerateTableIndex();
-	result->unnest_index = GenerateTableIndex();
 	result->prune_index = GenerateTableIndex();
 
 	result->from_table = std::move(from_table);
@@ -427,14 +426,32 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 	SelectBinder select_binder(*this, context, *result, info, alias_map);
 	vector<LogicalType> internal_sql_types;
 	vector<idx_t> group_by_all_indexes;
+	vector<string> new_names;
 	for (idx_t i = 0; i < statement.select_list.size(); i++) {
 		bool is_window = statement.select_list[i]->IsWindow();
 		idx_t unnest_count = result->unnests.size();
 		LogicalType result_type;
-		auto expr = select_binder.Bind(statement.select_list[i], &result_type);
+		auto expr = select_binder.Bind(statement.select_list[i], &result_type, true);
 		bool is_original_column = i < result->column_count;
 		bool can_group_by_all =
 		    statement.aggregate_handling == AggregateHandling::FORCE_AGGREGATES && is_original_column;
+		if (select_binder.HasExpandedExpressions()) {
+			if (!is_original_column) {
+				throw InternalException("Only original columns can have expanded expressions");
+			}
+			if (statement.aggregate_handling == AggregateHandling::FORCE_AGGREGATES) {
+				throw BinderException("UNNEST of struct cannot be combined with GROUP BY ALL");
+			}
+			auto &struct_expressions = select_binder.ExpandedExpressions();
+			D_ASSERT(!struct_expressions.empty());
+			for (auto &struct_expr : struct_expressions) {
+				new_names.push_back(struct_expr->GetName());
+				result->types.push_back(struct_expr->return_type);
+				result->select_list.push_back(std::move(struct_expr));
+			}
+			struct_expressions.clear();
+			continue;
+		}
 		if (can_group_by_all && select_binder.HasBoundColumns()) {
 			if (select_binder.BoundAggregates()) {
 				throw BinderException("Cannot mix aggregates with non-aggregated columns!");
@@ -450,7 +467,8 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 			group_by_all_indexes.push_back(i);
 		}
 		result->select_list.push_back(std::move(expr));
-		if (i < result->column_count) {
+		if (is_original_column) {
+			new_names.push_back(std::move(result->names[i]));
 			result->types.push_back(result_type);
 		}
 		internal_sql_types.push_back(result_type);
@@ -466,6 +484,8 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 		result->groups.group_expressions.push_back(std::move(expr));
 		expr = std::move(group_ref);
 	}
+	result->column_count = new_names.size();
+	result->names = std::move(new_names);
 	result->need_prune = result->select_list.size() > result->column_count;
 
 	// in the normal select binder, we bind columns as if there is no aggregation

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

@@ -88,9 +88,15 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSelectNode &statement) {
 		root = std::move(qualify);
 	}
 
-	if (!statement.unnests.empty()) {
-		auto unnest = make_unique<LogicalUnnest>(statement.unnest_index);
-		unnest->expressions = std::move(statement.unnests);
+	for (idx_t i = statement.unnests.size(); i > 0; i--) {
+		auto unnest_level = i - 1;
+		auto entry = statement.unnests.find(unnest_level);
+		if (entry == statement.unnests.end()) {
+			throw InternalException("unnests specified at level %d but none were found", unnest_level);
+		}
+		auto &unnest_node = entry->second;
+		auto unnest = make_unique<LogicalUnnest>(unnest_node.index);
+		unnest->expressions = std::move(unnest_node.expressions);
 		// visit the unnest expressions
 		for (auto &expr : unnest->expressions) {
 			PlanSubqueries(&expr, &root);

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

@@ -25,10 +25,10 @@ static void ConstructPivots(PivotRef &ref, idx_t pivot_idx, vector<unique_ptr<Pa
 	for (auto &entry : pivot.entries) {
 		unique_ptr<ParsedExpression> expr = current_expr ? current_expr->Copy() : nullptr;
 		string name = entry.alias;
-		D_ASSERT(entry.values.size() == pivot.names.size());
+		D_ASSERT(entry.values.size() == pivot.pivot_expressions.size());
 		for (idx_t v = 0; v < entry.values.size(); v++) {
 			auto &value = entry.values[v];
-			auto column_ref = make_unique<ColumnRefExpression>(pivot.names[v]);
+			auto column_ref = pivot.pivot_expressions[v]->Copy();
 			auto constant_value = make_unique<ConstantExpression>(value);
 			auto comp_expr = make_unique<ComparisonExpression>(ExpressionType::COMPARE_NOT_DISTINCT_FROM,
 			                                                   std::move(column_ref), std::move(constant_value));
@@ -126,8 +126,8 @@ unique_ptr<SelectNode> Binder::BindPivot(PivotRef &ref, vector<unique_ptr<Parsed
 		}
 		total_pivots *= pivot.entries.size();
 		// add the pivoted column to the columns that have been handled
-		for (auto &pivot_name : pivot.names) {
-			handled_columns.insert(pivot_name);
+		for (auto &pivot_name : pivot.pivot_expressions) {
+			ExtractPivotExpressions(*pivot_name, handled_columns);
 		}
 		value_set_t pivots;
 		for (auto &entry : pivot.entries) {
@@ -143,9 +143,9 @@ unique_ptr<SelectNode> Binder::BindPivot(PivotRef &ref, vector<unique_ptr<Parsed
 				    ref, StringUtil::Format("The value \"%s\" was specified multiple times in the IN clause",
 				                            val.ToString())));
 			}
-			if (entry.values.size() != pivot.names.size()) {
+			if (entry.values.size() != pivot.pivot_expressions.size()) {
 				throw ParserException("PIVOT IN list - inconsistent amount of rows - expected %d but got %d",
-				                      pivot.names.size(), entry.values.size());
+				                      pivot.pivot_expressions.size(), entry.values.size());
 			}
 			pivots.insert(val);
 		}
@@ -284,7 +284,7 @@ unique_ptr<SelectNode> Binder::BindUnpivot(Binder &child_binder, PivotRef &ref,
 	vector<unique_ptr<ParsedExpression>> unnest_name_children;
 	unnest_name_children.push_back(std::move(unpivot_name_expr));
 	auto unnest_name_expr = make_unique<FunctionExpression>("unnest", std::move(unnest_name_children));
-	unnest_name_expr->alias = unpivot.names[0];
+	unnest_name_expr->alias = unpivot.unpivot_names[0];
 	select_node->select_list.push_back(std::move(unnest_name_expr));
 
 	// construct the UNNEST expression for the set of unpivoted columns

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);
 }
@@ -28,7 +28,7 @@ BindResult HavingBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, i
 		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;
 		}
@@ -54,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);
 	}
 }