duckdb 0.7.2-dev16.0 → 0.7.2-dev314.0

package/src/duckdb/src/parser/transform/tableref/transform_pivot.cpp

@@ -0,0 +1,105 @@
+#include "duckdb/common/exception.hpp"
+#include "duckdb/parser/tableref/pivotref.hpp"
+#include "duckdb/parser/transformer.hpp"
+#include "duckdb/parser/expression/columnref_expression.hpp"
+#include "duckdb/parser/expression/constant_expression.hpp"
+#include "duckdb/parser/expression/function_expression.hpp"
+
+namespace duckdb {
+
+static void TransformPivotInList(unique_ptr<ParsedExpression> &expr, PivotColumnEntry &entry, bool root_entry = true) {
+	if (expr->type == ExpressionType::COLUMN_REF) {
+		auto &colref = (ColumnRefExpression &)*expr;
+		if (colref.IsQualified()) {
+			throw ParserException("PIVOT IN list cannot contain qualified column references");
+		}
+		entry.values.emplace_back(colref.GetColumnName());
+	} else if (expr->type == ExpressionType::VALUE_CONSTANT) {
+		auto &constant_expr = (ConstantExpression &)*expr;
+		entry.values.push_back(std::move(constant_expr.value));
+	} else if (root_entry && expr->type == ExpressionType::FUNCTION) {
+		auto &function = (FunctionExpression &)*expr;
+		if (function.function_name != "row") {
+			throw ParserException("PIVOT IN list must contain columns or lists of columns");
+		}
+		for (auto &child : function.children) {
+			TransformPivotInList(child, entry, false);
+		}
+	} else if (root_entry && expr->type == ExpressionType::STAR) {
+		entry.star_expr = std::move(expr);
+	} else {
+		throw ParserException("PIVOT IN list must contain columns or lists of columns");
+	}
+}
+
+PivotColumn Transformer::TransformPivotColumn(duckdb_libpgquery::PGPivot *pivot) {
+	PivotColumn col;
+	col.names = TransformStringList(pivot->pivot_columns);
+	if (pivot->pivot_value) {
+		for (auto node = pivot->pivot_value->head; node != nullptr; node = node->next) {
+			auto n = (duckdb_libpgquery::PGNode *)node->data.ptr_value;
+			auto expr = TransformExpression(n);
+			PivotColumnEntry entry;
+			entry.alias = expr->alias;
+			TransformPivotInList(expr, entry);
+			col.entries.push_back(std::move(entry));
+		}
+	}
+	if (pivot->pivot_enum) {
+		col.pivot_enum = pivot->pivot_enum;
+	}
+	return col;
+}
+
+vector<PivotColumn> Transformer::TransformPivotList(duckdb_libpgquery::PGList *list) {
+	vector<PivotColumn> result;
+	for (auto node = list->head; node != nullptr; node = node->next) {
+		auto pivot = (duckdb_libpgquery::PGPivot *)node->data.ptr_value;
+		result.push_back(TransformPivotColumn(pivot));
+	}
+	return result;
+}
+
+unique_ptr<TableRef> Transformer::TransformPivot(duckdb_libpgquery::PGPivotExpr *root) {
+	auto result = make_unique<PivotRef>();
+	result->source = TransformTableRefNode(root->source);
+	if (root->aggrs) {
+		TransformExpressionList(*root->aggrs, result->aggregates);
+	}
+	if (root->unpivots) {
+		result->unpivot_names = TransformStringList(root->unpivots);
+	}
+	result->pivots = TransformPivotList(root->pivots);
+	if (root->groups) {
+		result->groups = TransformStringList(root->groups);
+	}
+	for (auto &pivot : result->pivots) {
+		idx_t expected_size;
+		bool is_pivot = result->unpivot_names.empty();
+		if (!result->unpivot_names.empty()) {
+			// unpivot
+			if (pivot.names.size() != 1) {
+				throw ParserException("UNPIVOT requires a single column name for the PIVOT IN clause");
+			}
+			expected_size = pivot.entries[0].values.size();
+		} else {
+			// pivot
+			expected_size = pivot.names.size();
+		}
+		for (auto &entry : pivot.entries) {
+			if (entry.star_expr && is_pivot) {
+				throw ParserException("PIVOT IN list must contain columns or lists of columns - star expressions are "
+				                      "only supported for UNPIVOT");
+			}
+			if (entry.values.size() != expected_size) {
+				throw ParserException("PIVOT IN list - inconsistent amount of rows - expected %d but got %d",
+				                      expected_size, entry.values.size());
+			}
+		}
+	}
+	result->include_nulls = root->include_nulls;
+	result->alias = TransformAlias(root->alias, result->column_name_alias);
+	return std::move(result);
+}
+
+} // namespace duckdb

package/src/duckdb/src/parser/transform/tableref/transform_tableref.cpp

@@ -16,6 +16,8 @@ unique_ptr<TableRef> Transformer::TransformTableRefNode(duckdb_libpgquery::PGNod
 		return TransformRangeSubselect(reinterpret_cast<duckdb_libpgquery::PGRangeSubselect *>(n));
 	case duckdb_libpgquery::T_PGRangeFunction:
 		return TransformRangeFunction(reinterpret_cast<duckdb_libpgquery::PGRangeFunction *>(n));
+	case duckdb_libpgquery::T_PGPivotExpr:
+		return TransformPivot(reinterpret_cast<duckdb_libpgquery::PGPivotExpr *>(n));
 	default:
 		throw NotImplementedException("From Type %d not supported", n->type);
 	}

package/src/duckdb/src/parser/transformer.cpp

@@ -3,6 +3,7 @@
 #include "duckdb/parser/expression/list.hpp"
 #include "duckdb/parser/statement/list.hpp"
 #include "duckdb/parser/tableref/emptytableref.hpp"
+#include "duckdb/parser/query_node/select_node.hpp"
 
 namespace duckdb {
 
@@ -28,12 +29,24 @@ Transformer::Transformer(Transformer *parent)
     : parent(parent), max_expression_depth(parent->max_expression_depth), stack_depth(DConstants::INVALID_INDEX) {
 }
 
+Transformer::~Transformer() {
+}
+
+void Transformer::Clear() {
+	SetParamCount(0);
+	pivot_entries.clear();
+}
+
 bool Transformer::TransformParseTree(duckdb_libpgquery::PGList *tree, vector<unique_ptr<SQLStatement>> &statements) {
 	InitializeStackCheck();
 	for (auto entry = tree->head; entry != nullptr; entry = entry->next) {
-		SetParamCount(0);
-		auto stmt = TransformStatement((duckdb_libpgquery::PGNode *)entry->data.ptr_value);
+		Clear();
+		auto n = (duckdb_libpgquery::PGNode *)entry->data.ptr_value;
+		auto stmt = TransformStatement(n);
 		D_ASSERT(stmt);
+		if (HasPivotEntries()) {
+			stmt = CreatePivotStatement(std::move(stmt));
+		}
 		stmt->n_param = ParamCount();
 		statements.push_back(std::move(stmt));
 	}
@@ -154,7 +167,6 @@ unique_ptr<SQLStatement> Transformer::TransformStatementInternal(duckdb_libpgque
 	default:
 		throw NotImplementedException(NodetypeToString(stmt->type));
 	}
-	return nullptr;
 }
 
 } // namespace duckdb

package/src/duckdb/src/planner/bind_context.cpp

@@ -555,4 +555,20 @@ void BindContext::AddContext(BindContext other) {
 	}
 }
 
+void BindContext::RemoveContext(vector<std::pair<string, duckdb::Binding *>> &other_bindings_list) {
+	for (auto &other_binding : other_bindings_list) {
+		if (bindings.find(other_binding.first) != bindings.end()) {
+			bindings.erase(other_binding.first);
+		}
+	}
+
+	vector<idx_t> delete_list_indexes;
+	for (auto &other_binding : other_bindings_list) {
+		auto it =
+		    std::remove_if(bindings_list.begin(), bindings_list.end(),
+		                   [other_binding](std::pair<string, Binding *> &x) { return x.first == other_binding.first; });
+		bindings_list.erase(it, bindings_list.end());
+	}
+}
+
 } // namespace duckdb

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

@@ -328,6 +328,16 @@ void Binder::ExpandStarExpressions(vector<unique_ptr<ParsedExpression>> &select_
 }
 
 unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
+	D_ASSERT(statement.from_table);
+	// first bind the FROM table statement
+	auto from = std::move(statement.from_table);
+	auto from_table = Bind(*from);
+	return BindSelectNode(statement, std::move(from_table));
+}
+
+unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_ptr<BoundTableRef> from_table) {
+	D_ASSERT(from_table);
+	D_ASSERT(!statement.from_table);
 	auto result = make_unique<BoundSelectNode>();
 	result->projection_index = GenerateTableIndex();
 	result->group_index = GenerateTableIndex();
@@ -337,9 +347,7 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
 	result->unnest_index = GenerateTableIndex();
 	result->prune_index = GenerateTableIndex();
 
-	// first bind the FROM table statement
-	result->from_table = Bind(*statement.from_table);
-
+	result->from_table = std::move(from_table);
 	// bind the sample clause
 	if (statement.sample) {
 		result->sample_options = std::move(statement.sample);

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

@@ -104,7 +104,6 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSelectNode &statement) {
 		PlanSubqueries(&expr, &root);
 	}
 
-	// create the projection
 	auto proj = make_unique<LogicalProjection>(statement.projection_index, std::move(statement.select_list));
 	auto &projection = *proj;
 	proj->AddChild(std::move(root));

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

@@ -467,7 +467,6 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 	BoundStatement result;
 	result.names = {"Count"};
 	result.types = {LogicalType::BIGINT};
-	properties.return_type = StatementReturnType::NOTHING;
 
 	auto catalog_type = stmt.info->type;
 	switch (catalog_type) {
@@ -675,6 +674,7 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 	default:
 		throw Exception("Unrecognized type!");
 	}
+	properties.return_type = StatementReturnType::NOTHING;
 	properties.allow_stream_result = false;
 	return result;
 }

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

@@ -4,6 +4,19 @@
 
 namespace duckdb {
 
+idx_t GetMaxTableIndex(LogicalOperator &op) {
+	idx_t result = 0;
+	for (auto &child : op.children) {
+		auto max_child_index = GetMaxTableIndex(*child);
+		result = MaxValue<idx_t>(result, max_child_index);
+	}
+	auto indexes = op.GetTableIndex();
+	for (auto &index : indexes) {
+		result = MaxValue<idx_t>(result, index);
+	}
+	return result;
+}
+
 BoundStatement Binder::Bind(LogicalPlanStatement &stmt) {
 	BoundStatement result;
 	result.types = stmt.plan->types;
@@ -14,6 +27,10 @@ BoundStatement Binder::Bind(LogicalPlanStatement &stmt) {
 	properties.allow_stream_result = true;
 	properties.return_type = StatementReturnType::QUERY_RESULT; // TODO could also be something else
 
+	if (parent) {
+		throw InternalException("LogicalPlanStatement should be bound in root binder");
+	}
+	bound_tables = GetMaxTableIndex(*result.plan) + 1;
 	return result;
 }
 

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

@@ -7,9 +7,11 @@
 #include "duckdb/parser/expression/constant_expression.hpp"
 #include "duckdb/parser/expression/conjunction_expression.hpp"
 #include "duckdb/parser/expression/bound_expression.hpp"
+#include "duckdb/parser/expression/star_expression.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/case_insensitive_map.hpp"
 #include "duckdb/planner/expression_binder/lateral_binder.hpp"
+#include "duckdb/planner/query_node/bound_select_node.hpp"
 
 namespace duckdb {
 
@@ -253,6 +255,8 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 		}
 	}
 
+	auto right_bindings_list_copy = right_binder.bind_context.GetBindingsList();
+
 	bind_context.AddContext(std::move(left_binder.bind_context));
 	bind_context.AddContext(std::move(right_binder.bind_context));
 	MoveCorrelatedExpressions(left_binder);
@@ -269,6 +273,11 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 		WhereBinder binder(*this, context);
 		result->condition = binder.Bind(ref.condition);
 	}
+
+	if (result->type == JoinType::SEMI || result->type == JoinType::ANTI) {
+		bind_context.RemoveContext(right_bindings_list_copy);
+	}
+
 	return std::move(result);
 }
 

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

@@ -0,0 +1,365 @@
+#include "duckdb/planner/binder.hpp"
+#include "duckdb/parser/tableref/pivotref.hpp"
+#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/columnref_expression.hpp"
+#include "duckdb/parser/expression/comparison_expression.hpp"
+#include "duckdb/parser/expression/conjunction_expression.hpp"
+#include "duckdb/parser/expression/constant_expression.hpp"
+#include "duckdb/parser/expression/function_expression.hpp"
+#include "duckdb/planner/query_node/bound_select_node.hpp"
+#include "duckdb/parser/expression/star_expression.hpp"
+#include "duckdb/common/types/value_map.hpp"
+#include "duckdb/parser/parsed_expression_iterator.hpp"
+#include "duckdb/parser/expression/operator_expression.hpp"
+#include "duckdb/planner/tableref/bound_subqueryref.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()) {
+	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;
+		string name = entry.alias;
+		D_ASSERT(entry.values.size() == pivot.names.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 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));
+			if (expr) {
+				expr = make_unique<ConjunctionExpression>(ExpressionType::CONJUNCTION_AND, std::move(expr),
+				                                          std::move(comp_expr));
+			} else {
+				expr = std::move(comp_expr);
+			}
+			if (entry.alias.empty()) {
+				if (name.empty()) {
+					name = value.ToString();
+				} else {
+					name += "_" + value.ToString();
+				}
+			}
+		}
+		if (!current_name.empty()) {
+			name = current_name + "_" + 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) {
+					// 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));
+			}
+		} else {
+			// need to recurse
+			ConstructPivots(ref, pivot_idx + 1, pivot_expressions, std::move(expr), name);
+		}
+	}
+}
+
+static void ExtractPivotExpressions(ParsedExpression &expr, case_insensitive_set_t &handled_columns) {
+	if (expr.type == ExpressionType::COLUMN_REF) {
+		auto &child_colref = (ColumnRefExpression &)expr;
+		if (child_colref.IsQualified()) {
+			throw BinderException("PIVOT expression cannot contain qualified columns");
+		}
+		handled_columns.insert(child_colref.GetColumnName());
+	}
+	ParsedExpressionIterator::EnumerateChildren(
+	    expr, [&](ParsedExpression &child) { ExtractPivotExpressions(child, handled_columns); });
+}
+
+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;
+	// parse the aggregate, and extract the referenced columns from the aggregate
+	for (auto &aggr : ref.aggregates) {
+		if (aggr->type != ExpressionType::FUNCTION) {
+			throw BinderException(FormatError(*aggr, "Pivot expression must be an aggregate"));
+		}
+		if (aggr->HasSubquery()) {
+			throw BinderException(FormatError(*aggr, "Pivot expression cannot contain subqueries"));
+		}
+		if (aggr->IsWindow()) {
+			throw BinderException(FormatError(*aggr, "Pivot expression cannot contain window functions"));
+		}
+		ExtractPivotExpressions(*aggr, handled_columns);
+	}
+	value_set_t pivots;
+
+	// now handle the pivots
+	auto select_node = make_unique<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) {
+		if (!pivot.pivot_enum.empty()) {
+			auto type = Catalog::GetType(context, INVALID_CATALOG, INVALID_SCHEMA, pivot.pivot_enum);
+			if (type.id() != LogicalTypeId::ENUM) {
+				throw BinderException(
+				    FormatError(ref, StringUtil::Format("Pivot must reference an ENUM type: \"%s\" is of type \"%s\"",
+				                                        pivot.pivot_enum, type.ToString())));
+			}
+			auto enum_size = EnumType::GetSize(type);
+			for (idx_t i = 0; i < enum_size; i++) {
+				auto enum_value = EnumType::GetValue(Value::ENUM(i, type));
+				PivotColumnEntry entry;
+				entry.values.emplace_back(enum_value);
+				entry.alias = std::move(enum_value);
+				pivot.entries.push_back(std::move(entry));
+			}
+		}
+		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);
+		}
+		value_set_t pivots;
+		for (auto &entry : pivot.entries) {
+			D_ASSERT(!entry.star_expr);
+			Value val;
+			if (entry.values.size() == 1) {
+				val = entry.values[0];
+			} else {
+				val = Value::LIST(LogicalType::VARCHAR, entry.values);
+			}
+			if (pivots.find(val) != pivots.end()) {
+				throw BinderException(FormatError(
+				    ref, StringUtil::Format("The value \"%s\" was specified multiple times in the IN clause",
+				                            val.ToString())));
+			}
+			if (entry.values.size() != pivot.names.size()) {
+				throw ParserException("PIVOT IN list - inconsistent amount of rows - expected %d but got %d",
+				                      pivot.names.size(), entry.values.size());
+			}
+			pivots.insert(val);
+		}
+	}
+	if (total_pivots >= PIVOT_EXPRESSION_LIMIT) {
+		throw BinderException("Pivot column limit of %llu exceeded", PIVOT_EXPRESSION_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_unique<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_unique<ConstantExpression>(Value::INTEGER(select_node->select_list.size() + 1)));
+			select_node->select_list.push_back(make_unique<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;
+}
+
+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_unique<SelectNode>();
+
+	// handle the pivot
+	auto &unpivot = ref.pivots[0];
+
+	// handle star expressions in any entries
+	vector<PivotColumnEntry> new_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 = (ColumnRefExpression &)*col;
+				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));
+		}
+	}
+	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 &col_expr : all_columns) {
+		if (col_expr->type != ExpressionType::COLUMN_REF) {
+			throw InternalException("Unexpected child of pivot source - not a ColumnRef");
+		}
+		auto &columnref = (ColumnRefExpression &)*col_expr;
+		auto &column_name = columnref.GetColumnName();
+		auto entry = handled_columns.find(column_name);
+		if (entry == handled_columns.end()) {
+			// not handled - add to the set of regularly selected columns
+			select_node->select_list.push_back(std::move(col_expr));
+		} else {
+			name_map[column_name] = column_name;
+			handled_columns.erase(entry);
+		}
+	}
+	if (!handled_columns.empty()) {
+		for (auto &entry : handled_columns) {
+			throw BinderException("Column \"%s\" referenced in UNPIVOT but no matching entry was found in the table",
+			                      entry);
+		}
+	}
+	vector<Value> unpivot_names;
+	for (auto &entry : unpivot.entries) {
+		string generated_name;
+		for (auto &val : entry.values) {
+			auto name_entry = name_map.find(val.ToString());
+			if (name_entry == name_map.end()) {
+				throw InternalException("Unpivot - could not find column name in name map");
+			}
+			if (!generated_name.empty()) {
+				generated_name += "_";
+			}
+			generated_name += name_entry->second;
+		}
+		unpivot_names.emplace_back(!entry.alias.empty() ? entry.alias : generated_name);
+	}
+	vector<vector<unique_ptr<ParsedExpression>>> unpivot_expressions;
+	for (idx_t v_idx = 0; v_idx < unpivot.entries[0].values.size(); v_idx++) {
+		vector<unique_ptr<ParsedExpression>> expressions;
+		for (auto &entry : unpivot.entries) {
+			expressions.push_back(make_unique<ColumnRefExpression>(entry.values[v_idx].ToString()));
+		}
+		unpivot_expressions.push_back(std::move(expressions));
+	}
+
+	// construct the UNNEST expression for the set of names (constant)
+	auto unpivot_list = Value::LIST(LogicalType::VARCHAR, std::move(unpivot_names));
+	auto unpivot_name_expr = make_unique<ConstantExpression>(std::move(unpivot_list));
+	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];
+	select_node->select_list.push_back(std::move(unnest_name_expr));
+
+	// construct the UNNEST expression for the set of unpivoted columns
+	if (ref.unpivot_names.size() != unpivot_expressions.size()) {
+		throw BinderException("UNPIVOT name count mismatch - got %d names but %d expressions", ref.unpivot_names.size(),
+		                      unpivot_expressions.size());
+	}
+	for (idx_t i = 0; i < unpivot_expressions.size(); i++) {
+		auto list_expr = make_unique<FunctionExpression>("list_value", 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_unique<FunctionExpression>("unnest", std::move(unnest_val_children));
+		auto unnest_name = i < ref.column_name_alias.size() ? ref.column_name_alias[i] : ref.unpivot_names[i];
+		unnest_val_expr->alias = unnest_name;
+		select_node->select_list.push_back(std::move(unnest_val_expr));
+		if (!ref.include_nulls) {
+			// if we are running with EXCLUDE NULLS we need to add an IS NOT NULL filter
+			auto colref = make_unique<ColumnRefExpression>(unnest_name);
+			auto filter = make_unique<OperatorExpression>(ExpressionType::OPERATOR_IS_NOT_NULL, std::move(colref));
+			if (where_clause) {
+				where_clause = make_unique<ConjunctionExpression>(ExpressionType::CONJUNCTION_AND,
+				                                                  std::move(where_clause), std::move(filter));
+			} else {
+				where_clause = std::move(filter);
+			}
+		}
+	}
+	return select_node;
+}
+
+unique_ptr<BoundTableRef> Binder::Bind(PivotRef &ref) {
+	if (!ref.source) {
+		throw InternalException("Pivot without a source!?");
+	}
+
+	// bind the source of the pivot
+	auto child_binder = Binder::CreateBinder(context, this);
+	auto from_table = child_binder->Bind(*ref.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_unique<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);
+	}
+	// bind the generated select node
+	auto bound_select_node = child_binder->BindSelectNode(*select_node, std::move(from_table));
+	auto root_index = bound_select_node->GetRootIndex();
+	BoundQueryNode *bound_select_ptr = bound_select_node.get();
+
+	unique_ptr<BoundTableRef> result;
+	MoveCorrelatedExpressions(*child_binder);
+	result = make_unique<BoundSubqueryRef>(std::move(child_binder), std::move(bound_select_node));
+	auto alias = ref.alias.empty() ? "__unnamed_pivot" : ref.alias;
+	SubqueryRef subquery_ref(nullptr, 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
+		// we need to bind a new subquery here because the WHERE clause has to be applied AFTER the unnest
+		child_binder = Binder::CreateBinder(context, this);
+		child_binder->bind_context.AddSubquery(root_index, subquery_ref.alias, subquery_ref, *bound_select_ptr);
+		auto where_query = make_unique<SelectNode>();
+		where_query->select_list.push_back(make_unique<StarExpression>());
+		where_query->where_clause = std::move(where_clause);
+		bound_select_node = child_binder->BindSelectNode(*where_query, std::move(result));
+		bound_select_ptr = bound_select_node.get();
+		root_index = bound_select_node->GetRootIndex();
+		result = make_unique<BoundSubqueryRef>(std::move(child_binder), std::move(bound_select_node));
+	}
+	bind_context.AddSubquery(root_index, subquery_ref.alias, subquery_ref, *bound_select_ptr);
+	return result;
+}
+
+} // namespace duckdb