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

package/src/duckdb/src/storage/local_storage.cpp

@@ -18,10 +18,10 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 // OptimisticDataWriter
 //===--------------------------------------------------------------------===//
-OptimisticDataWriter::OptimisticDataWriter(DataTable *table) : table(table) {
+OptimisticDataWriter::OptimisticDataWriter(DataTable &table) : table(table) {
 }
 
-OptimisticDataWriter::OptimisticDataWriter(DataTable *table, OptimisticDataWriter &parent)
+OptimisticDataWriter::OptimisticDataWriter(DataTable &table, OptimisticDataWriter &parent)
     : table(table), partial_manager(std::move(parent.partial_manager)),
       written_blocks(std::move(parent.written_blocks)) {
 	if (partial_manager) {
@@ -34,13 +34,13 @@ OptimisticDataWriter::~OptimisticDataWriter() {
 
 bool OptimisticDataWriter::PrepareWrite() {
 	// check if we should pre-emptively write the table to disk
-	if (table->info->IsTemporary() || StorageManager::Get(table->info->db).InMemory()) {
+	if (table.info->IsTemporary() || StorageManager::Get(table.info->db).InMemory()) {
 		return false;
 	}
 	// we should! write the second-to-last row group to disk
 	// allocate the partial block-manager if none is allocated yet
 	if (!partial_manager) {
-		auto &block_manager = table->info->table_io_manager->GetBlockManagerForRowData();
+		auto &block_manager = table.info->table_io_manager->GetBlockManagerForRowData();
 		partial_manager = make_uniq<PartialBlockManager>(block_manager);
 	}
 	return true;
@@ -62,7 +62,7 @@ void OptimisticDataWriter::FlushToDisk(RowGroup *row_group) {
 	//! The set of column compression types (if any)
 	vector<CompressionType> compression_types;
 	D_ASSERT(compression_types.empty());
-	for (auto &column : table->column_definitions) {
+	for (auto &column : table.column_definitions) {
 		compression_types.push_back(column.CompressionType());
 	}
 	auto row_group_pointer = row_group->WriteToDisk(*partial_manager, compression_types);
@@ -102,7 +102,7 @@ void OptimisticDataWriter::Rollback() {
 		partial_manager.reset();
 	}
 	if (!written_blocks.empty()) {
-		auto &block_manager = table->info->table_io_manager->GetBlockManagerForRowData();
+		auto &block_manager = table.info->table_io_manager->GetBlockManagerForRowData();
 		for (auto block_id : written_blocks) {
 			block_manager.MarkBlockAsFree(block_id);
 		}
@@ -113,7 +113,7 @@ void OptimisticDataWriter::Rollback() {
 // Local Table Storage
 //===--------------------------------------------------------------------===//
 LocalTableStorage::LocalTableStorage(DataTable &table)
-    : table(&table), allocator(Allocator::Get(table.db)), deleted_rows(0), optimistic_writer(&table) {
+    : table_ref(table), allocator(Allocator::Get(table.db)), deleted_rows(0), optimistic_writer(table) {
 	auto types = table.GetTypes();
 	row_groups = make_shared<RowGroupCollection>(table.info, TableIOManager::Get(table).GetBlockManagerForRowData(),
 	                                             types, MAX_ROW_ID, 0);
@@ -138,26 +138,26 @@ LocalTableStorage::LocalTableStorage(DataTable &table)
 LocalTableStorage::LocalTableStorage(ClientContext &context, DataTable &new_dt, LocalTableStorage &parent,
                                      idx_t changed_idx, const LogicalType &target_type,
                                      const vector<column_t> &bound_columns, Expression &cast_expr)
-    : table(&new_dt), allocator(Allocator::Get(table->db)), deleted_rows(parent.deleted_rows),
-      optimistic_writer(table, parent.optimistic_writer), optimistic_writers(std::move(parent.optimistic_writers)) {
+    : table_ref(new_dt), allocator(Allocator::Get(new_dt.db)), deleted_rows(parent.deleted_rows),
+      optimistic_writer(new_dt, parent.optimistic_writer), optimistic_writers(std::move(parent.optimistic_writers)) {
 	row_groups = parent.row_groups->AlterType(context, changed_idx, target_type, bound_columns, cast_expr);
 	parent.row_groups.reset();
 	indexes.Move(parent.indexes);
 }
 
 LocalTableStorage::LocalTableStorage(DataTable &new_dt, LocalTableStorage &parent, idx_t drop_idx)
-    : table(&new_dt), allocator(Allocator::Get(table->db)), deleted_rows(parent.deleted_rows),
-      optimistic_writer(table, parent.optimistic_writer), optimistic_writers(std::move(parent.optimistic_writers)) {
+    : table_ref(new_dt), allocator(Allocator::Get(new_dt.db)), deleted_rows(parent.deleted_rows),
+      optimistic_writer(new_dt, parent.optimistic_writer), optimistic_writers(std::move(parent.optimistic_writers)) {
 	row_groups = parent.row_groups->RemoveColumn(drop_idx);
 	parent.row_groups.reset();
 	indexes.Move(parent.indexes);
 }
 
 LocalTableStorage::LocalTableStorage(ClientContext &context, DataTable &new_dt, LocalTableStorage &parent,
-                                     ColumnDefinition &new_column, Expression *default_value)
-    : table(&new_dt), allocator(Allocator::Get(table->db)), deleted_rows(parent.deleted_rows),
-      optimistic_writer(table, parent.optimistic_writer), optimistic_writers(std::move(parent.optimistic_writers)) {
-	row_groups = parent.row_groups->AddColumn(context, new_column, default_value);
+                                     ColumnDefinition &new_column, optional_ptr<Expression> default_value)
+    : table_ref(new_dt), allocator(Allocator::Get(new_dt.db)), deleted_rows(parent.deleted_rows),
+      optimistic_writer(new_dt, parent.optimistic_writer), optimistic_writers(std::move(parent.optimistic_writers)) {
+	row_groups = parent.row_groups->AddColumn(context, new_column, default_value.get());
 	parent.row_groups.reset();
 	indexes.Move(parent.indexes);
 }
@@ -165,12 +165,12 @@ LocalTableStorage::LocalTableStorage(ClientContext &context, DataTable &new_dt,
 LocalTableStorage::~LocalTableStorage() {
 }
 
-void LocalTableStorage::InitializeScan(CollectionScanState &state, TableFilterSet *table_filters) {
+void LocalTableStorage::InitializeScan(CollectionScanState &state, optional_ptr<TableFilterSet> table_filters) {
 	if (row_groups->GetTotalRows() == 0) {
 		// nothing to scan
 		return;
 	}
-	row_groups->InitializeScan(state, state.GetColumnIds(), table_filters);
+	row_groups->InitializeScan(state, state.GetColumnIds(), table_filters.get());
 }
 
 idx_t LocalTableStorage::EstimatedSize() {
@@ -228,25 +228,26 @@ PreservedError LocalTableStorage::AppendToIndexes(DuckTransaction &transaction,
 
 void LocalTableStorage::AppendToIndexes(DuckTransaction &transaction, TableAppendState &append_state,
                                         idx_t append_count, bool append_to_table) {
+	auto &table = table_ref.get();
 	if (append_to_table) {
-		table->InitializeAppend(transaction, append_state, append_count);
+		table.InitializeAppend(transaction, append_state, append_count);
 	}
 	PreservedError error;
 	if (append_to_table) {
 		// appending: need to scan entire
 		row_groups->Scan(transaction, [&](DataChunk &chunk) -> bool {
 			// append this chunk to the indexes of the table
-			error = table->AppendToIndexes(chunk, append_state.current_row);
+			error = table.AppendToIndexes(chunk, append_state.current_row);
 			if (error) {
 				return false;
 			}
 			// append to base table
-			table->Append(chunk, append_state);
+			table.Append(chunk, append_state);
 			return true;
 		});
 	} else {
-		error = AppendToIndexes(transaction, *row_groups, table->info->indexes, table->GetTypes(),
-		                        append_state.current_row);
+		error =
+		    AppendToIndexes(transaction, *row_groups, table.info->indexes, table.GetTypes(), append_state.current_row);
 	}
 	if (error) {
 		// need to revert the append
@@ -255,7 +256,7 @@ void LocalTableStorage::AppendToIndexes(DuckTransaction &transaction, TableAppen
 		row_groups->Scan(transaction, [&](DataChunk &chunk) -> bool {
 			// append this chunk to the indexes of the table
 			try {
-				table->RemoveFromIndexes(append_state, chunk, current_row);
+				table.RemoveFromIndexes(append_state, chunk, current_row);
 			} catch (Exception &ex) {
 				error = PreservedError(ex);
 				return false;
@@ -272,16 +273,16 @@ void LocalTableStorage::AppendToIndexes(DuckTransaction &transaction, TableAppen
 			return true;
 		});
 		if (append_to_table) {
-			table->RevertAppendInternal(append_state.row_start, append_count);
+			table.RevertAppendInternal(append_state.row_start, append_count);
 		}
 		error.Throw();
 	}
 }
 
-OptimisticDataWriter *LocalTableStorage::CreateOptimisticWriter() {
-	auto writer = make_uniq<OptimisticDataWriter>(table);
+OptimisticDataWriter &LocalTableStorage::CreateOptimisticWriter() {
+	auto writer = make_uniq<OptimisticDataWriter>(table_ref.get());
 	optimistic_writers.push_back(std::move(writer));
-	return optimistic_writers.back().get();
+	return *optimistic_writers.back();
 }
 
 void LocalTableStorage::Rollback() {
@@ -295,22 +296,22 @@ void LocalTableStorage::Rollback() {
 //===--------------------------------------------------------------------===//
 // LocalTableManager
 //===--------------------------------------------------------------------===//
-LocalTableStorage *LocalTableManager::GetStorage(DataTable *table) {
+optional_ptr<LocalTableStorage> LocalTableManager::GetStorage(DataTable &table) {
 	lock_guard<mutex> l(table_storage_lock);
 	auto entry = table_storage.find(table);
 	return entry == table_storage.end() ? nullptr : entry->second.get();
 }
 
-LocalTableStorage *LocalTableManager::GetOrCreateStorage(DataTable *table) {
+LocalTableStorage &LocalTableManager::GetOrCreateStorage(DataTable &table) {
 	lock_guard<mutex> l(table_storage_lock);
 	auto entry = table_storage.find(table);
 	if (entry == table_storage.end()) {
-		auto new_storage = make_shared<LocalTableStorage>(*table);
+		auto new_storage = make_shared<LocalTableStorage>(table);
 		auto storage = new_storage.get();
-		table_storage.insert(make_pair(table, std::move(new_storage)));
-		return storage;
+		table_storage.insert(make_pair(reference<DataTable>(table), std::move(new_storage)));
+		return *storage;
 	} else {
-		return entry->second.get();
+		return *entry->second.get();
 	}
 }
 
@@ -319,7 +320,7 @@ bool LocalTableManager::IsEmpty() {
 	return table_storage.empty();
 }
 
-shared_ptr<LocalTableStorage> LocalTableManager::MoveEntry(DataTable *table) {
+shared_ptr<LocalTableStorage> LocalTableManager::MoveEntry(DataTable &table) {
 	lock_guard<mutex> l(table_storage_lock);
 	auto entry = table_storage.find(table);
 	if (entry == table_storage.end()) {
@@ -330,7 +331,7 @@ shared_ptr<LocalTableStorage> LocalTableManager::MoveEntry(DataTable *table) {
 	return storage_entry;
 }
 
-unordered_map<DataTable *, shared_ptr<LocalTableStorage>> LocalTableManager::MoveEntries() {
+reference_map_t<DataTable, shared_ptr<LocalTableStorage>> LocalTableManager::MoveEntries() {
 	lock_guard<mutex> l(table_storage_lock);
 	return std::move(table_storage);
 }
@@ -344,7 +345,7 @@ idx_t LocalTableManager::EstimatedSize() {
 	return estimated_size;
 }
 
-void LocalTableManager::InsertEntry(DataTable *table, shared_ptr<LocalTableStorage> entry) {
+void LocalTableManager::InsertEntry(DataTable &table, shared_ptr<LocalTableStorage> entry) {
 	lock_guard<mutex> l(table_storage_lock);
 	D_ASSERT(table_storage.find(table) == table_storage.end());
 	table_storage[table] = std::move(entry);
@@ -375,7 +376,8 @@ LocalStorage &LocalStorage::Get(ClientContext &context, Catalog &catalog) {
 	return LocalStorage::Get(context, catalog.GetAttached());
 }
 
-void LocalStorage::InitializeScan(DataTable *table, CollectionScanState &state, TableFilterSet *table_filters) {
+void LocalStorage::InitializeScan(DataTable &table, CollectionScanState &state,
+                                  optional_ptr<TableFilterSet> table_filters) {
 	auto storage = table_manager.GetStorage(table);
 	if (storage == nullptr) {
 		return;
@@ -387,7 +389,7 @@ void LocalStorage::Scan(CollectionScanState &state, const vector<column_t> &colu
 	state.Scan(transaction, result);
 }
 
-void LocalStorage::InitializeParallelScan(DataTable *table, ParallelCollectionScanState &state) {
+void LocalStorage::InitializeParallelScan(DataTable &table, ParallelCollectionScanState &state) {
 	auto storage = table_manager.GetStorage(table);
 	if (!storage) {
 		state.max_row = 0;
@@ -398,7 +400,7 @@ void LocalStorage::InitializeParallelScan(DataTable *table, ParallelCollectionSc
 	}
 }
 
-bool LocalStorage::NextParallelScan(ClientContext &context, DataTable *table, ParallelCollectionScanState &state,
+bool LocalStorage::NextParallelScan(ClientContext &context, DataTable &table, ParallelCollectionScanState &state,
                                     CollectionScanState &scan_state) {
 	auto storage = table_manager.GetStorage(table);
 	if (!storage) {
@@ -407,8 +409,8 @@ bool LocalStorage::NextParallelScan(ClientContext &context, DataTable *table, Pa
 	return storage->row_groups->NextParallelScan(context, state, scan_state);
 }
 
-void LocalStorage::InitializeAppend(LocalAppendState &state, DataTable *table) {
-	state.storage = table_manager.GetOrCreateStorage(table);
+void LocalStorage::InitializeAppend(LocalAppendState &state, DataTable &table) {
+	state.storage = &table_manager.GetOrCreateStorage(table);
 	state.storage->row_groups->InitializeAppend(TransactionData(transaction), state.append_state, 0);
 }
 
@@ -434,29 +436,29 @@ void LocalStorage::FinalizeAppend(LocalAppendState &state) {
 	state.storage->row_groups->FinalizeAppend(state.append_state.transaction, state.append_state);
 }
 
-void LocalStorage::LocalMerge(DataTable *table, RowGroupCollection &collection) {
-	auto storage = table_manager.GetOrCreateStorage(table);
-	if (!storage->indexes.Empty()) {
+void LocalStorage::LocalMerge(DataTable &table, RowGroupCollection &collection) {
+	auto &storage = table_manager.GetOrCreateStorage(table);
+	if (!storage.indexes.Empty()) {
 		// append data to indexes if required
-		row_t base_id = MAX_ROW_ID + storage->row_groups->GetTotalRows();
-		auto error = storage->AppendToIndexes(transaction, collection, storage->indexes, table->GetTypes(), base_id);
+		row_t base_id = MAX_ROW_ID + storage.row_groups->GetTotalRows();
+		auto error = storage.AppendToIndexes(transaction, collection, storage.indexes, table.GetTypes(), base_id);
 		if (error) {
 			error.Throw();
 		}
 	}
-	storage->row_groups->MergeStorage(collection);
+	storage.row_groups->MergeStorage(collection);
 }
 
-OptimisticDataWriter *LocalStorage::CreateOptimisticWriter(DataTable *table) {
-	auto storage = table_manager.GetOrCreateStorage(table);
-	return storage->CreateOptimisticWriter();
+OptimisticDataWriter &LocalStorage::CreateOptimisticWriter(DataTable &table) {
+	auto &storage = table_manager.GetOrCreateStorage(table);
+	return storage.CreateOptimisticWriter();
 }
 
 bool LocalStorage::ChangesMade() noexcept {
 	return !table_manager.IsEmpty();
 }
 
-bool LocalStorage::Find(DataTable *table) {
+bool LocalStorage::Find(DataTable &table) {
 	return table_manager.GetStorage(table) != nullptr;
 }
 
@@ -464,7 +466,7 @@ idx_t LocalStorage::EstimatedSize() {
 	return table_manager.EstimatedSize();
 }
 
-idx_t LocalStorage::Delete(DataTable *table, Vector &row_ids, idx_t count) {
+idx_t LocalStorage::Delete(DataTable &table, Vector &row_ids, idx_t count) {
 	auto storage = table_manager.GetStorage(table);
 	D_ASSERT(storage);
 
@@ -479,7 +481,7 @@ idx_t LocalStorage::Delete(DataTable *table, Vector &row_ids, idx_t count) {
 	return delete_count;
 }
 
-void LocalStorage::Update(DataTable *table, Vector &row_ids, const vector<PhysicalIndex> &column_ids,
+void LocalStorage::Update(DataTable &table, Vector &row_ids, const vector<PhysicalIndex> &column_ids,
                           DataChunk &updates) {
 	auto storage = table_manager.GetStorage(table);
 	D_ASSERT(storage);
@@ -517,7 +519,7 @@ void LocalStorage::Flush(DataTable &table, LocalTableStorage &storage) {
 		// append to the indexes and append to the base table
 		storage.AppendToIndexes(transaction, append_state, append_count, true);
 	}
-	transaction.PushAppend(&table, append_state.row_start, append_count);
+	transaction.PushAppend(table, append_state.row_start, append_count);
 }
 
 void LocalStorage::Commit(LocalStorage::CommitState &commit_state, DuckTransaction &transaction) {
@@ -528,7 +530,7 @@ void LocalStorage::Commit(LocalStorage::CommitState &commit_state, DuckTransacti
 	for (auto &entry : table_storage) {
 		auto table = entry.first;
 		auto storage = entry.second.get();
-		Flush(*table, *storage);
+		Flush(table, *storage);
 
 		entry.second.reset();
 	}
@@ -549,7 +551,7 @@ void LocalStorage::Rollback() {
 	}
 }
 
-idx_t LocalStorage::AddedRows(DataTable *table) {
+idx_t LocalStorage::AddedRows(DataTable &table) {
 	auto storage = table_manager.GetStorage(table);
 	if (!storage) {
 		return 0;
@@ -557,39 +559,39 @@ idx_t LocalStorage::AddedRows(DataTable *table) {
 	return storage->row_groups->GetTotalRows() - storage->deleted_rows;
 }
 
-void LocalStorage::MoveStorage(DataTable *old_dt, DataTable *new_dt) {
+void LocalStorage::MoveStorage(DataTable &old_dt, DataTable &new_dt) {
 	// check if there are any pending appends for the old version of the table
 	auto new_storage = table_manager.MoveEntry(old_dt);
 	if (!new_storage) {
 		return;
 	}
 	// take over the storage from the old entry
-	new_storage->table = new_dt;
+	new_storage->table_ref = new_dt;
 	table_manager.InsertEntry(new_dt, std::move(new_storage));
 }
 
-void LocalStorage::AddColumn(DataTable *old_dt, DataTable *new_dt, ColumnDefinition &new_column,
-                             Expression *default_value) {
+void LocalStorage::AddColumn(DataTable &old_dt, DataTable &new_dt, ColumnDefinition &new_column,
+                             optional_ptr<Expression> default_value) {
 	// check if there are any pending appends for the old version of the table
 	auto storage = table_manager.MoveEntry(old_dt);
 	if (!storage) {
 		return;
 	}
-	auto new_storage = make_shared<LocalTableStorage>(context, *new_dt, *storage, new_column, default_value);
+	auto new_storage = make_shared<LocalTableStorage>(context, new_dt, *storage, new_column, default_value);
 	table_manager.InsertEntry(new_dt, std::move(new_storage));
 }
 
-void LocalStorage::DropColumn(DataTable *old_dt, DataTable *new_dt, idx_t removed_column) {
+void LocalStorage::DropColumn(DataTable &old_dt, DataTable &new_dt, idx_t removed_column) {
 	// check if there are any pending appends for the old version of the table
 	auto storage = table_manager.MoveEntry(old_dt);
 	if (!storage) {
 		return;
 	}
-	auto new_storage = make_shared<LocalTableStorage>(*new_dt, *storage, removed_column);
+	auto new_storage = make_shared<LocalTableStorage>(new_dt, *storage, removed_column);
 	table_manager.InsertEntry(new_dt, std::move(new_storage));
 }
 
-void LocalStorage::ChangeType(DataTable *old_dt, DataTable *new_dt, idx_t changed_idx, const LogicalType &target_type,
+void LocalStorage::ChangeType(DataTable &old_dt, DataTable &new_dt, idx_t changed_idx, const LogicalType &target_type,
                               const vector<column_t> &bound_columns, Expression &cast_expr) {
 	// check if there are any pending appends for the old version of the table
 	auto storage = table_manager.MoveEntry(old_dt);
@@ -597,11 +599,11 @@ void LocalStorage::ChangeType(DataTable *old_dt, DataTable *new_dt, idx_t change
 		return;
 	}
 	auto new_storage =
-	    make_shared<LocalTableStorage>(context, *new_dt, *storage, changed_idx, target_type, bound_columns, cast_expr);
+	    make_shared<LocalTableStorage>(context, new_dt, *storage, changed_idx, target_type, bound_columns, cast_expr);
 	table_manager.InsertEntry(new_dt, std::move(new_storage));
 }
 
-void LocalStorage::FetchChunk(DataTable *table, Vector &row_ids, idx_t count, const vector<column_t> &col_ids,
+void LocalStorage::FetchChunk(DataTable &table, Vector &row_ids, idx_t count, const vector<column_t> &col_ids,
                               DataChunk &chunk, ColumnFetchState &fetch_state) {
 	auto storage = table_manager.GetStorage(table);
 	if (!storage) {
@@ -611,7 +613,7 @@ void LocalStorage::FetchChunk(DataTable *table, Vector &row_ids, idx_t count, co
 	storage->row_groups->Fetch(transaction, chunk, col_ids, row_ids, count, fetch_state);
 }
 
-TableIndexList &LocalStorage::GetIndexes(DataTable *table) {
+TableIndexList &LocalStorage::GetIndexes(DataTable &table) {
 	auto storage = table_manager.GetStorage(table);
 	if (!storage) {
 		throw InternalException("LocalStorage::GetIndexes - local storage not found");
@@ -620,7 +622,7 @@ TableIndexList &LocalStorage::GetIndexes(DataTable *table) {
 }
 
 void LocalStorage::VerifyNewConstraint(DataTable &parent, const BoundConstraint &constraint) {
-	auto storage = table_manager.GetStorage(&parent);
+	auto storage = table_manager.GetStorage(parent);
 	if (!storage) {
 		return;
 	}

package/src/duckdb/src/storage/storage_manager.cpp

@@ -143,12 +143,22 @@ void SingleFileStorageManager::LoadDatabase() {
 class SingleFileStorageCommitState : public StorageCommitState {
 	idx_t initial_wal_size = 0;
 	idx_t initial_written = 0;
-	WriteAheadLog *log;
+	optional_ptr<WriteAheadLog> log;
 	bool checkpoint;
 
 public:
 	SingleFileStorageCommitState(StorageManager &storage_manager, bool checkpoint);
-	~SingleFileStorageCommitState() override;
+	~SingleFileStorageCommitState() override {
+		// If log is non-null, then commit threw an exception before flushing.
+		if (log) {
+			auto &wal = *log.get();
+			wal.skip_writing = false;
+			if (wal.GetTotalWritten() > initial_written) {
+				// remove any entries written into the WAL by truncating it
+				wal.Truncate(initial_wal_size);
+			}
+		}
+	}
 
 	// Make the commit persistent
 	void FlushCommit() override;
@@ -189,17 +199,6 @@ void SingleFileStorageCommitState::FlushCommit() {
 	log = nullptr;
 }
 
-SingleFileStorageCommitState::~SingleFileStorageCommitState() {
-	// If log is non-null, then commit threw an exception before flushing.
-	if (log) {
-		log->skip_writing = false;
-		if (log->GetTotalWritten() > initial_written) {
-			// remove any entries written into the WAL by truncating it
-			log->Truncate(initial_wal_size);
-		}
-	}
-}
-
 unique_ptr<StorageCommitState> SingleFileStorageManager::GenStorageCommitState(Transaction &transaction,
                                                                                bool checkpoint) {
 	return make_uniq<SingleFileStorageCommitState>(*this, checkpoint);

package/src/duckdb/src/storage/table/column_checkpoint_state.cpp

@@ -135,7 +135,7 @@ void ColumnCheckpointState::FlushSegment(unique_ptr<ColumnSegment> segment, idx_
 		// set up the compression function to constant
 		auto &config = DBConfig::GetConfig(db);
 		segment->function =
-		    config.GetCompressionFunction(CompressionType::COMPRESSION_CONSTANT, segment->type.InternalType());
+		    *config.GetCompressionFunction(CompressionType::COMPRESSION_CONSTANT, segment->type.InternalType());
 		segment->ConvertToPersistent(nullptr, INVALID_BLOCK);
 	}
 
@@ -149,7 +149,7 @@ void ColumnCheckpointState::FlushSegment(unique_ptr<ColumnSegment> segment, idx_
 		data_pointer.row_start = last_pointer.row_start + last_pointer.tuple_count;
 	}
 	data_pointer.tuple_count = tuple_count;
-	data_pointer.compression_type = segment->function->type;
+	data_pointer.compression_type = segment->function.get().type;
 
 	// append the segment to the new segment tree
 	new_tree.AppendSegment(std::move(segment));

package/src/duckdb/src/storage/table/column_data.cpp

@@ -289,7 +289,7 @@ void ColumnData::InitializeAppend(ColumnAppendState &state) {
 
 	D_ASSERT(state.current->segment_type == ColumnSegmentType::TRANSIENT);
 	state.current->InitializeAppend(state);
-	D_ASSERT(state.current->function->append);
+	D_ASSERT(state.current->function.get().append);
 }
 
 void ColumnData::AppendData(BaseStatistics &stats, ColumnAppendState &state, UnifiedVectorFormat &vdata, idx_t count) {
@@ -520,7 +520,7 @@ void ColumnData::GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, T
 		column_info.segment_type = type.ToString();
 		column_info.segment_start = segment->start;
 		column_info.segment_count = segment->count;
-		column_info.compression_type = CompressionTypeToString(segment->function->type);
+		column_info.compression_type = CompressionTypeToString(segment->function.get().type);
 		column_info.segment_stats = segment->stats.statistics.ToString();
 		column_info.has_updates = updates ? true : false;
 		// persistent

package/src/duckdb/src/storage/table/column_data_checkpointer.cpp

@@ -14,7 +14,10 @@ ColumnDataCheckpointer::ColumnDataCheckpointer(ColumnData &col_data_p, RowGroup
       intermediate(is_validity ? LogicalType::BOOLEAN : GetType(), true, is_validity),
       checkpoint_info(checkpoint_info_p) {
 	auto &config = DBConfig::GetConfig(GetDatabase());
-	compression_functions = config.GetCompressionFunctions(GetType().InternalType());
+	auto functions = config.GetCompressionFunctions(GetType().InternalType());
+	for (auto &func : functions) {
+		compression_functions.push_back(&func.get());
+	}
 }
 
 DatabaseInstance &ColumnDataCheckpointer::GetDatabase() {
@@ -58,13 +61,14 @@ void ColumnDataCheckpointer::ScanSegments(const std::function<void(Vector &, idx
 	}
 }
 
-CompressionType ForceCompression(vector<CompressionFunction *> &compression_functions,
+CompressionType ForceCompression(vector<optional_ptr<CompressionFunction>> &compression_functions,
                                  CompressionType compression_type) {
 	// On of the force_compression flags has been set
 	// check if this compression method is available
 	bool found = false;
 	for (idx_t i = 0; i < compression_functions.size(); i++) {
-		if (compression_functions[i]->type == compression_type) {
+		auto &compression_function = *compression_functions[i];
+		if (compression_function.type == compression_type) {
 			found = true;
 			break;
 		}
@@ -74,10 +78,11 @@ CompressionType ForceCompression(vector<CompressionFunction *> &compression_func
 		// clear all other compression methods
 		// except the uncompressed method, so we can fall back on that
 		for (idx_t i = 0; i < compression_functions.size(); i++) {
-			if (compression_functions[i]->type == CompressionType::COMPRESSION_UNCOMPRESSED) {
+			auto &compression_function = *compression_functions[i];
+			if (compression_function.type == CompressionType::COMPRESSION_UNCOMPRESSED) {
 				continue;
 			}
-			if (compression_functions[i]->type != compression_type) {
+			if (compression_function.type != compression_type) {
 				compression_functions[i] = nullptr;
 			}
 		}
@@ -225,7 +230,7 @@ void ColumnDataCheckpointer::WritePersistentSegments() {
 		pointer.block_pointer.offset = segment->GetBlockOffset();
 		pointer.row_start = segment->start;
 		pointer.tuple_count = segment->count;
-		pointer.compression_type = segment->function->type;
+		pointer.compression_type = segment->function.get().type;
 
 		// merge the persistent stats into the global column stats
 		state.global_stats->Merge(segment->stats.statistics);
@@ -250,4 +255,11 @@ void ColumnDataCheckpointer::Checkpoint(vector<SegmentNode<ColumnSegment>> nodes
 	}
 }
 
+CompressionFunction &ColumnDataCheckpointer::GetCompressionFunction(CompressionType compression_type) {
+	auto &db = GetDatabase();
+	auto &column_type = GetType();
+	auto &config = DBConfig::GetConfig(db);
+	return *config.GetCompressionFunction(compression_type, column_type.InternalType());
+}
+
 } // namespace duckdb