duckdb 0.7.2-dev1457.0 → 0.7.2-dev1533.0

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

@@ -3,6 +3,7 @@
 #include "duckdb/parser/tableref/subqueryref.hpp"
 #include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/parser/expression/case_expression.hpp"
+#include "duckdb/parser/expression/cast_expression.hpp"
 #include "duckdb/parser/expression/columnref_expression.hpp"
 #include "duckdb/parser/expression/comparison_expression.hpp"
 #include "duckdb/parser/expression/conjunction_expression.hpp"
@@ -14,30 +15,23 @@
 #include "duckdb/parser/parsed_expression_iterator.hpp"
 #include "duckdb/parser/expression/operator_expression.hpp"
 #include "duckdb/planner/tableref/bound_subqueryref.hpp"
+#include "duckdb/planner/tableref/bound_pivotref.hpp"
+#include "duckdb/planner/expression/bound_aggregate_expression.hpp"
+#include "duckdb/main/client_config.hpp"
 
 namespace duckdb {
 
-static void ConstructPivots(PivotRef &ref, idx_t pivot_idx, vector<unique_ptr<ParsedExpression>> &pivot_expressions,
-                            unique_ptr<ParsedExpression> current_expr = nullptr,
-                            const string &current_name = string()) {
+static void ConstructPivots(PivotRef &ref, vector<PivotValueElement> &pivot_values, idx_t pivot_idx = 0,
+                            const PivotValueElement &current_value = PivotValueElement()) {
 	auto &pivot = ref.pivots[pivot_idx];
 	bool last_pivot = pivot_idx + 1 == ref.pivots.size();
 	for (auto &entry : pivot.entries) {
-		unique_ptr<ParsedExpression> expr = current_expr ? current_expr->Copy() : nullptr;
+		PivotValueElement new_value = current_value;
 		string name = entry.alias;
 		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 = pivot.pivot_expressions[v]->Copy();
-			auto constant_value = make_uniq<ConstantExpression>(value);
-			auto comp_expr = make_uniq<ComparisonExpression>(ExpressionType::COMPARE_NOT_DISTINCT_FROM,
-			                                                 std::move(column_ref), std::move(constant_value));
-			if (expr) {
-				expr = make_uniq<ConjunctionExpression>(ExpressionType::CONJUNCTION_AND, std::move(expr),
-				                                        std::move(comp_expr));
-			} else {
-				expr = std::move(comp_expr);
-			}
+			new_value.values.push_back(value);
 			if (entry.alias.empty()) {
 				if (name.empty()) {
 					name = value.ToString();
@@ -46,34 +40,23 @@ static void ConstructPivots(PivotRef &ref, idx_t pivot_idx, vector<unique_ptr<Pa
 				}
 			}
 		}
-		if (!current_name.empty()) {
-			name = current_name + "_" + name;
+		if (!current_value.name.empty()) {
+			new_value.name = current_value.name + "_" + name;
+		} else {
+			new_value.name = std::move(name);
 		}
 		if (last_pivot) {
-			// construct the aggregates
-			for (auto &aggr : ref.aggregates) {
-				auto copy = aggr->Copy();
-				auto &function = (FunctionExpression &)*copy;
-				// add the filter and alias to the aggregate function
-				function.filter = expr->Copy();
-				if (ref.aggregates.size() > 1 || !function.alias.empty()) {
-					// if there are multiple aggregates specified we add the name of the aggregate as well
-					function.alias = name + "_" + function.GetName();
-				} else {
-					function.alias = name;
-				}
-				pivot_expressions.push_back(std::move(copy));
-			}
+			pivot_values.push_back(std::move(new_value));
 		} else {
 			// need to recurse
-			ConstructPivots(ref, pivot_idx + 1, pivot_expressions, std::move(expr), name);
+			ConstructPivots(ref, pivot_values, pivot_idx + 1, new_value);
 		}
 	}
 }
 
 static void ExtractPivotExpressions(ParsedExpression &expr, case_insensitive_set_t &handled_columns) {
 	if (expr.type == ExpressionType::COLUMN_REF) {
-		auto &child_colref = (ColumnRefExpression &)expr;
+		auto &child_colref = expr.Cast<ColumnRefExpression>();
 		if (child_colref.IsQualified()) {
 			throw BinderException("PIVOT expression cannot contain qualified columns");
 		}
@@ -83,8 +66,237 @@ static void ExtractPivotExpressions(ParsedExpression &expr, case_insensitive_set
 	    expr, [&](ParsedExpression &child) { ExtractPivotExpressions(child, handled_columns); });
 }
 
+struct PivotBindState {
+	vector<string> internal_group_names;
+	vector<string> group_names;
+	vector<string> aggregate_names;
+	vector<string> internal_aggregate_names;
+};
+
+static unique_ptr<SelectNode> PivotInitialAggregate(PivotBindState &bind_state, PivotRef &ref,
+                                                    vector<unique_ptr<ParsedExpression>> all_columns,
+                                                    const case_insensitive_set_t &handled_columns) {
+	auto subquery_stage1 = make_uniq<SelectNode>();
+	subquery_stage1->from_table = std::move(ref.source);
+	if (ref.groups.empty()) {
+		// if rows are not specified any columns that are not pivoted/aggregated on are added to the GROUP BY clause
+		for (auto &entry : all_columns) {
+			if (entry->type != ExpressionType::COLUMN_REF) {
+				throw InternalException("Unexpected child of pivot source - not a ColumnRef");
+			}
+			auto &columnref = (ColumnRefExpression &)*entry;
+			if (handled_columns.find(columnref.GetColumnName()) == handled_columns.end()) {
+				// not handled - add to grouping set
+				subquery_stage1->groups.group_expressions.push_back(
+				    make_uniq<ConstantExpression>(Value::INTEGER(subquery_stage1->select_list.size() + 1)));
+				subquery_stage1->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_stage1->groups.group_expressions.push_back(
+			    make_uniq<ConstantExpression>(Value::INTEGER(subquery_stage1->select_list.size() + 1)));
+			subquery_stage1->select_list.push_back(make_uniq<ColumnRefExpression>(row));
+		}
+	}
+	idx_t group_count = 0;
+	for (auto &expr : subquery_stage1->select_list) {
+		bind_state.group_names.push_back(expr->GetName());
+		if (expr->alias.empty()) {
+			expr->alias = "__internal_pivot_group" + std::to_string(++group_count);
+		}
+		bind_state.internal_group_names.push_back(expr->alias);
+	}
+	// group by all of the pivot values
+	idx_t pivot_count = 0;
+	for (auto &pivot_column : ref.pivots) {
+		for (auto &pivot_expr : pivot_column.pivot_expressions) {
+			if (pivot_expr->alias.empty()) {
+				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->select_list.push_back(std::move(pivot_expr));
+			pivot_expr = make_uniq<ColumnRefExpression>(std::move(pivot_alias));
+		}
+	}
+	idx_t aggregate_count = 0;
+	// finally add the aggregates
+	for (auto &aggregate : ref.aggregates) {
+		auto aggregate_alias = "__internal_pivot_aggregate" + std::to_string(++aggregate_count);
+		bind_state.aggregate_names.push_back(aggregate->alias);
+		bind_state.internal_aggregate_names.push_back(aggregate_alias);
+		aggregate->alias = std::move(aggregate_alias);
+		subquery_stage1->select_list.push_back(std::move(aggregate));
+	}
+	return subquery_stage1;
+}
+
+static unique_ptr<SelectNode> PivotListAggregate(PivotBindState &bind_state, PivotRef &ref,
+                                                 unique_ptr<SelectNode> subquery_stage1) {
+	auto subquery_stage2 = make_uniq<SelectNode>();
+	// wrap the subquery of stage 1
+	auto subquery_select = make_uniq<SelectStatement>();
+	subquery_select->node = std::move(subquery_stage1);
+	auto subquery_ref = make_uniq<SubqueryRef>(std::move(subquery_select));
+
+	// 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)));
+		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));
+	}
+
+	// construct the list aggregates
+	for (idx_t aggr = 0; aggr < bind_state.internal_aggregate_names.size(); aggr++) {
+		auto colref = make_uniq<ColumnRefExpression>(bind_state.internal_aggregate_names[aggr]);
+		vector<unique_ptr<ParsedExpression>> list_children;
+		list_children.push_back(std::move(colref));
+		auto aggregate = make_uniq<FunctionExpression>("list", std::move(list_children));
+		aggregate->alias = bind_state.internal_aggregate_names[aggr];
+		subquery_stage2->select_list.push_back(std::move(aggregate));
+	}
+	// construct the pivot list
+	auto pivot_name = "__internal_pivot_name";
+	unique_ptr<ParsedExpression> expr;
+	for (auto &pivot : ref.pivots) {
+		for (auto &pivot_expr : pivot.pivot_expressions) {
+			// coalesce(pivot::VARCHAR, 'NULL')
+			auto cast = make_uniq<CastExpression>(LogicalType::VARCHAR, std::move(pivot_expr));
+			vector<unique_ptr<ParsedExpression>> coalesce_children;
+			coalesce_children.push_back(std::move(cast));
+			coalesce_children.push_back(make_uniq<ConstantExpression>(Value("NULL")));
+			auto coalesce =
+			    make_uniq<OperatorExpression>(ExpressionType::OPERATOR_COALESCE, std::move(coalesce_children));
+
+			if (!expr) {
+				expr = std::move(coalesce);
+			} else {
+				// string concat
+				vector<unique_ptr<ParsedExpression>> concat_children;
+				concat_children.push_back(std::move(expr));
+				concat_children.push_back(make_uniq<ConstantExpression>(Value("_")));
+				concat_children.push_back(std::move(coalesce));
+				auto concat = make_uniq<FunctionExpression>("concat", std::move(concat_children));
+				expr = std::move(concat);
+			}
+		}
+	}
+	// list(coalesce)
+	vector<unique_ptr<ParsedExpression>> list_children;
+	list_children.push_back(std::move(expr));
+	auto aggregate = make_uniq<FunctionExpression>("list", std::move(list_children));
+
+	aggregate->alias = pivot_name;
+	subquery_stage2->select_list.push_back(std::move(aggregate));
+
+	subquery_stage2->from_table = std::move(subquery_ref);
+	return subquery_stage2;
+}
+
+static unique_ptr<SelectNode> PivotFinalOperator(PivotBindState &bind_state, PivotRef &ref,
+                                                 unique_ptr<SelectNode> subquery,
+                                                 vector<PivotValueElement> pivot_values) {
+	auto final_pivot_operator = make_uniq<SelectNode>();
+	// wrap the subquery of stage 1
+	auto subquery_select = make_uniq<SelectStatement>();
+	subquery_select->node = std::move(subquery);
+	auto subquery_ref = make_uniq<SubqueryRef>(std::move(subquery_select));
+
+	auto bound_pivot = make_uniq<PivotRef>();
+	bound_pivot->bound_pivot_values = std::move(pivot_values);
+	bound_pivot->bound_group_names = std::move(bind_state.group_names);
+	bound_pivot->bound_aggregate_names = std::move(bind_state.aggregate_names);
+	bound_pivot->source = std::move(subquery_ref);
+
+	final_pivot_operator->select_list.push_back(make_uniq<StarExpression>());
+	final_pivot_operator->from_table = std::move(bound_pivot);
+	return final_pivot_operator;
+}
+
+void ExtractPivotAggregates(BoundTableRef &node, vector<unique_ptr<Expression>> &aggregates) {
+	if (node.type != TableReferenceType::SUBQUERY) {
+		throw InternalException("Pivot - Expected a subquery");
+	}
+	auto &subq = node.Cast<BoundSubqueryRef>();
+	if (subq.subquery->type != QueryNodeType::SELECT_NODE) {
+		throw InternalException("Pivot - Expected a select node");
+	}
+	auto &select = subq.subquery->Cast<BoundSelectNode>();
+	if (select.from_table->type != TableReferenceType::SUBQUERY) {
+		throw InternalException("Pivot - Expected another subquery");
+	}
+	auto &subq2 = select.from_table->Cast<BoundSubqueryRef>();
+	if (subq2.subquery->type != QueryNodeType::SELECT_NODE) {
+		throw InternalException("Pivot - Expected another select node");
+	}
+	auto &select2 = subq2.subquery->Cast<BoundSelectNode>();
+	for (auto &aggr : select2.aggregates) {
+		aggregates.push_back(aggr->Copy());
+	}
+}
+
+unique_ptr<BoundTableRef> Binder::BindBoundPivot(PivotRef &ref) {
+	// bind the child table in a child binder
+	auto result = make_uniq<BoundPivotRef>();
+	result->bind_index = GenerateTableIndex();
+	result->child_binder = Binder::CreateBinder(context, this);
+	result->child = result->child_binder->Bind(*ref.source);
+
+	auto &aggregates = result->bound_pivot.aggregates;
+	ExtractPivotAggregates(*result->child, aggregates);
+	if (aggregates.size() != ref.bound_aggregate_names.size()) {
+		throw InternalException("Pivot - aggregate count mismatch");
+	}
+
+	vector<string> child_names;
+	vector<LogicalType> child_types;
+	result->child_binder->bind_context.GetTypesAndNames(child_names, child_types);
+
+	vector<string> names;
+	vector<LogicalType> types;
+	// emit the groups
+	for (idx_t i = 0; i < ref.bound_group_names.size(); i++) {
+		names.push_back(ref.bound_group_names[i]);
+		types.push_back(child_types[i]);
+	}
+	// emit the pivot columns
+	for (auto &pivot_value : ref.bound_pivot_values) {
+		for (idx_t aggr_idx = 0; aggr_idx < ref.bound_aggregate_names.size(); aggr_idx++) {
+			auto &aggr = aggregates[aggr_idx];
+			auto &aggr_name = ref.bound_aggregate_names[aggr_idx];
+			auto name = pivot_value.name;
+			if (aggregates.size() > 1 || !aggr_name.empty()) {
+				// if there are multiple aggregates specified we add the name of the aggregate as well
+				name += "_" + (aggr_name.empty() ? aggr->GetName() : aggr_name);
+			}
+			string pivot_str;
+			for (auto &value : pivot_value.values) {
+				auto str = value.ToString();
+				if (pivot_str.empty()) {
+					pivot_str = std::move(str);
+				} else {
+					pivot_str += "_" + str;
+				}
+			}
+			result->bound_pivot.pivot_values.push_back(std::move(pivot_str));
+			names.push_back(std::move(name));
+			types.push_back(aggr->return_type);
+		}
+	}
+	result->bound_pivot.group_count = ref.bound_group_names.size();
+	result->bound_pivot.types = types;
+	auto subquery_alias = ref.alias.empty() ? "__unnamed_pivot" : ref.alias;
+	bind_context.AddGenericBinding(result->bind_index, subquery_alias, names, types);
+	MoveCorrelatedExpressions(*result->child_binder);
+	return std::move(result);
+}
+
 unique_ptr<SelectNode> Binder::BindPivot(PivotRef &ref, vector<unique_ptr<ParsedExpression>> all_columns) {
-	const static idx_t PIVOT_EXPRESSION_LIMIT = 10000;
 	// keep track of the columns by which we pivot/aggregate
 	// any columns which are not pivoted/aggregated on are added to the GROUP BY clause
 	case_insensitive_set_t handled_columns;
@@ -103,8 +315,6 @@ unique_ptr<SelectNode> Binder::BindPivot(PivotRef &ref, vector<unique_ptr<Parsed
 	}
 	value_set_t pivots;
 
-	// now handle the pivots
-	auto select_node = make_uniq<SelectNode>();
 	// first add all pivots to the set of handled columns, and check for duplicates
 	idx_t total_pivots = 1;
 	for (auto &pivot : ref.pivots) {
@@ -150,42 +360,41 @@ unique_ptr<SelectNode> Binder::BindPivot(PivotRef &ref, vector<unique_ptr<Parsed
 			pivots.insert(val);
 		}
 	}
-	if (total_pivots >= PIVOT_EXPRESSION_LIMIT) {
-		throw BinderException("Pivot column limit of %llu exceeded", PIVOT_EXPRESSION_LIMIT);
+	auto pivot_limit = ClientConfig::GetConfig(context).pivot_limit;
+	if (total_pivots >= pivot_limit) {
+		throw BinderException("Pivot column limit of %llu exceeded. Use SET pivot_limit=X to increase the limit.",
+		                      ClientConfig::GetConfig(context).pivot_limit);
 	}
-	// now construct the actual aggregates
-	// note that we construct a cross-product of all pivots
-	// we do this recursively
-	vector<unique_ptr<ParsedExpression>> pivot_expressions;
-	ConstructPivots(ref, 0, pivot_expressions);
 
-	if (ref.groups.empty()) {
-		// if rows are not specified any columns that are not pivoted/aggregated on are added to the GROUP BY clause
-		for (auto &entry : all_columns) {
-			if (entry->type != ExpressionType::COLUMN_REF) {
-				throw InternalException("Unexpected child of pivot source - not a ColumnRef");
-			}
-			auto &columnref = (ColumnRefExpression &)*entry;
-			if (handled_columns.find(columnref.GetColumnName()) == handled_columns.end()) {
-				// not handled - add to grouping set
-				select_node->groups.group_expressions.push_back(
-				    make_uniq<ConstantExpression>(Value::INTEGER(select_node->select_list.size() + 1)));
-				select_node->select_list.push_back(std::move(entry));
-			}
-		}
-	} else {
-		// if rows are specified only the columns mentioned in rows are added as groups
-		for (auto &row : ref.groups) {
-			select_node->groups.group_expressions.push_back(
-			    make_uniq<ConstantExpression>(Value::INTEGER(select_node->select_list.size() + 1)));
-			select_node->select_list.push_back(make_uniq<ColumnRefExpression>(row));
-		}
-	}
-	// add the pivot expressions to the select list
-	for (auto &pivot_expr : pivot_expressions) {
-		select_node->select_list.push_back(std::move(pivot_expr));
-	}
-	return select_node;
+	// construct the required pivot values recursively
+	vector<PivotValueElement> pivot_values;
+	ConstructPivots(ref, pivot_values);
+
+	// pivots have three components
+	// - the pivots (i.e. future column names)
+	// - the groups (i.e. the future row names
+	// - the aggregates (i.e. the values of the pivot columns)
+
+	// executing a pivot statement happens in three stages
+	// 1) execute the query "SELECT {groups}, {pivots}, {aggregates} FROM {from_clause} GROUP BY {groups}, {pivots}
+	// this computes all values that are required in the final result, but not yet in the correct orientation
+	// 2) execute the query "SELECT {groups}, LIST({pivots}), LIST({aggregates}) FROM [Q1] GROUP BY {groups}
+	// this pushes all pivots and aggregates that belong to a specific group together in an aligned manner
+	// 3) push a PIVOT operator, that performs the actual pivoting of the values into the different columns
+
+	PivotBindState bind_state;
+	// Pivot Stage 1
+	// SELECT {groups}, {pivots}, {aggregates} FROM {from_clause} GROUP BY {groups}, {pivots}
+	auto subquery_stage1 = PivotInitialAggregate(bind_state, ref, std::move(all_columns), handled_columns);
+
+	// Pivot stage 2
+	// SELECT {groups}, LIST({pivots}), LIST({aggregates}) FROM [Q1] GROUP BY {groups}
+	auto subquery_stage2 = PivotListAggregate(bind_state, ref, std::move(subquery_stage1));
+
+	// Pivot stage 3
+	// construct the final pivot operator
+	auto pivot_node = PivotFinalOperator(bind_state, ref, std::move(subquery_stage2), std::move(pivot_values));
+	return pivot_node;
 }
 
 unique_ptr<SelectNode> Binder::BindUnpivot(Binder &child_binder, PivotRef &ref,
@@ -196,6 +405,7 @@ unique_ptr<SelectNode> Binder::BindUnpivot(Binder &child_binder, PivotRef &ref,
 
 	unique_ptr<ParsedExpression> expr;
 	auto select_node = make_uniq<SelectNode>();
+	select_node->from_table = std::move(ref.source);
 
 	// handle the pivot
 	auto &unpivot = ref.pivots[0];
@@ -212,7 +422,7 @@ unique_ptr<SelectNode> Binder::BindUnpivot(Binder &child_binder, PivotRef &ref,
 				if (col->type != ExpressionType::COLUMN_REF) {
 					throw InternalException("Unexpected child of unpivot star - not a ColumnRef");
 				}
-				auto &columnref = (ColumnRefExpression &)*col;
+				auto &columnref = col->Cast<ColumnRefExpression>();
 				PivotColumnEntry new_entry;
 				new_entry.values.emplace_back(columnref.GetColumnName());
 				new_entry.alias = columnref.GetColumnName();
@@ -236,7 +446,7 @@ unique_ptr<SelectNode> Binder::BindUnpivot(Binder &child_binder, PivotRef &ref,
 		if (col_expr->type != ExpressionType::COLUMN_REF) {
 			throw InternalException("Unexpected child of pivot source - not a ColumnRef");
 		}
-		auto &columnref = (ColumnRefExpression &)*col_expr;
+		auto &columnref = col_expr->Cast<ColumnRefExpression>();
 		auto &column_name = columnref.GetColumnName();
 		auto entry = handled_columns.find(column_name);
 		if (entry == handled_columns.end()) {
@@ -269,6 +479,14 @@ 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()) {
+			throw BinderException(
+			    "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());
+		}
+	}
+
 	for (idx_t v_idx = 0; v_idx < unpivot.entries[0].values.size(); v_idx++) {
 		vector<unique_ptr<ParsedExpression>> expressions;
 		expressions.reserve(unpivot.entries.size());
@@ -319,32 +537,39 @@ unique_ptr<BoundTableRef> Binder::Bind(PivotRef &ref) {
 	if (!ref.source) {
 		throw InternalException("Pivot without a source!?");
 	}
+	if (!ref.bound_pivot_values.empty() || !ref.bound_group_names.empty() || !ref.bound_aggregate_names.empty()) {
+		// bound pivot
+		return BindBoundPivot(ref);
+	}
 
 	// bind the source of the pivot
-	auto child_binder = Binder::CreateBinder(context, this);
-	auto from_table = child_binder->Bind(*ref.source);
+	// we need to do this to be able to expand star expressions
+	auto copied_source = ref.source->Copy();
+	auto star_binder = Binder::CreateBinder(context, this);
+	star_binder->Bind(*copied_source);
 
 	// figure out the set of column names that are in the source of the pivot
 	vector<unique_ptr<ParsedExpression>> all_columns;
-	child_binder->ExpandStarExpression(make_uniq<StarExpression>(), all_columns);
+	star_binder->ExpandStarExpression(make_uniq<StarExpression>(), all_columns);
 
 	unique_ptr<SelectNode> select_node;
 	unique_ptr<ParsedExpression> where_clause;
 	if (!ref.aggregates.empty()) {
 		select_node = BindPivot(ref, std::move(all_columns));
 	} else {
-		select_node = BindUnpivot(*child_binder, ref, std::move(all_columns), where_clause);
+		select_node = BindUnpivot(*star_binder, ref, std::move(all_columns), where_clause);
 	}
 	// bind the generated select node
-	auto bound_select_node = child_binder->BindSelectNode(*select_node, std::move(from_table));
+	auto child_binder = Binder::CreateBinder(context, this);
+	auto bound_select_node = child_binder->BindNode(*select_node);
 	auto root_index = bound_select_node->GetRootIndex();
 	BoundQueryNode *bound_select_ptr = bound_select_node.get();
 
 	unique_ptr<BoundTableRef> result;
 	MoveCorrelatedExpressions(*child_binder);
 	result = make_uniq<BoundSubqueryRef>(std::move(child_binder), std::move(bound_select_node));
-	auto alias = ref.alias.empty() ? "__unnamed_pivot" : ref.alias;
-	SubqueryRef subquery_ref(nullptr, alias);
+	auto subquery_alias = ref.alias.empty() ? "__unnamed_pivot" : ref.alias;
+	SubqueryRef subquery_ref(nullptr, subquery_alias);
 	subquery_ref.column_name_alias = std::move(ref.column_name_alias);
 	if (where_clause) {
 		// if a WHERE clause was provided - bind a subquery holding the WHERE clause

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

@@ -13,14 +13,14 @@ unique_ptr<BoundTableRef> Binder::Bind(SubqueryRef &ref, CommonTableExpressionIn
 	binder->alias = ref.alias.empty() ? "unnamed_subquery" : ref.alias;
 	auto subquery = binder->BindNode(*ref.subquery->node);
 	idx_t bind_index = subquery->GetRootIndex();
-	string alias;
+	string subquery_alias;
 	if (ref.alias.empty()) {
-		alias = "unnamed_subquery" + to_string(bind_index);
+		subquery_alias = "unnamed_subquery" + to_string(bind_index);
 	} else {
-		alias = ref.alias;
+		subquery_alias = ref.alias;
 	}
 	auto result = make_uniq<BoundSubqueryRef>(std::move(binder), std::move(subquery));
-	bind_context.AddSubquery(bind_index, alias, ref, *result->subquery);
+	bind_context.AddSubquery(bind_index, subquery_alias, ref, *result->subquery);
 	MoveCorrelatedExpressions(*result->binder);
 	return std::move(result);
 }

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

@@ -34,7 +34,7 @@ bool Binder::BindTableInTableOutFunction(vector<unique_ptr<ParsedExpression>> &e
 	unique_ptr<QueryNode> subquery_node;
 	if (expressions.size() == 1 && expressions[0]->type == ExpressionType::SUBQUERY) {
 		// general case: argument is a subquery, bind it as part of the node
-		auto &se = (SubqueryExpression &)*expressions[0];
+		auto &se = expressions[0]->Cast<SubqueryExpression>();
 		subquery_node = std::move(se.subquery->node);
 	} else {
 		// special case: non-subquery parameter to table-in table-out function
@@ -67,9 +67,9 @@ bool Binder::BindTableFunctionParameters(TableFunctionCatalogEntry &table_functi
 		// hack to make named parameters work
 		if (child->type == ExpressionType::COMPARE_EQUAL) {
 			// comparison, check if the LHS is a columnref
-			auto &comp = (ComparisonExpression &)*child;
+			auto &comp = child->Cast<ComparisonExpression>();
 			if (comp.left->type == ExpressionType::COLUMN_REF) {
-				auto &colref = (ColumnRefExpression &)*comp.left;
+				auto &colref = comp.left->Cast<ColumnRefExpression>();
 				if (!colref.IsQualified()) {
 					parameter_name = colref.GetColumnName();
 					child = std::move(comp.right);
@@ -82,7 +82,7 @@ bool Binder::BindTableFunctionParameters(TableFunctionCatalogEntry &table_functi
 				return false;
 			}
 			auto binder = Binder::CreateBinder(this->context, this, true);
-			auto &se = (SubqueryExpression &)*child;
+			auto &se = child->Cast<SubqueryExpression>();
 			auto node = binder->BindNode(*se.subquery->node);
 			subquery = make_uniq<BoundSubqueryRef>(std::move(binder), std::move(node));
 			seen_subquery = true;
@@ -194,19 +194,19 @@ unique_ptr<BoundTableRef> Binder::Bind(TableFunctionRef &ref) {
 	QueryErrorContext error_context(root_statement, ref.query_location);
 
 	D_ASSERT(ref.function->type == ExpressionType::FUNCTION);
-	auto fexpr = (FunctionExpression *)ref.function.get();
+	auto &fexpr = ref.function->Cast<FunctionExpression>();
 
 	TableFunctionCatalogEntry *function = nullptr;
 
 	// fetch the function from the catalog
-	auto func_catalog = Catalog::GetEntry(context, CatalogType::TABLE_FUNCTION_ENTRY, fexpr->catalog, fexpr->schema,
-	                                      fexpr->function_name, false, error_context);
+	auto func_catalog = Catalog::GetEntry(context, CatalogType::TABLE_FUNCTION_ENTRY, fexpr.catalog, fexpr.schema,
+	                                      fexpr.function_name, false, error_context);
 
 	if (func_catalog->type == CatalogType::TABLE_FUNCTION_ENTRY) {
 		function = (TableFunctionCatalogEntry *)func_catalog;
 	} else if (func_catalog->type == CatalogType::TABLE_MACRO_ENTRY) {
 		auto macro_func = (TableMacroCatalogEntry *)func_catalog;
-		auto query_node = BindTableMacro(*fexpr, macro_func, 0);
+		auto query_node = BindTableMacro(fexpr, macro_func, 0);
 		D_ASSERT(query_node);
 
 		auto binder = Binder::CreateBinder(context, this);
@@ -232,7 +232,7 @@ unique_ptr<BoundTableRef> Binder::Bind(TableFunctionRef &ref) {
 	named_parameter_map_t named_parameters;
 	unique_ptr<BoundSubqueryRef> subquery;
 	string error;
-	if (!BindTableFunctionParameters(*function, fexpr->children, arguments, parameters, named_parameters, subquery,
+	if (!BindTableFunctionParameters(*function, fexpr.children, arguments, parameters, named_parameters, subquery,
 	                                 error)) {
 		throw BinderException(FormatError(ref, error));
 	}
@@ -264,7 +264,7 @@ unique_ptr<BoundTableRef> Binder::Bind(TableFunctionRef &ref) {
 		input_table_types = subquery->subquery->types;
 		input_table_names = subquery->subquery->names;
 	}
-	auto get = BindTableFunctionInternal(table_function, ref.alias.empty() ? fexpr->function_name : ref.alias,
+	auto get = BindTableFunctionInternal(table_function, ref.alias.empty() ? fexpr.function_name : ref.alias,
 	                                     std::move(parameters), std::move(named_parameters),
 	                                     std::move(input_table_types), std::move(input_table_names),
 	                                     ref.column_name_alias, std::move(ref.external_dependency));

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

@@ -22,7 +22,7 @@ namespace duckdb {
 static bool CreateJoinCondition(Expression &expr, const unordered_set<idx_t> &left_bindings,
                                 const unordered_set<idx_t> &right_bindings, vector<JoinCondition> &conditions) {
 	// comparison
-	auto &comparison = (BoundComparisonExpression &)expr;
+	auto &comparison = expr.Cast<BoundComparisonExpression>();
 	auto left_side = JoinSide::GetJoinSide(*comparison.left, left_bindings, right_bindings);
 	auto right_side = JoinSide::GetJoinSide(*comparison.right, left_bindings, right_bindings);
 	if (left_side != JoinSide::BOTH && right_side != JoinSide::BOTH) {
@@ -64,7 +64,7 @@ void LogicalComparisonJoin::ExtractJoinConditions(JoinType type, unique_ptr<Logi
 					right_child = std::move(filter);
 				}
 				// push the expression into the filter
-				auto &filter = (LogicalFilter &)*right_child;
+				auto &filter = right_child->Cast<LogicalFilter>();
 				filter.expressions.push_back(std::move(expr));
 				continue;
 			}
@@ -202,7 +202,7 @@ unique_ptr<LogicalOperator> LogicalComparisonJoin::CreateJoin(JoinType type, Joi
 
 static bool HasCorrelatedColumns(Expression &expression) {
 	if (expression.type == ExpressionType::BOUND_COLUMN_REF) {
-		auto &colref = (BoundColumnRefExpression &)expression;
+		auto &colref = expression.Cast<BoundColumnRefExpression>();
 		if (colref.depth > 0) {
 			return true;
 		}
@@ -286,7 +286,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundJoinRef &ref) {
 	}
 	for (auto &child : join->children) {
 		if (child->type == LogicalOperatorType::LOGICAL_FILTER) {
-			auto &filter = (LogicalFilter &)*child;
+			auto &filter = child->Cast<LogicalFilter>();
 			for (auto &expr : filter.expressions) {
 				PlanSubqueries(&expr, &filter.children[0]);
 			}
@@ -300,7 +300,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundJoinRef &ref) {
 		// 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
-		auto &comp_join = (LogicalComparisonJoin &)*join;
+		auto &comp_join = join->Cast<LogicalComparisonJoin>();
 		for (idx_t i = 0; i < comp_join.conditions.size(); i++) {
 			PlanSubqueries(&comp_join.conditions[i].left, &comp_join.children[0]);
 			PlanSubqueries(&comp_join.conditions[i].right, &comp_join.children[1]);
@@ -308,7 +308,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundJoinRef &ref) {
 		break;
 	}
 	case LogicalOperatorType::LOGICAL_ANY_JOIN: {
-		auto &any_join = (LogicalAnyJoin &)*join;
+		auto &any_join = join->Cast<LogicalAnyJoin>();
 		// for the any join we just visit the condition
 		if (any_join.condition->HasSubquery()) {
 			throw NotImplementedException("Cannot perform non-inner join on subquery!");

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

@@ -0,0 +1,13 @@
+#include "duckdb/planner/tableref/bound_pivotref.hpp"
+#include "duckdb/planner/operator/logical_pivot.hpp"
+
+namespace duckdb {
+
+unique_ptr<LogicalOperator> Binder::CreatePlan(BoundPivotRef &ref) {
+	auto subquery = ref.child_binder->CreatePlan(*ref.child);
+
+	auto result = make_uniq<LogicalPivot>(ref.bind_index, std::move(subquery), std::move(ref.bound_pivot));
+	return std::move(result);
+}
+
+} // namespace duckdb