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

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

@@ -21,16 +21,15 @@ BoundStatement Binder::Bind(DeleteStatement &stmt) {
 		throw BinderException("Can only delete from base table!");
 	}
 	auto &table_binding = bound_table->Cast<BoundBaseTableRef>();
-	;
-	auto table = table_binding.table;
+	auto &table = table_binding.table;
 
 	auto root = CreatePlan(*bound_table);
 	auto &get = root->Cast<LogicalGet>();
 	D_ASSERT(root->type == LogicalOperatorType::LOGICAL_GET);
 
-	if (!table->temporary) {
+	if (!table.temporary) {
 		// delete from persistent table: not read only!
-		properties.modified_databases.insert(table->catalog->GetName());
+		properties.modified_databases.insert(table.catalog->GetName());
 	}
 
 	// Add CTEs as bindable

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

@@ -352,8 +352,8 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl
 		// Get the column_ids we need to fetch later on from the conflicting tuples
 		// of the original table, to execute the expressions
 		D_ASSERT(original_binding->binding_type == BindingType::TABLE);
-		auto table_binding = (TableBinding *)original_binding;
-		insert.columns_to_fetch = table_binding->GetBoundColumnIds();
+		auto &table_binding = (TableBinding &)*original_binding;
+		insert.columns_to_fetch = table_binding.GetBoundColumnIds();
 		return;
 	}
 
@@ -378,8 +378,8 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl
 	// Get the column_ids we need to fetch later on from the conflicting tuples
 	// of the original table, to execute the expressions
 	D_ASSERT(original_binding->binding_type == BindingType::TABLE);
-	auto table_binding = (TableBinding *)original_binding;
-	insert.columns_to_fetch = table_binding->GetBoundColumnIds();
+	auto &table_binding = (TableBinding &)*original_binding;
+	insert.columns_to_fetch = table_binding.GetBoundColumnIds();
 
 	// Replace the column bindings to refer to the child operator
 	for (auto &expr : insert.expressions) {
@@ -398,11 +398,10 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 	result.types = {LogicalType::BIGINT};
 
 	BindSchemaOrCatalog(stmt.catalog, stmt.schema);
-	auto table = Catalog::GetEntry<TableCatalogEntry>(context, stmt.catalog, stmt.schema, stmt.table);
-	D_ASSERT(table);
-	if (!table->temporary) {
+	auto &table = *Catalog::GetEntry<TableCatalogEntry>(context, stmt.catalog, stmt.schema, stmt.table);
+	if (!table.temporary) {
 		// inserting into a non-temporary table: alters underlying database
-		properties.modified_databases.insert(table->catalog->GetName());
+		properties.modified_databases.insert(table.catalog->GetName());
 	}
 
 	auto insert = make_uniq<LogicalInsert>(table, GenerateTableIndex());
@@ -417,18 +416,18 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 		case_insensitive_map_t<idx_t> column_name_map;
 		for (idx_t i = 0; i < stmt.columns.size(); i++) {
 			column_name_map[stmt.columns[i]] = i;
-			auto column_index = table->GetColumnIndex(stmt.columns[i]);
+			auto column_index = table.GetColumnIndex(stmt.columns[i]);
 			if (column_index.index == COLUMN_IDENTIFIER_ROW_ID) {
 				throw BinderException("Cannot explicitly insert values into rowid column");
 			}
-			auto &col = table->GetColumn(column_index);
+			auto &col = table.GetColumn(column_index);
 			if (col.Generated()) {
 				throw BinderException("Cannot insert into a generated column");
 			}
 			insert->expected_types.push_back(col.Type());
 			named_column_map.push_back(column_index);
 		}
-		for (auto &col : table->GetColumns().Physical()) {
+		for (auto &col : table.GetColumns().Physical()) {
 			auto entry = column_name_map.find(col.Name());
 			if (entry == column_name_map.end()) {
 				// column not specified, set index to DConstants::INVALID_INDEX
@@ -441,21 +440,21 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 	} else {
 		// No columns specified, assume insertion into all columns
 		// Intentionally don't populate 'column_index_map' as an indication of this
-		for (auto &col : table->GetColumns().Physical()) {
+		for (auto &col : table.GetColumns().Physical()) {
 			named_column_map.push_back(col.Logical());
 			insert->expected_types.push_back(col.Type());
 		}
 	}
 
 	// bind the default values
-	BindDefaultValues(table->GetColumns(), insert->bound_defaults);
+	BindDefaultValues(table.GetColumns(), insert->bound_defaults);
 	if (!stmt.select_statement) {
 		result.plan = std::move(insert);
 		return result;
 	}
 
 	// Exclude the generated columns from this amount
-	idx_t expected_columns = stmt.columns.empty() ? table->GetColumns().PhysicalColumnCount() : stmt.columns.size();
+	idx_t expected_columns = stmt.columns.empty() ? table.GetColumns().PhysicalColumnCount() : stmt.columns.size();
 
 	// special case: check if we are inserting from a VALUES statement
 	auto values_list = stmt.GetValuesList();
@@ -466,7 +465,7 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 
 		D_ASSERT(expr_list.values.size() > 0);
 		CheckInsertColumnCountMismatch(expected_columns, expr_list.values[0].size(), !stmt.columns.empty(),
-		                               table->name.c_str());
+		                               table.name.c_str());
 
 		// VALUES list!
 		for (idx_t col_idx = 0; col_idx < expected_columns; col_idx++) {
@@ -474,7 +473,7 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 			auto &table_col_idx = named_column_map[col_idx];
 
 			// set the expected types as the types for the INSERT statement
-			auto &column = table->GetColumn(table_col_idx);
+			auto &column = table.GetColumn(table_col_idx);
 			expr_list.expected_types[col_idx] = column.Type();
 			expr_list.expected_names[col_idx] = column.Name();
 
@@ -494,12 +493,12 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 	MoveCorrelatedExpressions(*select_binder);
 
 	CheckInsertColumnCountMismatch(expected_columns, root_select.types.size(), !stmt.columns.empty(),
-	                               table->name.c_str());
+	                               table.name.c_str());
 
 	auto root = CastLogicalOperatorToTypes(root_select.types, insert->expected_types, std::move(root_select.plan));
 	insert->AddChild(std::move(root));
 
-	BindOnConflictClause(*insert, *table, stmt);
+	BindOnConflictClause(*insert, table, stmt);
 
 	if (!stmt.returning_list.empty()) {
 		insert->return_chunk = true;

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

@@ -135,8 +135,8 @@ static void BindUpdateConstraints(TableCatalogEntry &table, LogicalGet &get, Log
 
 // This creates a LogicalProjection and moves 'root' into it as a child
 // unless there are no expressions to project, in which case it just returns 'root'
-unique_ptr<LogicalOperator> Binder::BindUpdateSet(LogicalOperator *op, unique_ptr<LogicalOperator> root,
-                                                  UpdateSetInfo &set_info, TableCatalogEntry *table,
+unique_ptr<LogicalOperator> Binder::BindUpdateSet(LogicalOperator &op, unique_ptr<LogicalOperator> root,
+                                                  UpdateSetInfo &set_info, TableCatalogEntry &table,
                                                   vector<PhysicalIndex> &columns) {
 	auto proj_index = GenerateTableIndex();
 
@@ -145,10 +145,10 @@ unique_ptr<LogicalOperator> Binder::BindUpdateSet(LogicalOperator *op, unique_pt
 	for (idx_t i = 0; i < set_info.columns.size(); i++) {
 		auto &colname = set_info.columns[i];
 		auto &expr = set_info.expressions[i];
-		if (!table->ColumnExists(colname)) {
+		if (!table.ColumnExists(colname)) {
 			throw BinderException("Referenced update column %s not found in table!", colname);
 		}
-		auto &column = table->GetColumn(colname);
+		auto &column = table.GetColumn(colname);
 		if (column.Generated()) {
 			throw BinderException("Cant update column \"%s\" because it is a generated column!", column.Name());
 		}
@@ -157,19 +157,19 @@ unique_ptr<LogicalOperator> Binder::BindUpdateSet(LogicalOperator *op, unique_pt
 		}
 		columns.push_back(column.Physical());
 		if (expr->type == ExpressionType::VALUE_DEFAULT) {
-			op->expressions.push_back(make_uniq<BoundDefaultExpression>(column.Type()));
+			op.expressions.push_back(make_uniq<BoundDefaultExpression>(column.Type()));
 		} else {
 			UpdateBinder binder(*this, context);
 			binder.target_type = column.Type();
 			auto bound_expr = binder.Bind(expr);
 			PlanSubqueries(&bound_expr, &root);
 
-			op->expressions.push_back(make_uniq<BoundColumnRefExpression>(
+			op.expressions.push_back(make_uniq<BoundColumnRefExpression>(
 			    bound_expr->return_type, ColumnBinding(proj_index, projection_expressions.size())));
 			projection_expressions.push_back(std::move(bound_expr));
 		}
 	}
-	if (op->type != LogicalOperatorType::LOGICAL_UPDATE && projection_expressions.empty()) {
+	if (op.type != LogicalOperatorType::LOGICAL_UPDATE && projection_expressions.empty()) {
 		return root;
 	}
 	// now create the projection
@@ -181,7 +181,6 @@ unique_ptr<LogicalOperator> Binder::BindUpdateSet(LogicalOperator *op, unique_pt
 BoundStatement Binder::Bind(UpdateStatement &stmt) {
 	BoundStatement result;
 	unique_ptr<LogicalOperator> root;
-	LogicalGet *get;
 
 	// visit the table reference
 	auto bound_table = Bind(*stmt.table);
@@ -189,28 +188,28 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 		throw BinderException("Can only update base table!");
 	}
 	auto &table_binding = bound_table->Cast<BoundBaseTableRef>();
-	;
-	auto table = table_binding.table;
+	auto &table = table_binding.table;
 
 	// Add CTEs as bindable
 	AddCTEMap(stmt.cte_map);
 
+	optional_ptr<LogicalGet> get;
 	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 = from_binder->Bind(*stmt.from_table);
 		root = CreatePlan(bound_crossproduct);
-		get = (LogicalGet *)root->children[0].get();
+		get = &root->children[0]->Cast<LogicalGet>();
 		bind_context.AddContext(std::move(from_binder->bind_context));
 	} else {
 		root = CreatePlan(*bound_table);
-		get = (LogicalGet *)root.get();
+		get = &root->Cast<LogicalGet>();
 	}
 
-	if (!table->temporary) {
+	if (!table.temporary) {
 		// update of persistent table: not read only!
-		properties.modified_databases.insert(table->catalog->GetName());
+		properties.modified_databases.insert(table.catalog->GetName());
 	}
 	auto update = make_uniq<LogicalUpdate>(table);
 
@@ -219,7 +218,7 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 		update->return_chunk = true;
 	}
 	// bind the default values
-	BindDefaultValues(table->GetColumns(), update->bound_defaults);
+	BindDefaultValues(table.GetColumns(), update->bound_defaults);
 
 	// project any additional columns required for the condition/expressions
 	if (stmt.set_info->condition) {
@@ -235,12 +234,12 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 	D_ASSERT(stmt.set_info);
 	D_ASSERT(stmt.set_info->columns.size() == stmt.set_info->expressions.size());
 
-	auto proj_tmp = BindUpdateSet(update.get(), std::move(root), *stmt.set_info, table, update->columns);
+	auto proj_tmp = BindUpdateSet(*update, std::move(root), *stmt.set_info, table, update->columns);
 	D_ASSERT(proj_tmp->type == LogicalOperatorType::LOGICAL_PROJECTION);
 	auto proj = unique_ptr_cast<LogicalOperator, LogicalProjection>(std::move(proj_tmp));
 
 	// bind any extra columns necessary for CHECK constraints or indexes
-	BindUpdateConstraints(*table, *get, *proj, *update);
+	BindUpdateConstraints(table, *get, *proj, *update);
 	// finally add the row id column to the projection list
 	proj->expressions.push_back(make_uniq<BoundColumnRefExpression>(
 	    LogicalType::ROW_TYPE, ColumnBinding(get->table_index, get->column_ids.size())));

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

@@ -21,7 +21,8 @@ BoundStatement Binder::Bind(VacuumStatement &stmt) {
 			throw InvalidInputException("Can only vacuum/analyze base tables!");
 		}
 		auto ref = unique_ptr_cast<BoundTableRef, BoundBaseTableRef>(std::move(bound_table));
-		stmt.info->table = ref->table;
+		auto &table = ref->table;
+		stmt.info->table = &table;
 
 		auto &columns = stmt.info->columns;
 		vector<unique_ptr<Expression>> select_list;
@@ -38,16 +39,16 @@ BoundStatement Binder::Bind(VacuumStatement &stmt) {
 				throw BinderException("Vacuum the same column twice(same name in column name list)");
 			}
 			column_name_set.insert(col_name);
-			if (!ref->table->ColumnExists(col_name)) {
+			if (!table.ColumnExists(col_name)) {
 				throw BinderException("Column with name \"%s\" does not exist", col_name);
 			}
-			auto &col = ref->table->GetColumn(col_name);
+			auto &col = table.GetColumn(col_name);
 			// ignore generated column
 			if (col.Generated()) {
 				continue;
 			}
 			non_generated_column_names.push_back(col_name);
-			ColumnRefExpression colref(col_name, ref->table->name);
+			ColumnRefExpression colref(col_name, table.name);
 			auto result = bind_context.BindColumn(colref, 0);
 			if (result.HasError()) {
 				throw BinderException(result.error);
@@ -65,7 +66,7 @@ BoundStatement Binder::Bind(VacuumStatement &stmt) {
 			D_ASSERT(stmt.info->columns.size() == get.column_ids.size());
 			for (idx_t i = 0; i < get.column_ids.size(); i++) {
 				stmt.info->column_id_map[i] =
-				    ref->table->GetColumns().LogicalToPhysical(LogicalIndex(get.column_ids[i])).index;
+				    table.GetColumns().LogicalToPhysical(LogicalIndex(get.column_ids[i])).index;
 			}
 
 			auto projection = make_uniq<LogicalProjection>(GenerateTableIndex(), std::move(select_list));

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

@@ -117,10 +117,10 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 	case CatalogType::TABLE_ENTRY: {
 		// base table: create the BoundBaseTableRef node
 		auto table_index = GenerateTableIndex();
-		auto table = (TableCatalogEntry *)table_or_view;
+		auto &table = table_or_view->Cast<TableCatalogEntry>();
 
 		unique_ptr<FunctionData> bind_data;
-		auto scan_function = table->GetScanFunction(context, bind_data);
+		auto scan_function = table.GetScanFunction(context, bind_data);
 		auto alias = ref.alias.empty() ? ref.table_name : ref.alias;
 		// TODO: bundle the type and name vector in a struct (e.g PackedColumnMetadata)
 		vector<LogicalType> table_types;
@@ -129,7 +129,7 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 
 		vector<LogicalType> return_types;
 		vector<string> return_names;
-		for (auto &col : table->GetColumns().Logical()) {
+		for (auto &col : table.GetColumns().Logical()) {
 			table_types.push_back(col.Type());
 			table_names.push_back(col.Name());
 			return_types.push_back(col.Type());
@@ -145,19 +145,19 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 	}
 	case CatalogType::VIEW_ENTRY: {
 		// the node is a view: get the query that the view represents
-		auto view_catalog_entry = (ViewCatalogEntry *)table_or_view;
+		auto &view_catalog_entry = table_or_view->Cast<ViewCatalogEntry>();
 		// We need to use a new binder for the view that doesn't reference any CTEs
 		// defined for this binder so there are no collisions between the CTEs defined
 		// for the view and for the current query
 		bool inherit_ctes = false;
 		auto view_binder = Binder::CreateBinder(context, this, inherit_ctes);
 		view_binder->can_contain_nulls = true;
-		SubqueryRef subquery(unique_ptr_cast<SQLStatement, SelectStatement>(view_catalog_entry->query->Copy()));
+		SubqueryRef subquery(unique_ptr_cast<SQLStatement, SelectStatement>(view_catalog_entry.query->Copy()));
 		subquery.alias = ref.alias.empty() ? ref.table_name : ref.alias;
 		subquery.column_name_alias =
-		    BindContext::AliasColumnNames(subquery.alias, view_catalog_entry->aliases, ref.column_name_alias);
+		    BindContext::AliasColumnNames(subquery.alias, view_catalog_entry.aliases, ref.column_name_alias);
 		// bind the child subquery
-		view_binder->AddBoundView(*view_catalog_entry);
+		view_binder->AddBoundView(view_catalog_entry);
 		auto bound_child = view_binder->Bind(subquery);
 		if (!view_binder->correlated_columns.empty()) {
 			throw BinderException("Contents of view were altered - view bound correlated columns");
@@ -167,11 +167,11 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 		// verify that the types and names match up with the expected types and names
 		auto &bound_subquery = bound_child->Cast<BoundSubqueryRef>();
 		if (GetBindingMode() != BindingMode::EXTRACT_NAMES &&
-		    bound_subquery.subquery->types != view_catalog_entry->types) {
+		    bound_subquery.subquery->types != view_catalog_entry.types) {
 			throw BinderException("Contents of view were altered: types don't match!");
 		}
 		bind_context.AddView(bound_subquery.subquery->GetRootIndex(), subquery.alias, subquery,
-		                     *bound_subquery.subquery, view_catalog_entry);
+		                     *bound_subquery.subquery, &view_catalog_entry);
 		return bound_child;
 	}
 	default:

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

@@ -68,7 +68,7 @@ string Binder::FindBinding(const string &using_column, const string &join_side)
 	return result;
 }
 
-static void AddUsingBindings(UsingColumnSet &set, UsingColumnSet *input_set, const string &input_binding) {
+static void AddUsingBindings(UsingColumnSet &set, optional_ptr<UsingColumnSet> input_set, const string &input_binding) {
 	if (input_set) {
 		for (auto &entry : input_set->bindings) {
 			set.bindings.insert(entry);
@@ -95,8 +95,8 @@ static void SetPrimaryBinding(UsingColumnSet &set, JoinType join_type, const str
 	}
 }
 
-string Binder::RetrieveUsingBinding(Binder &current_binder, UsingColumnSet *current_set, const string &using_column,
-                                    const string &join_side, UsingColumnSet *new_set) {
+string Binder::RetrieveUsingBinding(Binder &current_binder, optional_ptr<UsingColumnSet> current_set,
+                                    const string &using_column, const string &join_side) {
 	string binding;
 	if (!current_set) {
 		binding = current_binder.FindBinding(using_column, join_side);
@@ -150,7 +150,7 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 		case_insensitive_set_t lhs_columns;
 		auto &lhs_binding_list = left_binder.bind_context.GetBindingsList();
 		for (auto &binding : lhs_binding_list) {
-			for (auto &column_name : binding.second->names) {
+			for (auto &column_name : binding.get().names) {
 				lhs_columns.insert(column_name);
 			}
 		}
@@ -175,20 +175,22 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 			// gather all left/right candidates
 			string left_candidates, right_candidates;
 			auto &rhs_binding_list = right_binder.bind_context.GetBindingsList();
-			for (auto &binding : lhs_binding_list) {
-				for (auto &column_name : binding.second->names) {
+			for (auto &binding_ref : lhs_binding_list) {
+				auto &binding = binding_ref.get();
+				for (auto &column_name : binding.names) {
 					if (!left_candidates.empty()) {
 						left_candidates += ", ";
 					}
-					left_candidates += binding.first + "." + column_name;
+					left_candidates += binding.alias + "." + column_name;
 				}
 			}
-			for (auto &binding : rhs_binding_list) {
-				for (auto &column_name : binding.second->names) {
+			for (auto &binding_ref : rhs_binding_list) {
+				auto &binding = binding_ref.get();
+				for (auto &column_name : binding.names) {
 					if (!right_candidates.empty()) {
 						right_candidates += ", ";
 					}
-					right_candidates += binding.first + "." + column_name;
+					right_candidates += binding.alias + "." + column_name;
 				}
 			}
 			error_msg += "\n   Left candidates: " + left_candidates;
@@ -213,8 +215,8 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 	extra_using_columns = RemoveDuplicateUsingColumns(extra_using_columns);
 
 	if (!extra_using_columns.empty()) {
-		vector<UsingColumnSet *> left_using_bindings;
-		vector<UsingColumnSet *> right_using_bindings;
+		vector<optional_ptr<UsingColumnSet>> left_using_bindings;
+		vector<optional_ptr<UsingColumnSet>> right_using_bindings;
 		for (idx_t i = 0; i < extra_using_columns.size(); i++) {
 			auto &using_column = extra_using_columns[i];
 			// we check if there is ALREADY a using column of the same name in the left and right set
@@ -238,10 +240,10 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 			string right_binding;
 
 			auto set = make_uniq<UsingColumnSet>();
-			auto left_using_binding = left_using_bindings[i];
-			auto right_using_binding = right_using_bindings[i];
-			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());
+			auto &left_using_binding = left_using_bindings[i];
+			auto &right_using_binding = right_using_bindings[i];
+			left_binding = RetrieveUsingBinding(left_binder, left_using_binding, using_column, "left");
+			right_binding = RetrieveUsingBinding(right_binder, right_using_binding, using_column, "right");
 
 			// Last column of ASOF JOIN ... USING is >=
 			const auto type = (ref.ref_type == JoinRefType::ASOF && i == extra_using_columns.size() - 1)
@@ -254,9 +256,9 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 			AddUsingBindings(*set, left_using_binding, left_binding);
 			AddUsingBindings(*set, right_using_binding, right_binding);
 			SetPrimaryBinding(*set, ref.type, left_binding, right_binding);
-			bind_context.TransferUsingBinding(left_binder.bind_context, left_using_binding, set.get(), left_binding,
+			bind_context.TransferUsingBinding(left_binder.bind_context, left_using_binding, *set, left_binding,
 			                                  using_column);
-			bind_context.TransferUsingBinding(right_binder.bind_context, right_using_binding, set.get(), right_binding,
+			bind_context.TransferUsingBinding(right_binder.bind_context, right_using_binding, *set, right_binding,
 			                                  using_column);
 			AddUsingBindingSet(std::move(set));
 		}

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

@@ -278,7 +278,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundJoinRef &ref) {
 	auto result = LogicalComparisonJoin::CreateJoin(ref.type, ref.ref_type, std::move(left), std::move(right),
 	                                                std::move(ref.condition));
 
-	LogicalOperator *join;
+	optional_ptr<LogicalOperator> join;
 	if (result->type == LogicalOperatorType::LOGICAL_FILTER) {
 		join = result->children[0].get();
 	} else {

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

@@ -438,7 +438,7 @@ void VerifyNotExcluded(ParsedExpression &expr) {
 	    expr, [&](const ParsedExpression &child) { VerifyNotExcluded((ParsedExpression &)child); });
 }
 
-BoundStatement Binder::BindReturning(vector<unique_ptr<ParsedExpression>> returning_list, TableCatalogEntry *table,
+BoundStatement Binder::BindReturning(vector<unique_ptr<ParsedExpression>> returning_list, TableCatalogEntry &table,
                                      const string &alias, idx_t update_table_index,
                                      unique_ptr<LogicalOperator> child_operator, BoundStatement result) {
 
@@ -449,7 +449,7 @@ BoundStatement Binder::BindReturning(vector<unique_ptr<ParsedExpression>> return
 
 	vector<column_t> bound_columns;
 	idx_t column_count = 0;
-	for (auto &col : table->GetColumns().Logical()) {
+	for (auto &col : table.GetColumns().Logical()) {
 		names.push_back(col.Name());
 		types.push_back(col.Type());
 		if (!col.Generated()) {
@@ -458,8 +458,8 @@ BoundStatement Binder::BindReturning(vector<unique_ptr<ParsedExpression>> return
 		column_count++;
 	}
 
-	binder->bind_context.AddBaseTable(update_table_index, alias.empty() ? table->name : alias, names, types,
-	                                  bound_columns, table, false);
+	binder->bind_context.AddBaseTable(update_table_index, alias.empty() ? table.name : alias, names, types,
+	                                  bound_columns, &table, false);
 	ReturningBinder returning_binder(*binder, context);
 
 	vector<unique_ptr<Expression>> projection_expressions;

package/src/duckdb/src/planner/expression_binder/index_binder.cpp

@@ -7,7 +7,8 @@
 
 namespace duckdb {
 
-IndexBinder::IndexBinder(Binder &binder, ClientContext &context, TableCatalogEntry *table, CreateIndexInfo *info)
+IndexBinder::IndexBinder(Binder &binder, ClientContext &context, optional_ptr<TableCatalogEntry> table,
+                         optional_ptr<CreateIndexInfo> info)
     : ExpressionBinder(binder, context), table(table), info(info) {
 }
 

package/src/duckdb/src/planner/expression_binder/where_binder.cpp

@@ -1,15 +1,16 @@
 #include "duckdb/planner/expression_binder/where_binder.hpp"
 #include "duckdb/planner/expression_binder/column_alias_binder.hpp"
+#include "duckdb/parser/expression/columnref_expression.hpp"
 
 namespace duckdb {
 
-WhereBinder::WhereBinder(Binder &binder, ClientContext &context, ColumnAliasBinder *column_alias_binder)
+WhereBinder::WhereBinder(Binder &binder, ClientContext &context, optional_ptr<ColumnAliasBinder> column_alias_binder)
     : ExpressionBinder(binder, context), column_alias_binder(column_alias_binder) {
 	target_type = LogicalType(LogicalTypeId::BOOLEAN);
 }
 
 BindResult WhereBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
-	auto &expr = (ColumnRefExpression &)**expr_ptr;
+	auto &expr = (*expr_ptr)->Cast<ColumnRefExpression>();
 	auto result = ExpressionBinder::BindExpression(expr_ptr, depth);
 	if (!result.HasError() || !column_alias_binder) {
 		return result;

package/src/duckdb/src/planner/operator/logical_create_table.cpp

@@ -8,7 +8,7 @@ void LogicalCreateTable::Serialize(FieldWriter &writer) const {
 
 unique_ptr<LogicalOperator> LogicalCreateTable::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
 	auto info = reader.ReadRequiredSerializable<BoundCreateTableInfo>(state.gstate);
-	auto schema = info->schema;
+	auto &schema = info->schema;
 	return make_uniq<LogicalCreateTable>(schema, std::move(info));
 }
 

package/src/duckdb/src/planner/operator/logical_delete.cpp

@@ -4,13 +4,13 @@
 
 namespace duckdb {
 
-LogicalDelete::LogicalDelete(TableCatalogEntry *table, idx_t table_index)
+LogicalDelete::LogicalDelete(TableCatalogEntry &table, idx_t table_index)
     : LogicalOperator(LogicalOperatorType::LOGICAL_DELETE), table(table), table_index(table_index),
       return_chunk(false) {
 }
 
 void LogicalDelete::Serialize(FieldWriter &writer) const {
-	table->Serialize(writer.GetSerializer());
+	table.Serialize(writer.GetSerializer());
 	writer.WriteField(table_index);
 	writer.WriteField(return_chunk);
 }
@@ -23,7 +23,7 @@ unique_ptr<LogicalOperator> LogicalDelete::Deserialize(LogicalDeserializationSta
 	    Catalog::GetEntry<TableCatalogEntry>(context, INVALID_CATALOG, info->schema, info->table);
 
 	auto table_index = reader.ReadRequired<idx_t>();
-	auto result = make_uniq<LogicalDelete>(table_catalog_entry, table_index);
+	auto result = make_uniq<LogicalDelete>(*table_catalog_entry, table_index);
 	result->return_chunk = reader.ReadRequired<bool>();
 	return std::move(result);
 }
@@ -38,14 +38,14 @@ vector<idx_t> LogicalDelete::GetTableIndex() const {
 
 vector<ColumnBinding> LogicalDelete::GetColumnBindings() {
 	if (return_chunk) {
-		return GenerateColumnBindings(table_index, table->GetTypes().size());
+		return GenerateColumnBindings(table_index, table.GetTypes().size());
 	}
 	return {ColumnBinding(0, 0)};
 }
 
 void LogicalDelete::ResolveTypes() {
 	if (return_chunk) {
-		types = table->GetTypes();
+		types = table.GetTypes();
 	} else {
 		types.emplace_back(LogicalType::BIGINT);
 	}

package/src/duckdb/src/planner/operator/logical_insert.cpp

@@ -5,7 +5,7 @@
 
 namespace duckdb {
 
-LogicalInsert::LogicalInsert(TableCatalogEntry *table, idx_t table_index)
+LogicalInsert::LogicalInsert(TableCatalogEntry &table, idx_t table_index)
     : LogicalOperator(LogicalOperatorType::LOGICAL_INSERT), table(table), table_index(table_index), return_chunk(false),
       action_type(OnConflictAction::THROW) {
 }
@@ -18,7 +18,7 @@ void LogicalInsert::Serialize(FieldWriter &writer) const {
 
 	writer.WriteList<idx_t>(column_index_map);
 	writer.WriteRegularSerializableList(expected_types);
-	table->Serialize(writer.GetSerializer());
+	table.Serialize(writer.GetSerializer());
 	writer.WriteField(table_index);
 	writer.WriteField(return_chunk);
 	writer.WriteSerializableList(bound_defaults);
@@ -43,15 +43,14 @@ unique_ptr<LogicalOperator> LogicalInsert::Deserialize(LogicalDeserializationSta
 
 	auto &catalog = Catalog::GetCatalog(context, INVALID_CATALOG);
 
-	TableCatalogEntry *table_catalog_entry = catalog.GetEntry<TableCatalogEntry>(context, info->schema, info->table);
+	auto table_catalog_entry = catalog.GetEntry<TableCatalogEntry>(context, info->schema, info->table);
 
 	if (!table_catalog_entry) {
 		throw InternalException("Cant find catalog entry for table %s", info->table);
 	}
 
-	auto result = make_uniq<LogicalInsert>(table_catalog_entry, table_index);
+	auto result = make_uniq<LogicalInsert>(*table_catalog_entry, table_index);
 	result->type = state.type;
-	result->table = table_catalog_entry;
 	result->return_chunk = return_chunk;
 	result->insert_values = std::move(insert_values);
 	result->column_index_map = column_index_map;
@@ -71,14 +70,14 @@ vector<idx_t> LogicalInsert::GetTableIndex() const {
 
 vector<ColumnBinding> LogicalInsert::GetColumnBindings() {
 	if (return_chunk) {
-		return GenerateColumnBindings(table_index, table->GetTypes().size());
+		return GenerateColumnBindings(table_index, table.GetTypes().size());
 	}
 	return {ColumnBinding(0, 0)};
 }
 
 void LogicalInsert::ResolveTypes() {
 	if (return_chunk) {
-		types = table->GetTypes();
+		types = table.GetTypes();
 	} else {
 		types.emplace_back(LogicalType::BIGINT);
 	}