duckdb 0.7.2-dev12.0 → 0.7.2-dev1244.0

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

@@ -3,6 +3,7 @@
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/constraints/list.hpp"
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
+#include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/planner/expression_binder/check_binder.hpp"
 #include "duckdb/planner/expression_binder/constant_binder.hpp"
 #include "duckdb/planner/parsed_data/bound_create_table_info.hpp"
@@ -119,9 +120,15 @@ static void BindConstraints(Binder &binder, BoundCreateTableInfo &info) {
 			         fk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE);
 			physical_index_set_t fk_key_set, pk_key_set;
 			for (idx_t i = 0; i < fk.info.pk_keys.size(); i++) {
+				if (pk_key_set.find(fk.info.pk_keys[i]) != pk_key_set.end()) {
+					throw BinderException("Duplicate primary key referenced in FOREIGN KEY constraint");
+				}
 				pk_key_set.insert(fk.info.pk_keys[i]);
 			}
 			for (idx_t i = 0; i < fk.info.fk_keys.size(); i++) {
+				if (fk_key_set.find(fk.info.fk_keys[i]) != fk_key_set.end()) {
+					throw BinderException("Duplicate key specified in FOREIGN KEY constraint");
+				}
 				fk_key_set.insert(fk.info.fk_keys[i]);
 			}
 			info.bound_constraints.push_back(
@@ -292,6 +299,7 @@ unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateIn
 			result->dependencies.AddDependency(type_dependency);
 		}
 	}
+	result->dependencies.VerifyDependencies(schema->catalog, result->Base().table);
 	properties.allow_stream_result = false;
 	return result;
 }
@@ -303,9 +311,10 @@ unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateIn
 }
 
 vector<unique_ptr<Expression>> Binder::BindCreateIndexExpressions(TableCatalogEntry *table, CreateIndexInfo *info) {
-	vector<unique_ptr<Expression>> expressions;
 
 	auto index_binder = IndexBinder(*this, this->context, table, info);
+	vector<unique_ptr<Expression>> expressions;
+	expressions.reserve(info->expressions.size());
 	for (auto &expr : info->expressions) {
 		expressions.push_back(index_binder.Bind(expr));
 	}

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

@@ -83,7 +83,7 @@ BoundStatement Binder::Bind(DeleteStatement &stmt) {
 		del->table_index = update_table_index;
 
 		unique_ptr<LogicalOperator> del_as_logicaloperator = std::move(del);
-		return BindReturning(std::move(stmt.returning_list), table, update_table_index,
+		return BindReturning(std::move(stmt.returning_list), table, stmt.table->alias, update_table_index,
 		                     std::move(del_as_logicaloperator), std::move(result));
 	}
 	result.plan = std::move(del);

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

@@ -335,6 +335,16 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl
 		ReplaceColumnBindings(*insert.on_conflict_condition, table_index, projection_index);
 	}
 
+	if (insert.action_type == OnConflictAction::REPLACE) {
+		D_ASSERT(on_conflict.set_info == nullptr);
+		on_conflict.set_info = CreateSetInfoForReplace(table, stmt);
+		insert.action_type = OnConflictAction::UPDATE;
+	}
+	if (on_conflict.set_info && on_conflict.set_info->columns.empty()) {
+		// if we are doing INSERT OR REPLACE on a table with no columns outside of the primary key column
+		// convert to INSERT OR IGNORE
+		insert.action_type = OnConflictAction::NOTHING;
+	}
 	if (insert.action_type == OnConflictAction::NOTHING) {
 		if (!insert.on_conflict_condition) {
 			return;
@@ -346,15 +356,9 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl
 		insert.columns_to_fetch = table_binding->GetBoundColumnIds();
 		return;
 	}
-	if (insert.action_type == OnConflictAction::REPLACE) {
-		D_ASSERT(on_conflict.set_info == nullptr);
-		on_conflict.set_info = CreateSetInfoForReplace(table, stmt);
-		insert.action_type = OnConflictAction::UPDATE;
-	}
 
 	D_ASSERT(on_conflict.set_info);
 	auto &set_info = *on_conflict.set_info;
-	D_ASSERT(!set_info.columns.empty());
 	D_ASSERT(set_info.columns.size() == set_info.expressions.size());
 
 	if (set_info.condition) {
@@ -505,8 +509,8 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 		insert->table_index = insert_table_index;
 		unique_ptr<LogicalOperator> index_as_logicaloperator = std::move(insert);
 
-		return BindReturning(std::move(stmt.returning_list), table, insert_table_index,
-		                     std::move(index_as_logicaloperator), std::move(result));
+		return BindReturning(std::move(stmt.returning_list), table, stmt.table_ref ? stmt.table_ref->alias : string(),
+		                     insert_table_index, std::move(index_as_logicaloperator), std::move(result));
 	}
 
 	D_ASSERT(result.types.size() == result.names.size());

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/statement/bind_update.cpp

@@ -195,11 +195,13 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 	AddCTEMap(stmt.cte_map);
 
 	if (stmt.from_table) {
+		auto from_binder = Binder::CreateBinder(context, this);
 		BoundJoinRef bound_crossproduct(JoinRefType::CROSS);
 		bound_crossproduct.left = std::move(bound_table);
-		bound_crossproduct.right = Bind(*stmt.from_table);
+		bound_crossproduct.right = from_binder->Bind(*stmt.from_table);
 		root = CreatePlan(bound_crossproduct);
 		get = (LogicalGet *)root->children[0].get();
+		bind_context.AddContext(std::move(from_binder->bind_context));
 	} else {
 		root = CreatePlan(*bound_table);
 		get = (LogicalGet *)root.get();
@@ -251,7 +253,7 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 	if (!stmt.returning_list.empty()) {
 		unique_ptr<LogicalOperator> update_as_logicaloperator = std::move(update);
 
-		return BindReturning(std::move(stmt.returning_list), table, update_table_index,
+		return BindReturning(std::move(stmt.returning_list), table, stmt.table->alias, update_table_index,
 		                     std::move(update_as_logicaloperator), std::move(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 {
 
@@ -23,11 +25,11 @@ static unique_ptr<ParsedExpression> BindColumn(Binder &binder, ClientContext &co
 
 static unique_ptr<ParsedExpression> AddCondition(ClientContext &context, Binder &left_binder, Binder &right_binder,
                                                  const string &left_alias, const string &right_alias,
-                                                 const string &column_name) {
+                                                 const string &column_name, ExpressionType type) {
 	ExpressionBinder expr_binder(left_binder, context);
 	auto left = BindColumn(left_binder, context, left_alias, column_name);
 	auto right = BindColumn(right_binder, context, right_alias, column_name);
-	return make_unique<ComparisonExpression>(ExpressionType::COMPARE_EQUAL, std::move(left), std::move(right));
+	return make_unique<ComparisonExpression>(type, std::move(left), std::move(right));
 }
 
 bool Binder::TryFindBinding(const string &using_column, const string &join_side, string &result) {
@@ -196,12 +198,14 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 		break;
 	}
 	case JoinRefType::REGULAR:
+	case JoinRefType::ASOF:
 		if (!ref.using_columns.empty()) {
 			// USING columns
 			D_ASSERT(!result->condition);
 			extra_using_columns = ref.using_columns;
 		}
 		break;
+
 	case JoinRefType::CROSS:
 	case JoinRefType::POSITIONAL:
 		break;
@@ -239,8 +243,13 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 			left_binding = RetrieveUsingBinding(left_binder, left_using_binding, using_column, "left", set.get());
 			right_binding = RetrieveUsingBinding(right_binder, right_using_binding, using_column, "right", set.get());
 
+			// Last column of ASOF JOIN ... USING is >=
+			const auto type = (ref.ref_type == JoinRefType::ASOF && i == extra_using_columns.size() - 1)
+			                      ? ExpressionType::COMPARE_GREATERTHANOREQUALTO
+			                      : ExpressionType::COMPARE_EQUAL;
+
 			extra_conditions.push_back(
-			    AddCondition(context, left_binder, right_binder, left_binding, right_binding, using_column));
+			    AddCondition(context, left_binder, right_binder, left_binding, right_binding, using_column, type));
 
 			AddUsingBindings(*set, left_using_binding, left_binding);
 			AddUsingBindings(*set, right_using_binding, right_binding);
@@ -253,6 +262,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 +280,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,366 @@
+#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.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_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 || !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));
+			}
+		} 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.pivot_expressions) {
+			ExtractPivotExpressions(*pivot_name, handled_columns);
+		}
+		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.pivot_expressions.size()) {
+				throw ParserException("PIVOT IN list - inconsistent amount of rows - expected %d but got %d",
+				                      pivot.pivot_expressions.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;
+		expressions.reserve(unpivot.entries.size());
+		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.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

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

@@ -126,9 +126,18 @@ Binder::BindTableFunctionInternal(TableFunction &table_function, const string &f
 	unique_ptr<FunctionData> bind_data;
 	vector<LogicalType> return_types;
 	vector<string> return_names;
-	if (table_function.bind) {
+	if (table_function.bind || table_function.bind_replace) {
 		TableFunctionBindInput bind_input(parameters, named_parameters, input_table_types, input_table_names,
 		                                  table_function.function_info.get());
+		if (table_function.bind_replace) {
+			auto new_plan = table_function.bind_replace(context, bind_input);
+			if (new_plan != nullptr) {
+				return CreatePlan(*Bind(*new_plan));
+			} else if (!table_function.bind) {
+				throw BinderException("Failed to bind \"%s\": nullptr returned from bind_replace without bind function",
+				                      table_function.name);
+			}
+		}
 		bind_data = table_function.bind(context, bind_input, return_types, return_names);
 		if (table_function.name == "pandas_scan" || table_function.name == "arrow_scan") {
 			auto arrow_bind = (PyTableFunctionData *)bind_data.get();
@@ -153,6 +162,7 @@ Binder::BindTableFunctionInternal(TableFunction &table_function, const string &f
 			return_names[i] = "C" + to_string(i);
 		}
 	}
+
 	auto get = make_unique<LogicalGet>(bind_index, table_function, std::move(bind_data), return_types, return_names);
 	get->parameters = parameters;
 	get->named_parameters = named_parameters;

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

@@ -8,6 +8,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundCTERef &ref) {
 	auto index = ref.bind_index;
 
 	vector<LogicalType> types;
+	types.reserve(ref.types.size());
 	for (auto &type : ref.types) {
 		types.push_back(type);
 	}