duckdb 0.7.2-dev2233.0 → 0.7.2-dev2320.0

package/src/duckdb/src/parallel/pipeline.cpp

@@ -81,8 +81,9 @@ bool Pipeline::ScheduleParallel(shared_ptr<Event> &event) {
 	if (!source->ParallelSource()) {
 		return false;
 	}
-	for (auto &op : operators) {
-		if (!op->ParallelOperator()) {
+	for (auto &op_ref : operators) {
+		auto &op = op_ref.get();
+		if (!op.ParallelOperator()) {
 			return false;
 		}
 	}
@@ -107,11 +108,12 @@ bool Pipeline::IsOrderDependent() const {
 			return false;
 		}
 	}
-	for (auto &op : operators) {
-		if (op->OperatorOrder() == OrderPreservationType::NO_ORDER) {
+	for (auto &op_ref : operators) {
+		auto &op = op_ref.get();
+		if (op.OperatorOrder() == OrderPreservationType::NO_ORDER) {
 			return false;
 		}
-		if (op->OperatorOrder() == OrderPreservationType::FIXED_ORDER) {
+		if (op.OperatorOrder() == OrderPreservationType::FIXED_ORDER) {
 			return true;
 		}
 	}
@@ -169,12 +171,11 @@ void Pipeline::ResetSink() {
 
 void Pipeline::Reset() {
 	ResetSink();
-	for (auto &op : operators) {
-		if (op) {
-			lock_guard<mutex> guard(op->lock);
-			if (!op->op_state) {
-				op->op_state = op->GetGlobalOperatorState(GetClientContext());
-			}
+	for (auto &op_ref : operators) {
+		auto &op = op_ref.get();
+		lock_guard<mutex> guard(op.lock);
+		if (!op.op_state) {
+			op.op_state = op.GetGlobalOperatorState(GetClientContext());
 		}
 	}
 	ResetSource(false);
@@ -238,13 +239,28 @@ void Pipeline::PrintDependencies() const {
 	}
 }
 
-vector<PhysicalOperator *> Pipeline::GetOperators() const {
-	vector<PhysicalOperator *> result;
+vector<reference<PhysicalOperator>> Pipeline::GetOperators() {
+	vector<reference<PhysicalOperator>> result;
+	D_ASSERT(source);
+	result.push_back(*source);
+	for (auto &op : operators) {
+		result.push_back(op.get());
+	}
+	if (sink) {
+		result.push_back(*sink);
+	}
+	return result;
+}
+
+vector<const_reference<PhysicalOperator>> Pipeline::GetOperators() const {
+	vector<const_reference<PhysicalOperator>> result;
 	D_ASSERT(source);
-	result.push_back(source);
-	result.insert(result.end(), operators.begin(), operators.end());
+	result.push_back(*source);
+	for (auto &op : operators) {
+		result.push_back(op.get());
+	}
 	if (sink) {
-		result.push_back(sink);
+		result.push_back(*sink);
 	}
 	return result;
 }
@@ -252,38 +268,39 @@ vector<PhysicalOperator *> Pipeline::GetOperators() const {
 //===--------------------------------------------------------------------===//
 // Pipeline Build State
 //===--------------------------------------------------------------------===//
-void PipelineBuildState::SetPipelineSource(Pipeline &pipeline, PhysicalOperator *op) {
-	pipeline.source = op;
+void PipelineBuildState::SetPipelineSource(Pipeline &pipeline, PhysicalOperator &op) {
+	pipeline.source = &op;
 }
 
-void PipelineBuildState::SetPipelineSink(Pipeline &pipeline, PhysicalOperator *op, idx_t sink_pipeline_count) {
+void PipelineBuildState::SetPipelineSink(Pipeline &pipeline, optional_ptr<PhysicalOperator> op,
+                                         idx_t sink_pipeline_count) {
 	pipeline.sink = op;
 	// set the base batch index of this pipeline based on how many other pipelines have this node as their sink
 	pipeline.base_batch_index = BATCH_INCREMENT * sink_pipeline_count;
 }
 
-void PipelineBuildState::AddPipelineOperator(Pipeline &pipeline, PhysicalOperator *op) {
+void PipelineBuildState::AddPipelineOperator(Pipeline &pipeline, PhysicalOperator &op) {
 	pipeline.operators.push_back(op);
 }
 
-PhysicalOperator *PipelineBuildState::GetPipelineSource(Pipeline &pipeline) {
+optional_ptr<PhysicalOperator> PipelineBuildState::GetPipelineSource(Pipeline &pipeline) {
 	return pipeline.source;
 }
 
-PhysicalOperator *PipelineBuildState::GetPipelineSink(Pipeline &pipeline) {
+optional_ptr<PhysicalOperator> PipelineBuildState::GetPipelineSink(Pipeline &pipeline) {
 	return pipeline.sink;
 }
 
-void PipelineBuildState::SetPipelineOperators(Pipeline &pipeline, vector<PhysicalOperator *> operators) {
+void PipelineBuildState::SetPipelineOperators(Pipeline &pipeline, vector<reference<PhysicalOperator>> operators) {
 	pipeline.operators = std::move(operators);
 }
 
 shared_ptr<Pipeline> PipelineBuildState::CreateChildPipeline(Executor &executor, Pipeline &pipeline,
-                                                             PhysicalOperator *op) {
-	return executor.CreateChildPipeline(&pipeline, op);
+                                                             PhysicalOperator &op) {
+	return executor.CreateChildPipeline(pipeline, op);
 }
 
-vector<PhysicalOperator *> PipelineBuildState::GetPipelineOperators(Pipeline &pipeline) {
+vector<reference<PhysicalOperator>> PipelineBuildState::GetPipelineOperators(Pipeline &pipeline) {
 	return pipeline.operators;
 }
 

package/src/duckdb/src/parallel/pipeline_executor.cpp

@@ -16,17 +16,17 @@ PipelineExecutor::PipelineExecutor(ClientContext &context_p, Pipeline &pipeline_
 	intermediate_chunks.reserve(pipeline.operators.size());
 	intermediate_states.reserve(pipeline.operators.size());
 	for (idx_t i = 0; i < pipeline.operators.size(); i++) {
-		auto prev_operator = i == 0 ? pipeline.source : pipeline.operators[i - 1];
-		auto current_operator = pipeline.operators[i];
+		auto &prev_operator = i == 0 ? *pipeline.source : pipeline.operators[i - 1].get();
+		auto &current_operator = pipeline.operators[i].get();
 
 		auto chunk = make_uniq<DataChunk>();
-		chunk->Initialize(Allocator::Get(context.client), prev_operator->GetTypes());
+		chunk->Initialize(Allocator::Get(context.client), prev_operator.GetTypes());
 		intermediate_chunks.push_back(std::move(chunk));
 
-		auto op_state = current_operator->GetOperatorState(context);
+		auto op_state = current_operator.GetOperatorState(context);
 		intermediate_states.push_back(std::move(op_state));
 
-		if (current_operator->IsSink() && current_operator->sink_state->state == SinkFinalizeType::NO_OUTPUT_POSSIBLE) {
+		if (current_operator.IsSink() && current_operator.sink_state->state == SinkFinalizeType::NO_OUTPUT_POSSIBLE) {
 			// one of the operators has already figured out no output is possible
 			// we can skip executing the pipeline
 			FinishProcessing();
@@ -98,11 +98,11 @@ OperatorResultType PipelineExecutor::ExecutePushInternal(DataChunk &input, idx_t
 		}
 		auto &sink_chunk = final_chunk;
 		if (sink_chunk.size() > 0) {
-			StartOperator(pipeline.sink);
+			StartOperator(*pipeline.sink);
 			D_ASSERT(pipeline.sink);
 			D_ASSERT(pipeline.sink->sink_state);
 			auto sink_result = pipeline.sink->Sink(context, *pipeline.sink->sink_state, *local_sink_state, sink_chunk);
-			EndOperator(pipeline.sink, nullptr);
+			EndOperator(*pipeline.sink, nullptr);
 			if (sink_result == SinkResultType::FINISHED) {
 				FinishProcessing();
 				return OperatorResultType::FINISHED;
@@ -118,7 +118,7 @@ OperatorResultType PipelineExecutor::ExecutePushInternal(DataChunk &input, idx_t
 void PipelineExecutor::FlushCachingOperatorsPush() {
 	idx_t start_idx = IsFinished() ? idx_t(finished_processing_idx) : 0;
 	for (idx_t op_idx = start_idx; op_idx < pipeline.operators.size(); op_idx++) {
-		if (!pipeline.operators[op_idx]->RequiresFinalExecute()) {
+		if (!pipeline.operators[op_idx].get().RequiresFinalExecute()) {
 			continue;
 		}
 
@@ -128,10 +128,10 @@ void PipelineExecutor::FlushCachingOperatorsPush() {
 		do {
 			auto &curr_chunk =
 			    op_idx + 1 >= intermediate_chunks.size() ? final_chunk : *intermediate_chunks[op_idx + 1];
-			auto current_operator = pipeline.operators[op_idx];
+			auto &current_operator = pipeline.operators[op_idx].get();
 			StartOperator(current_operator);
-			finalize_result = current_operator->FinalExecute(context, curr_chunk, *current_operator->op_state,
-			                                                 *intermediate_states[op_idx]);
+			finalize_result = current_operator.FinalExecute(context, curr_chunk, *current_operator.op_state,
+			                                                *intermediate_states[op_idx]);
 			EndOperator(current_operator, &curr_chunk);
 			push_result = ExecutePushInternal(curr_chunk, op_idx + 1);
 		} while (finalize_result != OperatorFinalizeResultType::FINISHED &&
@@ -162,7 +162,7 @@ void PipelineExecutor::PushFinalize() {
 
 	// flush all query profiler info
 	for (idx_t i = 0; i < intermediate_states.size(); i++) {
-		intermediate_states[i]->Finalize(pipeline.operators[i], context);
+		intermediate_states[i]->Finalize(pipeline.operators[i].get(), context);
 	}
 	pipeline.executor.Flush(thread);
 	local_sink_state.reset();
@@ -263,13 +263,13 @@ OperatorResultType PipelineExecutor::Execute(DataChunk &input, DataChunk &result
 			auto &prev_chunk =
 			    current_intermediate == initial_idx + 1 ? input : *intermediate_chunks[current_intermediate - 1];
 			auto operator_idx = current_idx - 1;
-			auto current_operator = pipeline.operators[operator_idx];
+			auto &current_operator = pipeline.operators[operator_idx].get();
 
 			// if current_idx > source_idx, we pass the previous' operators output through the Execute of the current
 			// operator
 			StartOperator(current_operator);
-			auto result = current_operator->Execute(context, prev_chunk, current_chunk, *current_operator->op_state,
-			                                        *intermediate_states[current_intermediate - 1]);
+			auto result = current_operator.Execute(context, prev_chunk, current_chunk, *current_operator.op_state,
+			                                       *intermediate_states[current_intermediate - 1]);
 			EndOperator(current_operator, &current_chunk);
 			if (result == OperatorResultType::HAVE_MORE_OUTPUT) {
 				// more data remains in this operator
@@ -308,7 +308,7 @@ OperatorResultType PipelineExecutor::Execute(DataChunk &input, DataChunk &result
 }
 
 void PipelineExecutor::FetchFromSource(DataChunk &result) {
-	StartOperator(pipeline.source);
+	StartOperator(*pipeline.source);
 	pipeline.source->GetData(context, result, *pipeline.source_state, *local_source_state);
 	if (result.size() != 0 && requires_batch_index) {
 		auto next_batch_index =
@@ -318,22 +318,22 @@ void PipelineExecutor::FetchFromSource(DataChunk &result) {
 		         local_sink_state->batch_index == DConstants::INVALID_INDEX);
 		local_sink_state->batch_index = next_batch_index;
 	}
-	EndOperator(pipeline.source, &result);
+	EndOperator(*pipeline.source, &result);
 }
 
 void PipelineExecutor::InitializeChunk(DataChunk &chunk) {
-	PhysicalOperator *last_op = pipeline.operators.empty() ? pipeline.source : pipeline.operators.back();
-	chunk.Initialize(Allocator::DefaultAllocator(), last_op->GetTypes());
+	auto &last_op = pipeline.operators.empty() ? *pipeline.source : pipeline.operators.back().get();
+	chunk.Initialize(Allocator::DefaultAllocator(), last_op.GetTypes());
 }
 
-void PipelineExecutor::StartOperator(PhysicalOperator *op) {
+void PipelineExecutor::StartOperator(PhysicalOperator &op) {
 	if (context.client.interrupted) {
 		throw InterruptException();
 	}
-	context.thread.profiler.StartOperator(op);
+	context.thread.profiler.StartOperator(&op);
 }
 
-void PipelineExecutor::EndOperator(PhysicalOperator *op, DataChunk *chunk) {
+void PipelineExecutor::EndOperator(PhysicalOperator &op, optional_ptr<DataChunk> chunk) {
 	context.thread.profiler.EndOperator(chunk);
 
 	if (chunk) {

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

@@ -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,
@@ -214,7 +208,7 @@ unique_ptr<ParsedExpression> BindContext::CreateColumnReference(const string &ca
 		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;
@@ -301,7 +296,7 @@ BindResult BindContext::BindColumn(PositionalReferenceExpression &ref, idx_t dep
 	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()) {
@@ -328,16 +323,17 @@ void BindContext::GenerateAllColumnExpressions(StarExpression &expr,
 	if (expr.relation_name.empty()) {
 		// SELECT * case
 		// bind all expressions of each table in-order
-		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)) {
+			auto &binding = entry.get();
+			for (auto &column_name : binding.names) {
+				if (CheckExclusionList(expr, column_name, new_select_list, excluded_columns)) {
 					continue;
 				}
 				// 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()) {
@@ -345,10 +341,10 @@ 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_uniq<OperatorExpression>(ExpressionType::OPERATOR_COALESCE);
-						for (auto &child_binding : using_binding->bindings) {
+						for (auto &child_binding : using_binding.bindings) {
 							coalesce->children.push_back(make_uniq<ColumnRefExpression>(column_name, child_binding));
 						}
 						coalesce->alias = column_name;
@@ -356,12 +352,12 @@ void BindContext::GenerateAllColumnExpressions(StarExpression &expr,
 					} else {
 						// primary binding: output the qualified column ref
 						new_select_list.push_back(
-						    make_uniq<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_uniq<ColumnRefExpression>(column_name, binding->alias));
+				new_select_list.push_back(make_uniq<ColumnRefExpression>(column_name, binding.alias));
 			}
 		}
 	} else {
@@ -391,7 +387,7 @@ 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;
@@ -399,7 +395,7 @@ void BindContext::GenerateAllColumnExpressions(StarExpression &expr,
 			}
 		} 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;
 				}
 
@@ -423,7 +419,7 @@ 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.second;
+		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]);
@@ -436,7 +432,7 @@ 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);
 }
 
@@ -527,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
@@ -543,19 +539,19 @@ void BindContext::AddContext(BindContext other) {
 	}
 }
 
-void BindContext::RemoveContext(vector<std::pair<string, duckdb::Binding *>> &other_bindings_list) {
+void BindContext::RemoveContext(vector<reference<Binding>> &other_bindings_list) {
 	for (auto &other_binding : other_bindings_list) {
-		if (bindings.find(other_binding.first) != bindings.end()) {
-			bindings.erase(other_binding.first);
-		}
+		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());
 	}
 
-	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());
+		auto &alias = other_binding.get().alias;
+		if (bindings.find(alias) != bindings.end()) {
+			bindings.erase(alias);
+		}
 	}
 }
 

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

@@ -509,9 +509,8 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 			throw BinderException("Can only create an index over a base table!");
 		}
 		auto &table_binding = bound_table->Cast<BoundBaseTableRef>();
-		;
-		auto table = table_binding.table;
-		if (table->temporary) {
+		auto &table = table_binding.table;
+		if (table.temporary) {
 			stmt.info->temporary = true;
 		}
 		// create a plan over the bound table
@@ -520,13 +519,13 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 			throw BinderException("Cannot create index on a view!");
 		}
 
-		result.plan = table->catalog->BindCreateIndex(*this, stmt, *table, std::move(plan));
+		result.plan = table.catalog->BindCreateIndex(*this, stmt, table, std::move(plan));
 		break;
 	}
 	case CatalogType::TABLE_ENTRY: {
 		auto &create_info = (CreateTableInfo &)*stmt.info;
 		// If there is a foreign key constraint, resolve primary key column's index from primary key column's name
-		unordered_set<SchemaCatalogEntry *> fk_schemas;
+		reference_set_t<SchemaCatalogEntry> fk_schemas;
 		for (idx_t i = 0; i < create_info.constraints.size(); i++) {
 			auto &cond = create_info.constraints[i];
 			if (cond->type != ConstraintType::FOREIGN_KEY) {
@@ -549,7 +548,7 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 				// have to resolve referenced table
 				auto pk_table_entry_ptr =
 				    Catalog::GetEntry<TableCatalogEntry>(context, INVALID_CATALOG, fk.info.schema, fk.info.table);
-				fk_schemas.insert(pk_table_entry_ptr->schema);
+				fk_schemas.insert(*pk_table_entry_ptr->schema);
 				FindMatchingPrimaryKeyColumns(pk_table_entry_ptr->GetColumns(), pk_table_entry_ptr->GetConstraints(),
 				                              fk);
 				FindForeignKeyIndexes(pk_table_entry_ptr->GetColumns(), fk.pk_columns, fk.info.pk_keys);
@@ -574,7 +573,7 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 		auto bound_info = BindCreateTableInfo(std::move(stmt.info));
 		auto root = std::move(bound_info->query);
 		for (auto &fk_schema : fk_schemas) {
-			if (fk_schema != bound_info->schema) {
+			if (&fk_schema.get() != &bound_info->schema) {
 				throw BinderException("Creating foreign keys across different schemas or catalogs is not supported");
 			}
 		}

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

@@ -253,8 +253,7 @@ static void ExtractDependencies(BoundCreateTableInfo &info) {
 }
 unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateInfo> info, SchemaCatalogEntry &schema) {
 	auto &base = (CreateTableInfo &)*info;
-	auto result = make_uniq<BoundCreateTableInfo>(std::move(info));
-	result->schema = &schema;
+	auto result = make_uniq<BoundCreateTableInfo>(schema, std::move(info));
 	if (base.query) {
 		// construct the result object
 		auto query_obj = Bind(*base.query);
@@ -292,7 +291,7 @@ unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateIn
 		if (column.Type().id() == LogicalTypeId::VARCHAR) {
 			ExpressionBinder::TestCollation(context, StringType::GetCollation(column.Type()));
 		}
-		BindLogicalType(context, column.TypeMutable(), result->schema->catalog);
+		BindLogicalType(context, column.TypeMutable(), result->schema.catalog);
 		// We add a catalog dependency
 		auto type_dependency = LogicalType::GetCatalog(column.Type());
 		if (type_dependency) {
@@ -311,12 +310,11 @@ unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateIn
 	return BindCreateTableInfo(std::move(info), schema);
 }
 
-vector<unique_ptr<Expression>> Binder::BindCreateIndexExpressions(TableCatalogEntry *table, CreateIndexInfo *info) {
-
-	auto index_binder = IndexBinder(*this, this->context, table, info);
+vector<unique_ptr<Expression>> Binder::BindCreateIndexExpressions(TableCatalogEntry &table, CreateIndexInfo &info) {
+	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.reserve(info.expressions.size());
+	for (auto &expr : info.expressions) {
 		expressions.push_back(index_binder.Bind(expr));
 	}