duckdb 0.7.2-dev225.0 → 0.7.2-dev2320.0

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

@@ -9,16 +9,16 @@ 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;
+		auto &colref = expr->Cast<ColumnRefExpression>();
 		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;
+		auto &constant_expr = expr->Cast<ConstantExpression>();
 		entry.values.push_back(std::move(constant_expr.value));
 	} else if (root_entry && expr->type == ExpressionType::FUNCTION) {
-		auto &function = (FunctionExpression &)*expr;
+		auto &function = expr->Cast<FunctionExpression>();
 		if (function.function_name != "row") {
 			throw ParserException("PIVOT IN list must contain columns or lists of columns");
 		}
@@ -34,7 +34,21 @@ static void TransformPivotInList(unique_ptr<ParsedExpression> &expr, PivotColumn
 
 PivotColumn Transformer::TransformPivotColumn(duckdb_libpgquery::PGPivot *pivot) {
 	PivotColumn col;
-	col.names = TransformStringList(pivot->pivot_columns);
+	if (pivot->pivot_columns) {
+		TransformExpressionList(*pivot->pivot_columns, col.pivot_expressions);
+		for (auto &expr : col.pivot_expressions) {
+			if (expr->IsScalar()) {
+				throw ParserException("Cannot pivot on constant value \"%s\"", expr->ToString());
+			}
+			if (expr->HasSubquery()) {
+				throw ParserException("Cannot pivot on subquery \"%s\"", expr->ToString());
+			}
+		}
+	} else if (pivot->unpivot_columns) {
+		col.unpivot_names = TransformStringList(pivot->unpivot_columns);
+	} else {
+		throw InternalException("Either pivot_columns or unpivot_columns must be defined");
+	}
 	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;
@@ -61,7 +75,7 @@ vector<PivotColumn> Transformer::TransformPivotList(duckdb_libpgquery::PGList *l
 }
 
 unique_ptr<TableRef> Transformer::TransformPivot(duckdb_libpgquery::PGPivotExpr *root) {
-	auto result = make_unique<PivotRef>();
+	auto result = make_uniq<PivotRef>();
 	result->source = TransformTableRefNode(root->source);
 	if (root->aggrs) {
 		TransformExpressionList(*root->aggrs, result->aggregates);
@@ -78,13 +92,15 @@ unique_ptr<TableRef> Transformer::TransformPivot(duckdb_libpgquery::PGPivotExpr
 		bool is_pivot = result->unpivot_names.empty();
 		if (!result->unpivot_names.empty()) {
 			// unpivot
-			if (pivot.names.size() != 1) {
+			if (pivot.unpivot_names.size() != 1) {
 				throw ParserException("UNPIVOT requires a single column name for the PIVOT IN clause");
 			}
+			D_ASSERT(pivot.pivot_expressions.empty());
 			expected_size = pivot.entries[0].values.size();
 		} else {
 			// pivot
-			expected_size = pivot.names.size();
+			expected_size = pivot.pivot_expressions.size();
+			D_ASSERT(pivot.unpivot_names.empty());
 		}
 		for (auto &entry : pivot.entries) {
 			if (entry.star_expr && is_pivot) {

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

@@ -4,12 +4,12 @@
 namespace duckdb {
 
 unique_ptr<TableRef> Transformer::TransformRangeSubselect(duckdb_libpgquery::PGRangeSubselect *root) {
-	Transformer subquery_transformer(this);
+	Transformer subquery_transformer(*this);
 	auto subquery = subquery_transformer.TransformSelect(root->subquery);
 	if (!subquery) {
 		return nullptr;
 	}
-	auto result = make_unique<SubqueryRef>(std::move(subquery));
+	auto result = make_uniq<SubqueryRef>(std::move(subquery));
 	result->alias = TransformAlias(root->alias, result->column_name_alias);
 	if (root->sample) {
 		result->sample = TransformSampleOptions(root->sample);

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

@@ -23,7 +23,7 @@ unique_ptr<TableRef> Transformer::TransformRangeFunction(duckdb_libpgquery::PGRa
 		throw NotImplementedException("Explicit column definition not supported yet");
 	}
 	// transform the function call
-	auto result = make_unique<TableFunctionRef>();
+	auto result = make_uniq<TableFunctionRef>();
 	switch (call_tree->type) {
 	case duckdb_libpgquery::T_PGFuncCall: {
 		auto func_call = (duckdb_libpgquery::PGFuncCall *)call_tree;

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

@@ -4,6 +4,7 @@
 #include "duckdb/parser/statement/list.hpp"
 #include "duckdb/parser/tableref/emptytableref.hpp"
 #include "duckdb/parser/query_node/select_node.hpp"
+#include "duckdb/parser/parser_options.hpp"
 
 namespace duckdb {
 
@@ -21,12 +22,12 @@ StackChecker::StackChecker(StackChecker &&other) noexcept
 	other.stack_usage = 0;
 }
 
-Transformer::Transformer(idx_t max_expression_depth_p)
-    : parent(nullptr), max_expression_depth(max_expression_depth_p), stack_depth(DConstants::INVALID_INDEX) {
+Transformer::Transformer(ParserOptions &options)
+    : parent(nullptr), options(options), stack_depth(DConstants::INVALID_INDEX) {
 }
 
-Transformer::Transformer(Transformer *parent)
-    : parent(parent), max_expression_depth(parent->max_expression_depth), stack_depth(DConstants::INVALID_INDEX) {
+Transformer::Transformer(Transformer &parent)
+    : parent(&parent), options(parent.options), stack_depth(DConstants::INVALID_INDEX) {
 }
 
 Transformer::~Transformer() {
@@ -58,17 +59,14 @@ void Transformer::InitializeStackCheck() {
 }
 
 StackChecker Transformer::StackCheck(idx_t extra_stack) {
-	auto node = this;
-	while (node->parent) {
-		node = node->parent;
-	}
-	D_ASSERT(node->stack_depth != DConstants::INVALID_INDEX);
-	if (node->stack_depth + extra_stack >= max_expression_depth) {
+	auto &root = RootTransformer();
+	D_ASSERT(root.stack_depth != DConstants::INVALID_INDEX);
+	if (root.stack_depth + extra_stack >= options.max_expression_depth) {
 		throw ParserException("Max expression depth limit of %lld exceeded. Use \"SET max_expression_depth TO x\" to "
 		                      "increase the maximum expression depth.",
-		                      max_expression_depth);
+		                      options.max_expression_depth);
 	}
-	return StackChecker(*node, extra_stack);
+	return StackChecker(root, extra_stack);
 }
 
 unique_ptr<SQLStatement> Transformer::TransformStatement(duckdb_libpgquery::PGNode *stmt) {
@@ -81,6 +79,50 @@ unique_ptr<SQLStatement> Transformer::TransformStatement(duckdb_libpgquery::PGNo
 	return result;
 }
 
+Transformer &Transformer::RootTransformer() {
+	reference<Transformer> node = *this;
+	while (node.get().parent) {
+		node = *node.get().parent;
+	}
+	return node.get();
+}
+
+const Transformer &Transformer::RootTransformer() const {
+	reference<const Transformer> node = *this;
+	while (node.get().parent) {
+		node = *node.get().parent;
+	}
+	return node.get();
+}
+
+idx_t Transformer::ParamCount() const {
+	auto &root = RootTransformer();
+	return root.prepared_statement_parameter_index;
+}
+
+void Transformer::SetParamCount(idx_t new_count) {
+	auto &root = RootTransformer();
+	root.prepared_statement_parameter_index = new_count;
+}
+void Transformer::SetNamedParam(const string &name, int32_t index) {
+	auto &root = RootTransformer();
+	D_ASSERT(!root.named_param_map.count(name));
+	root.named_param_map[name] = index;
+}
+bool Transformer::GetNamedParam(const string &name, int32_t &index) {
+	auto &root = RootTransformer();
+	auto entry = root.named_param_map.find(name);
+	if (entry == root.named_param_map.end()) {
+		return false;
+	}
+	index = entry->second;
+	return true;
+}
+bool Transformer::HasNamedParameters() const {
+	auto &root = RootTransformer();
+	return !root.named_param_map.empty();
+}
+
 unique_ptr<SQLStatement> Transformer::TransformStatementInternal(duckdb_libpgquery::PGNode *stmt) {
 	switch (stmt->type) {
 	case duckdb_libpgquery::T_PGRawStmt: {

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

@@ -13,7 +13,7 @@
 #include "duckdb/planner/bound_query_node.hpp"
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
-#include "re2/re2.h"
+#include "duckdb/planner/expression_binder/constant_binder.hpp"
 
 #include <algorithm>
 
@@ -51,7 +51,7 @@ vector<string> BindContext::GetSimilarBindings(const string &column_name) {
 	return StringUtil::TopNStrings(scores);
 }
 
-void BindContext::AddUsingBinding(const string &column_name, UsingColumnSet *set) {
+void BindContext::AddUsingBinding(const string &column_name, UsingColumnSet &set) {
 	using_columns[column_name].insert(set);
 }
 
@@ -59,25 +59,18 @@ void BindContext::AddUsingBindingSet(unique_ptr<UsingColumnSet> set) {
 	using_column_sets.push_back(std::move(set));
 }
 
-bool BindContext::FindUsingBinding(const string &column_name, unordered_set<UsingColumnSet *> **out) {
+optional_ptr<UsingColumnSet> BindContext::GetUsingBinding(const string &column_name) {
 	auto entry = using_columns.find(column_name);
-	if (entry != using_columns.end()) {
-		*out = &entry->second;
-		return true;
-	}
-	return false;
-}
-
-UsingColumnSet *BindContext::GetUsingBinding(const string &column_name) {
-	unordered_set<UsingColumnSet *> *using_bindings;
-	if (!FindUsingBinding(column_name, &using_bindings)) {
+	if (entry == using_columns.end()) {
 		return nullptr;
 	}
-	if (using_bindings->size() > 1) {
+	auto &using_bindings = entry->second;
+	if (using_bindings.size() > 1) {
 		string error = "Ambiguous column reference: column \"" + column_name + "\" can refer to either:\n";
-		for (auto &using_set : *using_bindings) {
+		for (auto &using_set_ref : using_bindings) {
+			auto &using_set = using_set_ref.get();
 			string result_bindings;
-			for (auto &binding : using_set->bindings) {
+			for (auto &binding : using_set.bindings) {
 				if (result_bindings.empty()) {
 					result_bindings = "[";
 				} else {
@@ -91,33 +84,32 @@ UsingColumnSet *BindContext::GetUsingBinding(const string &column_name) {
 		}
 		throw BinderException(error);
 	}
-	for (auto &using_set : *using_bindings) {
-		return using_set;
+	for (auto &using_set : using_bindings) {
+		return &using_set.get();
 	}
 	throw InternalException("Using binding found but no entries");
 }
 
-UsingColumnSet *BindContext::GetUsingBinding(const string &column_name, const string &binding_name) {
+optional_ptr<UsingColumnSet> BindContext::GetUsingBinding(const string &column_name, const string &binding_name) {
 	if (binding_name.empty()) {
 		throw InternalException("GetUsingBinding: expected non-empty binding_name");
 	}
-	unordered_set<UsingColumnSet *> *using_bindings;
-	if (!FindUsingBinding(column_name, &using_bindings)) {
+	auto entry = using_columns.find(column_name);
+	if (entry == using_columns.end()) {
 		return nullptr;
 	}
-	for (auto &using_set : *using_bindings) {
-		auto &bindings = using_set->bindings;
+	auto &using_bindings = entry->second;
+	for (auto &using_set_ref : using_bindings) {
+		auto &using_set = using_set_ref.get();
+		auto &bindings = using_set.bindings;
 		if (bindings.find(binding_name) != bindings.end()) {
-			return using_set;
+			return &using_set;
 		}
 	}
 	return nullptr;
 }
 
-void BindContext::RemoveUsingBinding(const string &column_name, UsingColumnSet *set) {
-	if (!set) {
-		return;
-	}
+void BindContext::RemoveUsingBinding(const string &column_name, UsingColumnSet &set) {
 	auto entry = using_columns.find(column_name);
 	if (entry == using_columns.end()) {
 		throw InternalException("Attempting to remove using binding that is not there");
@@ -131,10 +123,12 @@ void BindContext::RemoveUsingBinding(const string &column_name, UsingColumnSet *
 	}
 }
 
-void BindContext::TransferUsingBinding(BindContext &current_context, UsingColumnSet *current_set,
-                                       UsingColumnSet *new_set, const string &binding, const string &using_column) {
+void BindContext::TransferUsingBinding(BindContext &current_context, optional_ptr<UsingColumnSet> current_set,
+                                       UsingColumnSet &new_set, const string &binding, const string &using_column) {
 	AddUsingBinding(using_column, new_set);
-	current_context.RemoveUsingBinding(using_column, current_set);
+	if (current_set) {
+		current_context.RemoveUsingBinding(using_column, *current_set);
+	}
 }
 
 string BindContext::GetActualColumnName(const string &binding_name, const string &column_name) {
@@ -167,7 +161,7 @@ unique_ptr<ParsedExpression> BindContext::ExpandGeneratedColumn(const string &ta
 
 	auto binding = GetBinding(table_name, error_message);
 	D_ASSERT(binding);
-	auto &table_binding = *(TableBinding *)binding;
+	auto &table_binding = (TableBinding &)*binding;
 	auto result = table_binding.ExpandGeneratedColumn(column_name);
 	result->alias = column_name;
 	return result;
@@ -178,12 +172,12 @@ unique_ptr<ParsedExpression> BindContext::CreateColumnReference(const string &ta
 	return CreateColumnReference(schema_name, table_name, column_name);
 }
 
-static bool ColumnIsGenerated(Binding *binding, column_t index) {
-	if (binding->binding_type != BindingType::TABLE) {
+static bool ColumnIsGenerated(Binding &binding, column_t index) {
+	if (binding.binding_type != BindingType::TABLE) {
 		return false;
 	}
-	auto table_binding = (TableBinding *)binding;
-	auto catalog_entry = table_binding->GetStandardEntry();
+	auto &table_binding = (TableBinding &)binding;
+	auto catalog_entry = table_binding.GetStandardEntry();
 	if (!catalog_entry) {
 		return false;
 	}
@@ -191,8 +185,8 @@ static bool ColumnIsGenerated(Binding *binding, column_t index) {
 		return false;
 	}
 	D_ASSERT(catalog_entry->type == CatalogType::TABLE_ENTRY);
-	auto table_entry = (TableCatalogEntry *)catalog_entry;
-	return table_entry->GetColumn(LogicalIndex(index)).Generated();
+	auto &table_entry = catalog_entry->Cast<TableCatalogEntry>();
+	return table_entry.GetColumn(LogicalIndex(index)).Generated();
 }
 
 unique_ptr<ParsedExpression> BindContext::CreateColumnReference(const string &catalog_name, const string &schema_name,
@@ -208,13 +202,13 @@ unique_ptr<ParsedExpression> BindContext::CreateColumnReference(const string &ca
 	names.push_back(table_name);
 	names.push_back(column_name);
 
-	auto result = make_unique<ColumnRefExpression>(std::move(names));
+	auto result = make_uniq<ColumnRefExpression>(std::move(names));
 	auto binding = GetBinding(table_name, error_message);
 	if (!binding) {
 		return std::move(result);
 	}
 	auto column_index = binding->GetBindingIndex(column_name);
-	if (ColumnIsGenerated(binding, column_index)) {
+	if (ColumnIsGenerated(*binding, column_index)) {
 		return ExpandGeneratedColumn(table_name, column_name);
 	} else if (column_index < binding->names.size() && binding->names[column_index] != column_name) {
 		// because of case insensitivity in the binder we rename the column to the original name
@@ -230,7 +224,7 @@ unique_ptr<ParsedExpression> BindContext::CreateColumnReference(const string &sc
 	return CreateColumnReference(catalog_name, schema_name, table_name, column_name);
 }
 
-Binding *BindContext::GetCTEBinding(const string &ctename) {
+optional_ptr<Binding> BindContext::GetCTEBinding(const string &ctename) {
 	auto match = cte_bindings.find(ctename);
 	if (match == cte_bindings.end()) {
 		return nullptr;
@@ -238,7 +232,7 @@ Binding *BindContext::GetCTEBinding(const string &ctename) {
 	return match->second.get();
 }
 
-Binding *BindContext::GetBinding(const string &name, string &out_error) {
+optional_ptr<Binding> BindContext::GetBinding(const string &name, string &out_error) {
 	auto match = bindings.find(name);
 	if (match == bindings.end()) {
 		// alias not found in this BindContext
@@ -271,16 +265,17 @@ string BindContext::BindColumn(PositionalReferenceExpression &ref, string &table
 	idx_t total_columns = 0;
 	idx_t current_position = ref.index - 1;
 	for (auto &entry : bindings_list) {
-		idx_t entry_column_count = entry.second->names.size();
+		auto &binding = entry.get();
+		idx_t entry_column_count = binding.names.size();
 		if (ref.index == 0) {
 			// this is a row id
-			table_name = entry.first;
+			table_name = binding.alias;
 			column_name = "rowid";
 			return string();
 		}
 		if (current_position < entry_column_count) {
-			table_name = entry.first;
-			column_name = entry.second->names[current_position];
+			table_name = binding.alias;
+			column_name = binding.names[current_position];
 			return string();
 		} else {
 			total_columns += entry_column_count;
@@ -297,11 +292,11 @@ BindResult BindContext::BindColumn(PositionalReferenceExpression &ref, idx_t dep
 	if (!error.empty()) {
 		return BindResult(error);
 	}
-	auto column_ref = make_unique<ColumnRefExpression>(column_name, table_name);
+	auto column_ref = make_uniq<ColumnRefExpression>(column_name, table_name);
 	return BindColumn(*column_ref, depth);
 }
 
-bool BindContext::CheckExclusionList(StarExpression &expr, Binding *binding, const string &column_name,
+bool BindContext::CheckExclusionList(StarExpression &expr, const string &column_name,
                                      vector<unique_ptr<ParsedExpression>> &new_select_list,
                                      case_insensitive_set_t &excluded_columns) {
 	if (expr.exclude_list.find(column_name) != expr.exclude_list.end()) {
@@ -319,45 +314,26 @@ bool BindContext::CheckExclusionList(StarExpression &expr, Binding *binding, con
 	return false;
 }
 
-bool CheckRegex(const string &column_name, duckdb_re2::RE2 *regex) {
-	if (!regex) {
-		return true;
-	}
-	return RE2::PartialMatch(column_name, *regex);
-}
-
 void BindContext::GenerateAllColumnExpressions(StarExpression &expr,
                                                vector<unique_ptr<ParsedExpression>> &new_select_list) {
 	if (bindings_list.empty()) {
-		throw BinderException("SELECT * expression without FROM clause!");
+		throw BinderException("* expression without FROM clause!");
 	}
 	case_insensitive_set_t excluded_columns;
 	if (expr.relation_name.empty()) {
 		// SELECT * case
 		// bind all expressions of each table in-order
-		unique_ptr<duckdb_re2::RE2> regex;
-		bool found_match = true;
-		if (!expr.regex.empty()) {
-			regex = make_unique<duckdb_re2::RE2>(expr.regex);
-			if (!regex->error().empty()) {
-				throw BinderException("Failed to compile regex \"%s\": %s", expr.regex, regex->error());
-			}
-			found_match = false;
-		}
-		unordered_set<UsingColumnSet *> handled_using_columns;
+		reference_set_t<UsingColumnSet> handled_using_columns;
 		for (auto &entry : bindings_list) {
-			auto binding = entry.second;
-			for (auto &column_name : binding->names) {
-				if (CheckExclusionList(expr, binding, column_name, new_select_list, excluded_columns)) {
-					continue;
-				}
-				if (!CheckRegex(column_name, regex.get())) {
+			auto &binding = entry.get();
+			for (auto &column_name : binding.names) {
+				if (CheckExclusionList(expr, column_name, new_select_list, excluded_columns)) {
 					continue;
 				}
-				found_match = true;
 				// check if this column is a USING column
-				auto using_binding = GetUsingBinding(column_name, binding->alias);
-				if (using_binding) {
+				auto using_binding_ptr = GetUsingBinding(column_name, binding.alias);
+				if (using_binding_ptr) {
+					auto &using_binding = *using_binding_ptr;
 					// it is!
 					// check if we have already emitted the using column
 					if (handled_using_columns.find(using_binding) != handled_using_columns.end()) {
@@ -365,28 +341,25 @@ void BindContext::GenerateAllColumnExpressions(StarExpression &expr,
 						continue;
 					}
 					// we have not! output the using column
-					if (using_binding->primary_binding.empty()) {
+					if (using_binding.primary_binding.empty()) {
 						// no primary binding: output a coalesce
-						auto coalesce = make_unique<OperatorExpression>(ExpressionType::OPERATOR_COALESCE);
-						for (auto &child_binding : using_binding->bindings) {
-							coalesce->children.push_back(make_unique<ColumnRefExpression>(column_name, child_binding));
+						auto coalesce = make_uniq<OperatorExpression>(ExpressionType::OPERATOR_COALESCE);
+						for (auto &child_binding : using_binding.bindings) {
+							coalesce->children.push_back(make_uniq<ColumnRefExpression>(column_name, child_binding));
 						}
 						coalesce->alias = column_name;
 						new_select_list.push_back(std::move(coalesce));
 					} else {
 						// primary binding: output the qualified column ref
 						new_select_list.push_back(
-						    make_unique<ColumnRefExpression>(column_name, using_binding->primary_binding));
+						    make_uniq<ColumnRefExpression>(column_name, using_binding.primary_binding));
 					}
 					handled_using_columns.insert(using_binding);
 					continue;
 				}
-				new_select_list.push_back(make_unique<ColumnRefExpression>(column_name, binding->alias));
+				new_select_list.push_back(make_uniq<ColumnRefExpression>(column_name, binding.alias));
 			}
 		}
-		if (!found_match) {
-			throw BinderException("No matching columns found that match regex \"%s\"", expr.regex);
-		}
 	} else {
 		// SELECT tbl.* case
 		// SELECT struct.* case
@@ -414,19 +387,19 @@ void BindContext::GenerateAllColumnExpressions(StarExpression &expr,
 			column_names[0] = binding->alias;
 			column_names[1] = expr.relation_name;
 			for (auto &child : struct_children) {
-				if (CheckExclusionList(expr, binding, child.first, new_select_list, excluded_columns)) {
+				if (CheckExclusionList(expr, child.first, new_select_list, excluded_columns)) {
 					continue;
 				}
 				column_names[2] = child.first;
-				new_select_list.push_back(make_unique<ColumnRefExpression>(column_names));
+				new_select_list.push_back(make_uniq<ColumnRefExpression>(column_names));
 			}
 		} else {
 			for (auto &column_name : binding->names) {
-				if (CheckExclusionList(expr, binding, column_name, new_select_list, excluded_columns)) {
+				if (CheckExclusionList(expr, column_name, new_select_list, excluded_columns)) {
 					continue;
 				}
 
-				new_select_list.push_back(make_unique<ColumnRefExpression>(column_name, binding->alias));
+				new_select_list.push_back(make_uniq<ColumnRefExpression>(column_name, binding->alias));
 			}
 		}
 	}
@@ -444,24 +417,35 @@ void BindContext::GenerateAllColumnExpressions(StarExpression &expr,
 	}
 }
 
+void BindContext::GetTypesAndNames(vector<string> &result_names, vector<LogicalType> &result_types) {
+	for (auto &binding_entry : bindings_list) {
+		auto &binding = binding_entry.get();
+		D_ASSERT(binding.names.size() == binding.types.size());
+		for (idx_t i = 0; i < binding.names.size(); i++) {
+			result_names.push_back(binding.names[i]);
+			result_types.push_back(binding.types[i]);
+		}
+	}
+}
+
 void BindContext::AddBinding(const string &alias, unique_ptr<Binding> binding) {
 	if (bindings.find(alias) != bindings.end()) {
 		throw BinderException("Duplicate alias \"%s\" in query!", alias);
 	}
-	bindings_list.emplace_back(alias, binding.get());
+	bindings_list.push_back(*binding);
 	bindings[alias] = std::move(binding);
 }
 
 void BindContext::AddBaseTable(idx_t index, const string &alias, const vector<string> &names,
                                const vector<LogicalType> &types, vector<column_t> &bound_column_ids,
                                StandardEntry *entry, bool add_row_id) {
-	AddBinding(alias, make_unique<TableBinding>(alias, types, names, bound_column_ids, entry, index, add_row_id));
+	AddBinding(alias, make_uniq<TableBinding>(alias, types, names, bound_column_ids, entry, index, add_row_id));
 }
 
 void BindContext::AddTableFunction(idx_t index, const string &alias, const vector<string> &names,
                                    const vector<LogicalType> &types, vector<column_t> &bound_column_ids,
                                    StandardEntry *entry) {
-	AddBinding(alias, make_unique<TableBinding>(alias, types, names, bound_column_ids, entry, index));
+	AddBinding(alias, make_uniq<TableBinding>(alias, types, names, bound_column_ids, entry, index));
 }
 
 static string AddColumnNameToBinding(const string &base_name, case_insensitive_set_t &current_names) {
@@ -501,7 +485,7 @@ void BindContext::AddSubquery(idx_t index, const string &alias, SubqueryRef &ref
 void BindContext::AddEntryBinding(idx_t index, const string &alias, const vector<string> &names,
                                   const vector<LogicalType> &types, StandardEntry *entry) {
 	D_ASSERT(entry);
-	AddBinding(alias, make_unique<EntryBinding>(alias, types, names, index, *entry));
+	AddBinding(alias, make_uniq<EntryBinding>(alias, types, names, index, *entry));
 }
 
 void BindContext::AddView(idx_t index, const string &alias, SubqueryRef &ref, BoundQueryNode &subquery,
@@ -517,7 +501,7 @@ void BindContext::AddSubquery(idx_t index, const string &alias, TableFunctionRef
 
 void BindContext::AddGenericBinding(idx_t index, const string &alias, const vector<string> &names,
                                     const vector<LogicalType> &types) {
-	AddBinding(alias, make_unique<Binding>(BindingType::BASE, alias, types, names, index));
+	AddBinding(alias, make_uniq<Binding>(BindingType::BASE, alias, types, names, index));
 }
 
 void BindContext::AddCTEBinding(idx_t index, const string &alias, const vector<string> &names,
@@ -539,14 +523,14 @@ void BindContext::AddContext(BindContext other) {
 		bindings[binding.first] = std::move(binding.second);
 	}
 	for (auto &binding : other.bindings_list) {
-		bindings_list.push_back(std::move(binding));
+		bindings_list.push_back(binding);
 	}
 	for (auto &entry : other.using_columns) {
 		for (auto &alias : entry.second) {
 #ifdef DEBUG
 			for (auto &other_alias : using_columns[entry.first]) {
-				for (auto &col : alias->bindings) {
-					D_ASSERT(other_alias->bindings.find(col) == other_alias->bindings.end());
+				for (auto &col : alias.get().bindings) {
+					D_ASSERT(other_alias.get().bindings.find(col) == other_alias.get().bindings.end());
 				}
 			}
 #endif
@@ -555,4 +539,20 @@ void BindContext::AddContext(BindContext other) {
 	}
 }
 
+void BindContext::RemoveContext(vector<reference<Binding>> &other_bindings_list) {
+	for (auto &other_binding : other_bindings_list) {
+		auto it = std::remove_if(bindings_list.begin(), bindings_list.end(), [other_binding](reference<Binding> x) {
+			return x.get().alias == other_binding.get().alias;
+		});
+		bindings_list.erase(it, bindings_list.end());
+	}
+
+	for (auto &other_binding : other_bindings_list) {
+		auto &alias = other_binding.get().alias;
+		if (bindings.find(alias) != bindings.end()) {
+			bindings.erase(alias);
+		}
+	}
+}
+
 } // namespace duckdb