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

package/src/duckdb/src/include/duckdb/parallel/pipeline.hpp

@@ -9,10 +9,10 @@
 #pragma once
 
 #include "duckdb/common/atomic.hpp"
-#include "duckdb/common/unordered_set.hpp"
 #include "duckdb/execution/physical_operator.hpp"
 #include "duckdb/function/table_function.hpp"
 #include "duckdb/parallel/task_scheduler.hpp"
+#include "duckdb/common/reference_map.hpp"
 
 namespace duckdb {
 
@@ -27,18 +27,18 @@ public:
 
 public:
 	//! Duplicate eliminated join scan dependencies
-	unordered_map<PhysicalOperator *, Pipeline *> delim_join_dependencies;
+	reference_map_t<const PhysicalOperator, reference<Pipeline>> delim_join_dependencies;
 
 public:
-	void SetPipelineSource(Pipeline &pipeline, PhysicalOperator *op);
-	void SetPipelineSink(Pipeline &pipeline, PhysicalOperator *op, idx_t sink_pipeline_count);
-	void SetPipelineOperators(Pipeline &pipeline, vector<PhysicalOperator *> operators);
-	void AddPipelineOperator(Pipeline &pipeline, PhysicalOperator *op);
-	shared_ptr<Pipeline> CreateChildPipeline(Executor &executor, Pipeline &pipeline, PhysicalOperator *op);
-
-	PhysicalOperator *GetPipelineSource(Pipeline &pipeline);
-	PhysicalOperator *GetPipelineSink(Pipeline &pipeline);
-	vector<PhysicalOperator *> GetPipelineOperators(Pipeline &pipeline);
+	void SetPipelineSource(Pipeline &pipeline, PhysicalOperator &op);
+	void SetPipelineSink(Pipeline &pipeline, optional_ptr<PhysicalOperator> op, idx_t sink_pipeline_count);
+	void SetPipelineOperators(Pipeline &pipeline, vector<reference<PhysicalOperator>> operators);
+	void AddPipelineOperator(Pipeline &pipeline, PhysicalOperator &op);
+	shared_ptr<Pipeline> CreateChildPipeline(Executor &executor, Pipeline &pipeline, PhysicalOperator &op);
+
+	optional_ptr<PhysicalOperator> GetPipelineSource(Pipeline &pipeline);
+	optional_ptr<PhysicalOperator> GetPipelineSink(Pipeline &pipeline);
+	vector<reference<PhysicalOperator>> GetPipelineOperators(Pipeline &pipeline);
 };
 
 //! The Pipeline class represents an execution pipeline starting at a
@@ -80,13 +80,14 @@ public:
 	bool GetProgress(double &current_percentage, idx_t &estimated_cardinality);
 
 	//! Returns a list of all operators (including source and sink) involved in this pipeline
-	vector<PhysicalOperator *> GetOperators() const;
+	vector<reference<PhysicalOperator>> GetOperators();
+	vector<const_reference<PhysicalOperator>> GetOperators() const;
 
-	PhysicalOperator *GetSink() {
+	optional_ptr<PhysicalOperator> GetSink() {
 		return sink;
 	}
 
-	PhysicalOperator *GetSource() {
+	optional_ptr<PhysicalOperator> GetSource() {
 		return source;
 	}
 
@@ -99,11 +100,11 @@ private:
 	//! Whether or not the pipeline has been initialized
 	atomic<bool> initialized;
 	//! The source of this pipeline
-	PhysicalOperator *source = nullptr;
+	optional_ptr<PhysicalOperator> source;
 	//! The chain of intermediate operators
-	vector<PhysicalOperator *> operators;
+	vector<reference<PhysicalOperator>> operators;
 	//! The sink (i.e. destination) for data; this is e.g. a hash table to-be-built
-	PhysicalOperator *sink = nullptr;
+	optional_ptr<PhysicalOperator> sink;
 
 	//! The global source state
 	unique_ptr<GlobalSourceState> source_state;

package/src/duckdb/src/include/duckdb/parallel/pipeline_executor.hpp

@@ -80,8 +80,8 @@ private:
 	bool requires_batch_index = false;
 
 private:
-	void StartOperator(PhysicalOperator *op);
-	void EndOperator(PhysicalOperator *op, DataChunk *chunk);
+	void StartOperator(PhysicalOperator &op);
+	void EndOperator(PhysicalOperator &op, optional_ptr<DataChunk> chunk);
 
 	//! Reset the operator index to the first operator
 	void GoToSource(idx_t &current_idx, idx_t initial_idx);

package/src/duckdb/src/include/duckdb/planner/bind_context.hpp

@@ -10,8 +10,7 @@
 
 #include "duckdb/catalog/catalog.hpp"
 #include "duckdb/common/case_insensitive_map.hpp"
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/unordered_set.hpp"
+#include "duckdb/common/reference_map.hpp"
 #include "duckdb/parser/expression/columnref_expression.hpp"
 #include "duckdb/parser/parsed_expression.hpp"
 #include "duckdb/parser/qualified_name_set.hpp"
@@ -52,7 +51,7 @@ public:
 	//! matching ones
 	vector<string> GetSimilarBindings(const string &column_name);
 
-	Binding *GetCTEBinding(const string &ctename);
+	optional_ptr<Binding> GetCTEBinding(const string &ctename);
 	//! Binds a column expression to the base table. Returns the bound expression
 	//! or throws an exception if the column could not be bound.
 	BindResult BindColumn(ColumnRefExpression &colref, idx_t depth);
@@ -73,11 +72,11 @@ public:
 	void GenerateAllColumnExpressions(StarExpression &expr, vector<unique_ptr<ParsedExpression>> &new_select_list);
 	//! Check if the given (binding, column_name) is in the exclusion/replacement lists.
 	//! Returns true if it is in one of these lists, and should therefore be skipped.
-	bool CheckExclusionList(StarExpression &expr, Binding *binding, const string &column_name,
+	bool CheckExclusionList(StarExpression &expr, const string &column_name,
 	                        vector<unique_ptr<ParsedExpression>> &new_select_list,
 	                        case_insensitive_set_t &excluded_columns);
 
-	const vector<std::pair<string, Binding *>> &GetBindingsList() {
+	const vector<reference<Binding>> &GetBindingsList() {
 		return bindings_list;
 	}
 
@@ -107,22 +106,20 @@ public:
 	void AddCTEBinding(idx_t index, const string &alias, const vector<string> &names, const vector<LogicalType> &types);
 
 	//! Add an implicit join condition (e.g. USING (x))
-	void AddUsingBinding(const string &column_name, UsingColumnSet *set);
+	void AddUsingBinding(const string &column_name, UsingColumnSet &set);
 
 	void AddUsingBindingSet(unique_ptr<UsingColumnSet> set);
 
 	//! Returns any using column set for the given column name, or nullptr if there is none. On conflict (multiple using
 	//! column sets with the same name) throw an exception.
-	UsingColumnSet *GetUsingBinding(const string &column_name);
+	optional_ptr<UsingColumnSet> GetUsingBinding(const string &column_name);
 	//! Returns any using column set for the given column name, or nullptr if there is none
-	UsingColumnSet *GetUsingBinding(const string &column_name, const string &binding_name);
+	optional_ptr<UsingColumnSet> GetUsingBinding(const string &column_name, const string &binding_name);
 	//! Erase a using binding from the set of using bindings
-	void RemoveUsingBinding(const string &column_name, UsingColumnSet *set);
-	//! Finds the using bindings for a given column. Returns true if any exists, false otherwise.
-	bool FindUsingBinding(const string &column_name, unordered_set<UsingColumnSet *> **using_columns);
+	void RemoveUsingBinding(const string &column_name, UsingColumnSet &set);
 	//! Transfer a using binding from one bind context to this bind context
-	void TransferUsingBinding(BindContext &current_context, UsingColumnSet *current_set, UsingColumnSet *new_set,
-	                          const string &binding, const string &using_column);
+	void TransferUsingBinding(BindContext &current_context, optional_ptr<UsingColumnSet> current_set,
+	                          UsingColumnSet &new_set, const string &binding, const string &using_column);
 
 	//! Fetch the actual column name from the given binding, or throws if none exists
 	//! This can be different from "column_name" because of case insensitivity
@@ -144,11 +141,11 @@ public:
 	//! Add all the bindings from a BindContext to this BindContext. The other BindContext is destroyed in the process.
 	void AddContext(BindContext other);
 	//! For semi and anti joins we remove the binding context of the right table after binding the condition.
-	void RemoveContext(vector<std::pair<string, duckdb::Binding *>> &other_bindings_list);
+	void RemoveContext(vector<reference<Binding>> &other_bindings_list);
 
 	//! Gets a binding of the specified name. Returns a nullptr and sets the out_error if the binding could not be
 	//! found.
-	Binding *GetBinding(const string &name, string &out_error);
+	optional_ptr<Binding> GetBinding(const string &name, string &out_error);
 
 private:
 	void AddBinding(const string &alias, unique_ptr<Binding> binding);
@@ -157,9 +154,9 @@ private:
 	//! The set of bindings
 	case_insensitive_map_t<unique_ptr<Binding>> bindings;
 	//! The list of bindings in insertion order
-	vector<std::pair<string, Binding *>> bindings_list;
+	vector<reference<Binding>> bindings_list;
 	//! The set of columns used in USING join conditions
-	case_insensitive_map_t<unordered_set<UsingColumnSet *>> using_columns;
+	case_insensitive_map_t<reference_set_t<UsingColumnSet>> using_columns;
 	//! Using column sets
 	vector<unique_ptr<UsingColumnSet>> using_column_sets;
 

package/src/duckdb/src/include/duckdb/planner/binder.hpp

@@ -109,7 +109,7 @@ public:
 	unique_ptr<BoundCreateTableInfo> BindCreateTableInfo(unique_ptr<CreateInfo> info);
 	unique_ptr<BoundCreateTableInfo> BindCreateTableInfo(unique_ptr<CreateInfo> info, SchemaCatalogEntry &schema);
 
-	vector<unique_ptr<Expression>> BindCreateIndexExpressions(TableCatalogEntry *table, CreateIndexInfo *info);
+	vector<unique_ptr<Expression>> BindCreateIndexExpressions(TableCatalogEntry &table, CreateIndexInfo &info);
 
 	void BindCreateViewInfo(CreateViewInfo &base);
 	SchemaCatalogEntry &BindSchema(CreateInfo &info);
@@ -164,8 +164,8 @@ public:
 		return FormatErrorRecursive(query_location, msg, values, params...);
 	}
 
-	unique_ptr<LogicalOperator> BindUpdateSet(LogicalOperator *op, unique_ptr<LogicalOperator> root,
-	                                          UpdateSetInfo &set_info, TableCatalogEntry *table,
+	unique_ptr<LogicalOperator> BindUpdateSet(LogicalOperator &op, unique_ptr<LogicalOperator> root,
+	                                          UpdateSetInfo &set_info, TableCatalogEntry &table,
 	                                          vector<PhysicalIndex> &columns);
 	void BindDoUpdateSetExpressions(const string &table_alias, LogicalInsert *insert, UpdateSetInfo &set_info,
 	                                TableCatalogEntry &table);
@@ -255,7 +255,7 @@ private:
 	BoundStatement Bind(AttachStatement &stmt);
 	BoundStatement Bind(DetachStatement &stmt);
 
-	BoundStatement BindReturning(vector<unique_ptr<ParsedExpression>> returning_list, TableCatalogEntry *table,
+	BoundStatement BindReturning(vector<unique_ptr<ParsedExpression>> returning_list, TableCatalogEntry &table,
 	                             const string &alias, idx_t update_table_index,
 	                             unique_ptr<LogicalOperator> child_operator, BoundStatement result);
 
@@ -336,8 +336,8 @@ private:
 	bool TryFindBinding(const string &using_column, const string &join_side, string &result);
 
 	void AddUsingBindingSet(unique_ptr<UsingColumnSet> set);
-	string RetrieveUsingBinding(Binder &current_binder, UsingColumnSet *current_set, const string &column_name,
-	                            const string &join_side, UsingColumnSet *new_set);
+	string RetrieveUsingBinding(Binder &current_binder, optional_ptr<UsingColumnSet> current_set,
+	                            const string &column_name, const string &join_side);
 
 	void AddCTEMap(CommonTableExpressionMap &cte_map);
 

package/src/duckdb/src/include/duckdb/planner/expression_binder/index_binder.hpp

@@ -19,8 +19,8 @@ class BoundColumnRefExpression;
 //! The IndexBinder is responsible for binding an expression within an index statement
 class IndexBinder : public ExpressionBinder {
 public:
-	IndexBinder(Binder &binder, ClientContext &context, TableCatalogEntry *table = nullptr,
-	            CreateIndexInfo *info = nullptr);
+	IndexBinder(Binder &binder, ClientContext &context, optional_ptr<TableCatalogEntry> table = nullptr,
+	            optional_ptr<CreateIndexInfo> info = nullptr);
 
 protected:
 	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
@@ -29,8 +29,8 @@ protected:
 
 private:
 	// only for WAL replay
-	TableCatalogEntry *table;
-	CreateIndexInfo *info;
+	optional_ptr<TableCatalogEntry> table;
+	optional_ptr<CreateIndexInfo> info;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/expression_binder/where_binder.hpp

@@ -17,7 +17,7 @@ class ColumnAliasBinder;
 //! The WHERE binder is responsible for binding an expression within the WHERE clause of a SQL statement
 class WhereBinder : public ExpressionBinder {
 public:
-	WhereBinder(Binder &binder, ClientContext &context, ColumnAliasBinder *column_alias_binder = nullptr);
+	WhereBinder(Binder &binder, ClientContext &context, optional_ptr<ColumnAliasBinder> column_alias_binder = nullptr);
 
 protected:
 	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
@@ -28,7 +28,7 @@ protected:
 private:
 	BindResult BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression);
 
-	ColumnAliasBinder *column_alias_binder;
+	optional_ptr<ColumnAliasBinder> column_alias_binder;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_create.hpp

@@ -19,11 +19,12 @@ public:
 	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_INVALID;
 
 public:
-	LogicalCreate(LogicalOperatorType type, unique_ptr<CreateInfo> info, SchemaCatalogEntry *schema = nullptr)
+	LogicalCreate(LogicalOperatorType type, unique_ptr<CreateInfo> info,
+	              optional_ptr<SchemaCatalogEntry> schema = nullptr)
 	    : LogicalOperator(type), schema(schema), info(std::move(info)) {
 	}
 
-	SchemaCatalogEntry *schema;
+	optional_ptr<SchemaCatalogEntry> schema;
 	unique_ptr<CreateInfo> info;
 
 public:

package/src/duckdb/src/include/duckdb/planner/operator/logical_create_table.hpp

@@ -18,12 +18,12 @@ public:
 	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_CREATE_TABLE;
 
 public:
-	LogicalCreateTable(SchemaCatalogEntry *schema, unique_ptr<BoundCreateTableInfo> info)
+	LogicalCreateTable(SchemaCatalogEntry &schema, unique_ptr<BoundCreateTableInfo> info)
 	    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_TABLE), schema(schema), info(std::move(info)) {
 	}
 
 	//! Schema to insert to
-	SchemaCatalogEntry *schema;
+	SchemaCatalogEntry &schema;
 	//! Create Table information
 	unique_ptr<BoundCreateTableInfo> info;
 

package/src/duckdb/src/include/duckdb/planner/operator/logical_delete.hpp

@@ -18,9 +18,9 @@ public:
 	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_DELETE;
 
 public:
-	explicit LogicalDelete(TableCatalogEntry *table, idx_t table_index);
+	explicit LogicalDelete(TableCatalogEntry &table, idx_t table_index);
 
-	TableCatalogEntry *table;
+	TableCatalogEntry &table;
 	idx_t table_index;
 	bool return_chunk;
 

package/src/duckdb/src/include/duckdb/planner/operator/logical_insert.hpp

@@ -23,7 +23,7 @@ public:
 	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_INSERT;
 
 public:
-	LogicalInsert(TableCatalogEntry *table, idx_t table_index);
+	LogicalInsert(TableCatalogEntry &table, idx_t table_index);
 
 	vector<vector<unique_ptr<Expression>>> insert_values;
 	//! The insertion map ([table_index -> index in result, or DConstants::INVALID_INDEX if not specified])
@@ -31,7 +31,7 @@ public:
 	//! The expected types for the INSERT statement (obtained from the column types)
 	vector<LogicalType> expected_types;
 	//! The base table to insert into
-	TableCatalogEntry *table;
+	TableCatalogEntry &table;
 	idx_t table_index;
 	//! if returning option is used, return actual chunk to projection
 	bool return_chunk;

package/src/duckdb/src/include/duckdb/planner/operator/logical_update.hpp

@@ -18,10 +18,10 @@ public:
 	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_UPDATE;
 
 public:
-	explicit LogicalUpdate(TableCatalogEntry *table);
+	explicit LogicalUpdate(TableCatalogEntry &table);
 
 	//! The base table to update
-	TableCatalogEntry *table;
+	TableCatalogEntry &table;
 	//! table catalog index
 	idx_t table_index;
 	//! if returning option is used, return the update chunk

package/src/duckdb/src/include/duckdb/planner/parsed_data/bound_create_function_info.hpp

@@ -14,11 +14,12 @@ namespace duckdb {
 class CatalogEntry;
 
 struct BoundCreateFunctionInfo {
-	explicit BoundCreateFunctionInfo(unique_ptr<CreateInfo> base) : base(std::move(base)) {
+	explicit BoundCreateFunctionInfo(SchemaCatalogEntry &schema, unique_ptr<CreateInfo> base)
+	    : schema(schema), base(std::move(base)) {
 	}
 
 	//! The schema to create the table in
-	SchemaCatalogEntry *schema;
+	SchemaCatalogEntry &schema;
 	//! The base CreateInfo object
 	unique_ptr<CreateInfo> base;
 

package/src/duckdb/src/include/duckdb/planner/parsed_data/bound_create_table_info.hpp

@@ -23,12 +23,13 @@ namespace duckdb {
 class CatalogEntry;
 
 struct BoundCreateTableInfo {
-	explicit BoundCreateTableInfo(unique_ptr<CreateInfo> base_p) : base(std::move(base_p)) {
+	explicit BoundCreateTableInfo(SchemaCatalogEntry &schema, unique_ptr<CreateInfo> base_p)
+	    : schema(schema), base(std::move(base_p)) {
 		D_ASSERT(base);
 	}
 
 	//! The schema to create the table in
-	SchemaCatalogEntry *schema;
+	SchemaCatalogEntry &schema;
 	//! The base CreateInfo object
 	unique_ptr<CreateInfo> base;
 	//! Column dependency manager of the table

package/src/duckdb/src/include/duckdb/planner/table_binding.hpp

@@ -54,7 +54,7 @@ public:
 	bool HasMatchingBinding(const string &column_name);
 	virtual string ColumnNotFoundError(const string &column_name) const;
 	virtual BindResult Bind(ColumnRefExpression &colref, idx_t depth);
-	virtual StandardEntry *GetStandardEntry();
+	virtual optional_ptr<StandardEntry> GetStandardEntry();
 };
 
 struct EntryBinding : public Binding {
@@ -64,24 +64,25 @@ public:
 	StandardEntry &entry;
 
 public:
-	StandardEntry *GetStandardEntry() override;
+	optional_ptr<StandardEntry> GetStandardEntry() override;
 };
 
 //! TableBinding is exactly like the Binding, except it keeps track of which columns were bound in the linked LogicalGet
 //! node for projection pushdown purposes.
 struct TableBinding : public Binding {
 	TableBinding(const string &alias, vector<LogicalType> types, vector<string> names,
-	             vector<column_t> &bound_column_ids, StandardEntry *entry, idx_t index, bool add_row_id = false);
+	             vector<column_t> &bound_column_ids, optional_ptr<StandardEntry> entry, idx_t index,
+	             bool add_row_id = false);
 
 	//! A reference to the set of bound column ids
 	vector<column_t> &bound_column_ids;
 	//! The underlying catalog entry (if any)
-	StandardEntry *entry;
+	optional_ptr<StandardEntry> entry;
 
 public:
 	unique_ptr<ParsedExpression> ExpandGeneratedColumn(const string &column_name);
 	BindResult Bind(ColumnRefExpression &colref, idx_t depth) override;
-	StandardEntry *GetStandardEntry() override;
+	optional_ptr<StandardEntry> GetStandardEntry() override;
 	string ColumnNotFoundError(const string &column_name) const override;
 	// These are columns that are present in the name_map, appearing in the order that they're bound
 	const vector<column_t> &GetBoundColumnIds() const;

package/src/duckdb/src/include/duckdb/planner/tableref/bound_basetableref.hpp

@@ -20,11 +20,11 @@ public:
 	static constexpr const TableReferenceType TYPE = TableReferenceType::BASE_TABLE;
 
 public:
-	BoundBaseTableRef(TableCatalogEntry *table, unique_ptr<LogicalOperator> get)
+	BoundBaseTableRef(TableCatalogEntry &table, unique_ptr<LogicalOperator> get)
 	    : BoundTableRef(TableReferenceType::BASE_TABLE), table(table), get(std::move(get)) {
 	}
 
-	TableCatalogEntry *table;
+	TableCatalogEntry &table;
 	unique_ptr<LogicalOperator> get;
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/compression/chimp/chimp_compress.hpp

@@ -33,12 +33,8 @@ public:
 	using CHIMP_TYPE = typename ChimpType<T>::type;
 
 	explicit ChimpCompressionState(ColumnDataCheckpointer &checkpointer, ChimpAnalyzeState<T> *analyze_state)
-	    : checkpointer(checkpointer) {
-
-		auto &db = checkpointer.GetDatabase();
-		auto &type = checkpointer.GetType();
-		auto &config = DBConfig::GetConfig(db);
-		function = config.GetCompressionFunction(CompressionType::COMPRESSION_CHIMP, type.InternalType());
+	    : checkpointer(checkpointer),
+	      function(checkpointer.GetCompressionFunction(CompressionType::COMPRESSION_CHIMP)) {
 		CreateEmptySegment(checkpointer.GetRowGroup().start);
 
 		// These buffers are recycled for every group, so they only have to be set once
@@ -48,7 +44,7 @@ public:
 	}
 
 	ColumnDataCheckpointer &checkpointer;
-	CompressionFunction *function;
+	CompressionFunction &function;
 	unique_ptr<ColumnSegment> current_segment;
 	BufferHandle handle;
 	idx_t group_idx = 0;

package/src/duckdb/src/include/duckdb/storage/compression/patas/patas_compress.hpp

@@ -57,12 +57,8 @@ public:
 	};
 
 	explicit PatasCompressionState(ColumnDataCheckpointer &checkpointer, PatasAnalyzeState<T> *analyze_state)
-	    : checkpointer(checkpointer) {
-
-		auto &db = checkpointer.GetDatabase();
-		auto &type = checkpointer.GetType();
-		auto &config = DBConfig::GetConfig(db);
-		function = config.GetCompressionFunction(CompressionType::COMPRESSION_PATAS, type.InternalType());
+	    : checkpointer(checkpointer),
+	      function(checkpointer.GetCompressionFunction(CompressionType::COMPRESSION_PATAS)) {
 		CreateEmptySegment(checkpointer.GetRowGroup().start);
 
 		state.data_ptr = (void *)this;
@@ -71,7 +67,7 @@ public:
 	}
 
 	ColumnDataCheckpointer &checkpointer;
-	CompressionFunction *function;
+	CompressionFunction &function;
 	unique_ptr<ColumnSegment> current_segment;
 	BufferHandle handle;
 	idx_t group_idx = 0;

package/src/duckdb/src/include/duckdb/storage/data_table.hpp

@@ -105,7 +105,7 @@ public:
 	//! Merge a row group collection into the transaction-local storage
 	void LocalMerge(ClientContext &context, RowGroupCollection &collection);
 	//! Creates an optimistic writer for this table - used for optimistically writing parallel appends
-	OptimisticDataWriter *CreateOptimisticWriter(ClientContext &context);
+	OptimisticDataWriter &CreateOptimisticWriter(ClientContext &context);
 
 	//! Delete the entries with the specified row identifier from the table
 	idx_t Delete(TableCatalogEntry &table, ClientContext &context, Vector &row_ids, idx_t count);

package/src/duckdb/src/include/duckdb/storage/storage_manager.hpp

@@ -54,7 +54,7 @@ public:
 	}
 
 	//! Get the WAL of the StorageManager, returns nullptr if in-memory
-	WriteAheadLog *GetWriteAheadLog() {
+	optional_ptr<WriteAheadLog> GetWriteAheadLog() {
 		return wal.get();
 	}
 

package/src/duckdb/src/include/duckdb/storage/table/column_data_checkpointer.hpp

@@ -27,6 +27,7 @@ public:
 	ColumnCheckpointState &GetCheckpointState();
 
 	void Checkpoint(vector<SegmentNode<ColumnSegment>> nodes);
+	CompressionFunction &GetCompressionFunction(CompressionType type);
 
 private:
 	void ScanSegments(const std::function<void(Vector &, idx_t)> &callback);
@@ -42,7 +43,7 @@ private:
 	bool is_validity;
 	Vector intermediate;
 	vector<SegmentNode<ColumnSegment>> nodes;
-	vector<CompressionFunction *> compression_functions;
+	vector<optional_ptr<CompressionFunction>> compression_functions;
 	ColumnCheckpointInfo &checkpoint_info;
 };
 

package/src/duckdb/src/include/duckdb/storage/table/column_segment.hpp

@@ -48,7 +48,7 @@ public:
 	//! The column segment type (transient or persistent)
 	ColumnSegmentType segment_type;
 	//! The compression function
-	CompressionFunction *function;
+	reference<CompressionFunction> function;
 	//! The statistics for the segment
 	SegmentStatistics stats;
 	//! The block that this segment relates to
@@ -124,7 +124,7 @@ public:
 
 public:
 	ColumnSegment(DatabaseInstance &db, shared_ptr<BlockHandle> block, LogicalType type, ColumnSegmentType segment_type,
-	              idx_t start, idx_t count, CompressionFunction *function, BaseStatistics statistics,
+	              idx_t start, idx_t count, CompressionFunction &function, BaseStatistics statistics,
 	              block_id_t block_id, idx_t offset, idx_t segment_size);
 	ColumnSegment(ColumnSegment &other, idx_t start);
 

package/src/duckdb/src/include/duckdb/storage/table/row_group.hpp

@@ -120,7 +120,7 @@ public:
 	void RevertAppend(idx_t start);
 
 	//! Delete the given set of rows in the version manager
-	idx_t Delete(TransactionData transaction, DataTable *table, row_t *row_ids, idx_t count);
+	idx_t Delete(TransactionData transaction, DataTable &table, row_t *row_ids, idx_t count);
 
 	RowGroupWriteData WriteToDisk(PartialBlockManager &manager, const vector<CompressionType> &compression_types);
 	RowGroupPointer Checkpoint(RowGroupWriter &writer, TableStatistics &global_stats);

package/src/duckdb/src/include/duckdb/storage/table/row_group_collection.hpp

@@ -77,7 +77,7 @@ public:
 
 	void RemoveFromIndexes(TableIndexList &indexes, Vector &row_identifiers, idx_t count);
 
-	idx_t Delete(TransactionData transaction, DataTable *table, row_t *ids, idx_t count);
+	idx_t Delete(TransactionData transaction, DataTable &table, row_t *ids, idx_t count);
 	void Update(TransactionData transaction, row_t *ids, const vector<PhysicalIndex> &column_ids, DataChunk &updates);
 	void UpdateColumn(TransactionData transaction, Vector &row_ids, const vector<column_t> &column_path,
 	                  DataChunk &updates);

package/src/duckdb/src/include/duckdb/storage/table/update_segment.hpp

@@ -42,9 +42,9 @@ public:
 	            Vector &base_data);
 	void FetchRow(TransactionData transaction, idx_t row_id, Vector &result, idx_t result_idx);
 
-	void RollbackUpdate(UpdateInfo *info);
-	void CleanupUpdateInternal(const StorageLockKey &lock, UpdateInfo *info);
-	void CleanupUpdate(UpdateInfo *info);
+	void RollbackUpdate(UpdateInfo &info);
+	void CleanupUpdateInternal(const StorageLockKey &lock, UpdateInfo &info);
+	void CleanupUpdate(UpdateInfo &info);
 
 	unique_ptr<BaseStatistics> GetStatistics();
 	StringHeap &GetStringHeap() {
@@ -77,7 +77,7 @@ public:
 	                                                 Vector &result);
 	typedef void (*fetch_row_function_t)(transaction_t start_time, transaction_t transaction_id, UpdateInfo *info,
 	                                     idx_t row_idx, Vector &result, idx_t result_idx);
-	typedef void (*rollback_update_function_t)(UpdateInfo *base_info, UpdateInfo *rollback_info);
+	typedef void (*rollback_update_function_t)(UpdateInfo &base_info, UpdateInfo &rollback_info);
 	typedef idx_t (*statistics_update_function_t)(UpdateSegment *segment, SegmentStatistics &stats, Vector &update,
 	                                              idx_t count, SelectionVector &sel);
 

package/src/duckdb/src/include/duckdb/storage/write_ahead_log.hpp

@@ -39,15 +39,15 @@ class TransactionManager;
 class ReplayState {
 public:
 	ReplayState(AttachedDatabase &db, ClientContext &context, Deserializer &source)
-	    : db(db), context(context), catalog(db.GetCatalog()), source(source), current_table(nullptr),
-	      deserialize_only(false), checkpoint_id(INVALID_BLOCK) {
+	    : db(db), context(context), catalog(db.GetCatalog()), source(source), deserialize_only(false),
+	      checkpoint_id(INVALID_BLOCK) {
 	}
 
 	AttachedDatabase &db;
 	ClientContext &context;
 	Catalog &catalog;
 	Deserializer &source;
-	TableCatalogEntry *current_table;
+	optional_ptr<TableCatalogEntry> current_table;
 	bool deserialize_only;
 	block_id_t checkpoint_id;
 

package/src/duckdb/src/include/duckdb/transaction/cleanup_state.hpp

@@ -27,14 +27,14 @@ public:
 
 private:
 	// data for index cleanup
-	DataTable *current_table;
+	optional_ptr<DataTable> current_table;
 	DataChunk chunk;
 	row_t row_numbers[STANDARD_VECTOR_SIZE];
 	idx_t count;
 
 private:
-	void CleanupDelete(DeleteInfo *info);
-	void CleanupUpdate(UpdateInfo *info);
+	void CleanupDelete(DeleteInfo &info);
+	void CleanupUpdate(UpdateInfo &info);
 
 	void Flush();
 };

package/src/duckdb/src/include/duckdb/transaction/commit_state.hpp

@@ -23,13 +23,13 @@ struct UpdateInfo;
 
 class CommitState {
 public:
-	explicit CommitState(ClientContext &context, transaction_t commit_id, WriteAheadLog *log = nullptr);
+	explicit CommitState(ClientContext &context, transaction_t commit_id, optional_ptr<WriteAheadLog> log = nullptr);
 
-	WriteAheadLog *log;
+	optional_ptr<WriteAheadLog> log;
 	transaction_t commit_id;
 	UndoFlags current_op;
 
-	DataTableInfo *current_table_info;
+	optional_ptr<DataTableInfo> current_table_info;
 	idx_t row_identifiers[STANDARD_VECTOR_SIZE];
 
 	unique_ptr<DataChunk> delete_chunk;
@@ -47,8 +47,8 @@ private:
 	void SwitchTable(DataTableInfo *table, UndoFlags new_op);
 
 	void WriteCatalogEntry(CatalogEntry &entry, data_ptr_t extra_data);
-	void WriteDelete(DeleteInfo *info);
-	void WriteUpdate(UpdateInfo *info);
+	void WriteDelete(DeleteInfo &info);
+	void WriteUpdate(UpdateInfo &info);
 
 	void AppendRowId(row_t rowid);
 };