duckdb 1.1.3 → 1.1.4-dev11.0

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

@@ -56,36 +56,19 @@ ObjectCache &ObjectCache::GetObjectCache(ClientContext &context) {
 	return context.db->GetObjectCache();
 }
 
-bool ObjectCache::ObjectCacheEnabled(ClientContext &context) {
-	return context.db->config.options.object_cache_enable;
-}
-
 idx_t StorageManager::GetWALSize() {
-	auto wal_ptr = GetWAL();
-	if (!wal_ptr) {
-		return 0;
-	}
-	return wal_ptr->GetWALSize();
+	return wal->GetWALSize();
 }
 
 optional_ptr<WriteAheadLog> StorageManager::GetWAL() {
 	if (InMemory() || read_only || !load_complete) {
 		return nullptr;
 	}
-
-	if (!wal) {
-		auto wal_path = GetWALPath();
-		wal = make_uniq<WriteAheadLog>(db, wal_path);
-	}
 	return wal.get();
 }
 
 void StorageManager::ResetWAL() {
-	auto wal_ptr = GetWAL();
-	if (wal_ptr) {
-		wal_ptr->Delete();
-	}
-	wal.reset();
+	wal->Delete();
 }
 
 string StorageManager::GetWALPath() {
@@ -109,23 +92,25 @@ bool StorageManager::InMemory() {
 	return path == IN_MEMORY_PATH;
 }
 
-void StorageManager::Initialize(const optional_idx block_alloc_size) {
+void StorageManager::Initialize(StorageOptions options) {
 	bool in_memory = InMemory();
 	if (in_memory && read_only) {
 		throw CatalogException("Cannot launch in-memory database in read-only mode!");
 	}
 
 	// Create or load the database from disk, if not in-memory mode.
-	LoadDatabase(block_alloc_size);
+	LoadDatabase(options);
 }
 
 ///////////////////////////////////////////////////////////////////////////
 class SingleFileTableIOManager : public TableIOManager {
 public:
-	explicit SingleFileTableIOManager(BlockManager &block_manager) : block_manager(block_manager) {
+	explicit SingleFileTableIOManager(BlockManager &block_manager, idx_t row_group_size)
+	    : block_manager(block_manager), row_group_size(row_group_size) {
 	}
 
 	BlockManager &block_manager;
+	idx_t row_group_size;
 
 public:
 	BlockManager &GetIndexBlockManager() override {
@@ -137,32 +122,43 @@ public:
 	MetadataManager &GetMetadataManager() override {
 		return block_manager.GetMetadataManager();
 	}
+	idx_t GetRowGroupSize() const override {
+		return row_group_size;
+	}
 };
 
 SingleFileStorageManager::SingleFileStorageManager(AttachedDatabase &db, string path, bool read_only)
     : StorageManager(db, std::move(path), read_only) {
 }
 
-void SingleFileStorageManager::LoadDatabase(const optional_idx block_alloc_size) {
+void SingleFileStorageManager::LoadDatabase(StorageOptions storage_options) {
 	if (InMemory()) {
 		block_manager = make_uniq<InMemoryBlockManager>(BufferManager::GetBufferManager(db), DEFAULT_BLOCK_ALLOC_SIZE);
-		table_io_manager = make_uniq<SingleFileTableIOManager>(*block_manager);
+		table_io_manager = make_uniq<SingleFileTableIOManager>(*block_manager, DEFAULT_ROW_GROUP_SIZE);
 		return;
 	}
 
 	auto &fs = FileSystem::Get(db);
 	auto &config = DBConfig::Get(db);
-	if (!config.options.enable_external_access) {
-		if (!db.IsInitialDatabase()) {
-			throw PermissionException("Attaching on-disk databases is disabled through configuration");
-		}
-	}
 
 	StorageManagerOptions options;
 	options.read_only = read_only;
 	options.use_direct_io = config.options.use_direct_io;
 	options.debug_initialize = config.options.debug_initialize;
 
+	idx_t row_group_size = DEFAULT_ROW_GROUP_SIZE;
+	if (storage_options.row_group_size.IsValid()) {
+		row_group_size = storage_options.row_group_size.GetIndex();
+		if (row_group_size == 0) {
+			throw NotImplementedException("Invalid row group size: %llu - row group size must be bigger than 0",
+			                              row_group_size);
+		}
+		if (row_group_size % STANDARD_VECTOR_SIZE != 0) {
+			throw NotImplementedException(
+			    "Invalid row group size: %llu - row group size must be divisible by the vector size (%llu)",
+			    row_group_size, STANDARD_VECTOR_SIZE);
+		}
+	}
 	// Check if the database file already exists.
 	// Note: a file can also exist if there was a ROLLBACK on a previous transaction creating that file.
 	if (!read_only && !fs.FileExists(path)) {
@@ -178,9 +174,10 @@ void SingleFileStorageManager::LoadDatabase(const optional_idx block_alloc_size)
 		}
 
 		// Set the block allocation size for the new database file.
-		if (block_alloc_size.IsValid()) {
+		if (storage_options.block_alloc_size.IsValid()) {
 			// Use the option provided by the user.
-			options.block_alloc_size = block_alloc_size;
+			Storage::VerifyBlockAllocSize(storage_options.block_alloc_size.GetIndex());
+			options.block_alloc_size = storage_options.block_alloc_size;
 		} else {
 			// No explicit option provided: use the default option.
 			options.block_alloc_size = config.options.default_block_alloc_size;
@@ -190,8 +187,8 @@ void SingleFileStorageManager::LoadDatabase(const optional_idx block_alloc_size)
 		auto sf_block_manager = make_uniq<SingleFileBlockManager>(db, path, options);
 		sf_block_manager->CreateNewDatabase();
 		block_manager = std::move(sf_block_manager);
-		table_io_manager = make_uniq<SingleFileTableIOManager>(*block_manager);
-
+		table_io_manager = make_uniq<SingleFileTableIOManager>(*block_manager, row_group_size);
+		wal = make_uniq<WriteAheadLog>(db, wal_path);
 	} else {
 		// Either the file exists, or we are in read-only mode, so we
 		// try to read the existing file on disk.
@@ -202,27 +199,24 @@ void SingleFileStorageManager::LoadDatabase(const optional_idx block_alloc_size)
 		auto sf_block_manager = make_uniq<SingleFileBlockManager>(db, path, options);
 		sf_block_manager->LoadExistingDatabase();
 		block_manager = std::move(sf_block_manager);
-		table_io_manager = make_uniq<SingleFileTableIOManager>(*block_manager);
-
-		if (block_alloc_size.IsValid() && block_alloc_size.GetIndex() != block_manager->GetBlockAllocSize()) {
-			throw InvalidInputException(
-			    "block size parameter does not match the file's block size, got %llu, expected %llu",
-			    block_alloc_size.GetIndex(), block_manager->GetBlockAllocSize());
+		table_io_manager = make_uniq<SingleFileTableIOManager>(*block_manager, row_group_size);
+
+		if (storage_options.block_alloc_size.IsValid()) {
+			// user-provided block alloc size
+			idx_t block_alloc_size = storage_options.block_alloc_size.GetIndex();
+			if (block_alloc_size != block_manager->GetBlockAllocSize()) {
+				throw InvalidInputException(
+				    "block size parameter does not match the file's block size, got %llu, expected %llu",
+				    storage_options.block_alloc_size.GetIndex(), block_manager->GetBlockAllocSize());
+			}
 		}
 
 		// load the db from storage
 		auto checkpoint_reader = SingleFileCheckpointReader(*this);
 		checkpoint_reader.LoadFromStorage();
 
-		// check if the WAL file exists
 		auto wal_path = GetWALPath();
-		auto handle = fs.OpenFile(wal_path, FileFlags::FILE_FLAGS_READ | FileFlags::FILE_FLAGS_NULL_IF_NOT_EXISTS);
-		if (handle) {
-			// replay the WAL
-			if (WriteAheadLog::Replay(db, std::move(handle))) {
-				fs.RemoveFile(wal_path);
-			}
-		}
+		wal = WriteAheadLog::Replay(fs, db, wal_path);
 	}
 
 	load_complete = true;

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

@@ -114,7 +114,13 @@ void ArrayColumnData::InitializeAppend(ColumnAppendState &state) {
 }
 
 void ArrayColumnData::Append(BaseStatistics &stats, ColumnAppendState &state, Vector &vector, idx_t count) {
-	vector.Flatten(count);
+	if (vector.GetVectorType() != VectorType::FLAT_VECTOR) {
+		Vector append_vector(vector);
+		append_vector.Flatten(count);
+		Append(stats, state, append_vector, count);
+		return;
+	}
+
 	// Append validity
 	validity.Append(stats, state.child_appends[0], vector, count);
 	// Append child column

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

@@ -112,7 +112,12 @@ void PartialBlockForCheckpoint::Clear() {
 	segments.clear();
 }
 
-void ColumnCheckpointState::FlushSegment(unique_ptr<ColumnSegment> segment, idx_t segment_size) {
+void ColumnCheckpointState::FlushSegment(unique_ptr<ColumnSegment> segment, BufferHandle handle, idx_t segment_size) {
+	handle.Destroy();
+	FlushSegmentInternal(std::move(segment), segment_size);
+}
+
+void ColumnCheckpointState::FlushSegmentInternal(unique_ptr<ColumnSegment> segment, idx_t segment_size) {
 	auto block_size = partial_block_manager.GetBlockManager().GetBlockSize();
 	D_ASSERT(segment_size <= block_size);
 
@@ -166,11 +171,6 @@ void ColumnCheckpointState::FlushSegment(unique_ptr<ColumnSegment> segment, idx_
 		// Writer will decide whether to reuse this block.
 		partial_block_manager.RegisterPartialBlock(std::move(allocation));
 	} else {
-		// constant block: no need to write anything to disk besides the stats
-		// set up the compression function to constant
-		auto &config = DBConfig::GetConfig(db);
-		segment->function =
-		    *config.GetCompressionFunction(CompressionType::COMPRESSION_CONSTANT, segment->type.InternalType());
 		segment->ConvertToPersistent(nullptr, INVALID_BLOCK);
 	}
 
@@ -184,9 +184,10 @@ 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.get().type;
-	if (segment->function.get().serialize_state) {
-		data_pointer.segment_state = segment->function.get().serialize_state(*segment);
+	auto &compression_function = segment->GetCompressionFunction();
+	data_pointer.compression_type = compression_function.type;
+	if (compression_function.serialize_state) {
+		data_pointer.segment_state = compression_function.serialize_state(*segment);
 	}
 
 	// append the segment to the new segment tree

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

@@ -24,7 +24,7 @@ namespace duckdb {
 ColumnData::ColumnData(BlockManager &block_manager, DataTableInfo &info, idx_t column_index, idx_t start_row,
                        LogicalType type_p, optional_ptr<ColumnData> parent)
     : start(start_row), count(0), block_manager(block_manager), info(info), column_index(column_index),
-      type(std::move(type_p)), parent(parent), allocation_size(0) {
+      type(std::move(type_p)), allocation_size(0), parent(parent) {
 	if (!parent) {
 		stats = make_uniq<SegmentStatistics>(type);
 	}
@@ -63,6 +63,16 @@ bool ColumnData::HasUpdates() const {
 	return updates.get();
 }
 
+bool ColumnData::HasChanges(idx_t start_row, idx_t end_row) const {
+	if (!updates) {
+		return false;
+	}
+	if (updates->HasUpdates(start_row, end_row)) {
+		return true;
+	}
+	return false;
+}
+
 void ColumnData::ClearUpdates() {
 	lock_guard<mutex> update_guard(update_lock);
 	updates.reset();
@@ -136,10 +146,7 @@ void ColumnData::InitializePrefetch(PrefetchState &prefetch_state, ColumnScanSta
 	}
 }
 
-idx_t ColumnData::ScanVector(ColumnScanState &state, Vector &result, idx_t remaining, ScanVectorType scan_type) {
-	if (scan_type == ScanVectorType::SCAN_FLAT_VECTOR && result.GetVectorType() != VectorType::FLAT_VECTOR) {
-		throw InternalException("ScanVector called with SCAN_FLAT_VECTOR but result is not a flat vector");
-	}
+void ColumnData::BeginScanVectorInternal(ColumnScanState &state) {
 	state.previous_states.clear();
 	if (!state.initialized) {
 		D_ASSERT(state.current);
@@ -153,6 +160,13 @@ idx_t ColumnData::ScanVector(ColumnScanState &state, Vector &result, idx_t remai
 		state.current->Skip(state);
 	}
 	D_ASSERT(state.current->type == type);
+}
+
+idx_t ColumnData::ScanVector(ColumnScanState &state, Vector &result, idx_t remaining, ScanVectorType scan_type) {
+	if (scan_type == ScanVectorType::SCAN_FLAT_VECTOR && result.GetVectorType() != VectorType::FLAT_VECTOR) {
+		throw InternalException("ScanVector called with SCAN_FLAT_VECTOR but result is not a flat vector");
+	}
+	BeginScanVectorInternal(state);
 	idx_t initial_remaining = remaining;
 	while (remaining > 0) {
 		D_ASSERT(state.row_index >= state.current->start &&
@@ -191,6 +205,36 @@ idx_t ColumnData::ScanVector(ColumnScanState &state, Vector &result, idx_t remai
 	return initial_remaining - remaining;
 }
 
+void ColumnData::SelectVector(ColumnScanState &state, Vector &result, idx_t target_count, const SelectionVector &sel,
+                              idx_t sel_count) {
+	BeginScanVectorInternal(state);
+	if (state.current->start + state.current->count - state.row_index < target_count) {
+		throw InternalException("ColumnData::SelectVector should be able to fetch everything from one segment");
+	}
+	if (state.scan_options && state.scan_options->force_fetch_row) {
+		for (idx_t i = 0; i < sel_count; i++) {
+			auto source_idx = sel.get_index(i);
+			ColumnFetchState fetch_state;
+			state.current->FetchRow(fetch_state, UnsafeNumericCast<row_t>(state.row_index + source_idx), result, i);
+		}
+	} else {
+		state.current->Select(state, target_count, result, sel, sel_count);
+	}
+	state.row_index += target_count;
+	state.internal_index = state.row_index;
+}
+
+void ColumnData::FilterVector(ColumnScanState &state, Vector &result, idx_t target_count, SelectionVector &sel,
+                              idx_t &sel_count, const TableFilter &filter) {
+	BeginScanVectorInternal(state);
+	if (state.current->start + state.current->count - state.row_index < target_count) {
+		throw InternalException("ColumnData::Filter should be able to fetch everything from one segment");
+	}
+	state.current->Filter(state, target_count, result, sel, sel_count, filter);
+	state.row_index += target_count;
+	state.internal_index = state.row_index;
+}
+
 unique_ptr<BaseStatistics> ColumnData::GetUpdateStatistics() {
 	lock_guard<mutex> update_guard(update_lock);
 	return updates ? updates->GetStatistics() : nullptr;
@@ -230,26 +274,23 @@ void ColumnData::UpdateInternal(TransactionData transaction, idx_t column_index,
 	updates->Update(transaction, column_index, update_vector, row_ids, update_count, base_vector);
 }
 
-template <bool SCAN_COMMITTED, bool ALLOW_UPDATES>
 idx_t ColumnData::ScanVector(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
-                             idx_t target_scan) {
-	auto scan_type = GetVectorScanType(state, target_scan, result);
+                             idx_t target_scan, ScanVectorType scan_type, ScanVectorMode mode) {
 	auto scan_count = ScanVector(state, result, target_scan, scan_type);
 	if (scan_type != ScanVectorType::SCAN_ENTIRE_VECTOR) {
 		// if we are scanning an entire vector we cannot have updates
-		FetchUpdates(transaction, vector_index, result, scan_count, ALLOW_UPDATES, SCAN_COMMITTED);
+		bool allow_updates = mode != ScanVectorMode::SCAN_COMMITTED_NO_UPDATES;
+		bool scan_committed = mode != ScanVectorMode::REGULAR_SCAN;
+		FetchUpdates(transaction, vector_index, result, scan_count, allow_updates, scan_committed);
 	}
 	return scan_count;
 }
 
-template idx_t ColumnData::ScanVector<false, false>(TransactionData transaction, idx_t vector_index,
-                                                    ColumnScanState &state, Vector &result, idx_t target_scan);
-template idx_t ColumnData::ScanVector<true, false>(TransactionData transaction, idx_t vector_index,
-                                                   ColumnScanState &state, Vector &result, idx_t target_scan);
-template idx_t ColumnData::ScanVector<false, true>(TransactionData transaction, idx_t vector_index,
-                                                   ColumnScanState &state, Vector &result, idx_t target_scan);
-template idx_t ColumnData::ScanVector<true, true>(TransactionData transaction, idx_t vector_index,
-                                                  ColumnScanState &state, Vector &result, idx_t target_scan);
+idx_t ColumnData::ScanVector(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
+                             idx_t target_scan, ScanVectorMode mode) {
+	auto scan_type = GetVectorScanType(state, target_scan, result);
+	return ScanVector(transaction, vector_index, state, result, target_scan, scan_type, mode);
+}
 
 idx_t ColumnData::Scan(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result) {
 	auto target_count = GetVectorCount(vector_index);
@@ -263,16 +304,14 @@ idx_t ColumnData::ScanCommitted(idx_t vector_index, ColumnScanState &state, Vect
 
 idx_t ColumnData::Scan(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
                        idx_t scan_count) {
-	return ScanVector<false, true>(transaction, vector_index, state, result, scan_count);
+	return ScanVector(transaction, vector_index, state, result, scan_count, ScanVectorMode::REGULAR_SCAN);
 }
 
 idx_t ColumnData::ScanCommitted(idx_t vector_index, ColumnScanState &state, Vector &result, bool allow_updates,
                                 idx_t scan_count) {
-	if (allow_updates) {
-		return ScanVector<true, true>(TransactionData(0, 0), vector_index, state, result, scan_count);
-	} else {
-		return ScanVector<true, false>(TransactionData(0, 0), vector_index, state, result, scan_count);
-	}
+	auto mode = allow_updates ? ScanVectorMode::SCAN_COMMITTED : ScanVectorMode::SCAN_COMMITTED_NO_UPDATES;
+	TransactionData commit_transaction(0, 0);
+	return ScanVector(commit_transaction, vector_index, state, result, scan_count, mode);
 }
 
 idx_t ColumnData::GetVectorCount(idx_t vector_index) const {
@@ -301,7 +340,7 @@ idx_t ColumnData::ScanCount(ColumnScanState &state, Vector &result, idx_t scan_c
 	return ScanVector(state, result, scan_count, ScanVectorType::SCAN_FLAT_VECTOR);
 }
 
-void ColumnData::Select(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
+void ColumnData::Filter(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
                         SelectionVector &sel, idx_t &s_count, const TableFilter &filter) {
 	idx_t scan_count = Scan(transaction, vector_index, state, result);
 
@@ -310,14 +349,14 @@ void ColumnData::Select(TransactionData transaction, idx_t vector_index, ColumnS
 	ColumnSegment::FilterSelection(sel, result, vdata, filter, scan_count, s_count);
 }
 
-void ColumnData::FilterScan(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
-                            SelectionVector &sel, idx_t s_count) {
+void ColumnData::Select(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result,
+                        SelectionVector &sel, idx_t s_count) {
 	Scan(transaction, vector_index, state, result);
 	result.Slice(sel, s_count);
 }
 
-void ColumnData::FilterScanCommitted(idx_t vector_index, ColumnScanState &state, Vector &result, SelectionVector &sel,
-                                     idx_t s_count, bool allow_updates) {
+void ColumnData::SelectCommitted(idx_t vector_index, ColumnScanState &state, Vector &result, SelectionVector &sel,
+                                 idx_t s_count, bool allow_updates) {
 	ScanCommitted(vector_index, state, result, allow_updates);
 	result.Slice(sel, s_count);
 }
@@ -409,7 +448,7 @@ void ColumnData::InitializeAppend(ColumnAppendState &state) {
 		AppendTransientSegment(l, start);
 	}
 	auto segment = data.GetLastSegment(l);
-	if (segment->segment_type == ColumnSegmentType::PERSISTENT || !segment->function.get().init_append) {
+	if (segment->segment_type == ColumnSegmentType::PERSISTENT || !segment->GetCompressionFunction().init_append) {
 		// we cannot append to this segment - append a new segment
 		auto total_rows = segment->start + segment->count;
 		AppendTransientSegment(l, total_rows);
@@ -420,7 +459,7 @@ void ColumnData::InitializeAppend(ColumnAppendState &state) {
 
 	D_ASSERT(state.current->segment_type == ColumnSegmentType::TRANSIENT);
 	state.current->InitializeAppend(state);
-	D_ASSERT(state.current->function.get().append);
+	D_ASSERT(state.current->GetCompressionFunction().append);
 }
 
 void ColumnData::AppendData(BaseStatistics &append_stats, ColumnAppendState &state, UnifiedVectorFormat &vdata,
@@ -527,8 +566,33 @@ void ColumnData::AppendTransientSegment(SegmentLock &l, idx_t start_row) {
 	// The segment size is bound by the block size, but can be smaller.
 	idx_t segment_size = block_size < vector_segment_size ? block_size : vector_segment_size;
 	allocation_size += segment_size;
-	auto new_segment = ColumnSegment::CreateTransientSegment(GetDatabase(), type, start_row, segment_size, block_size);
-	data.AppendSegment(l, std::move(new_segment));
+
+	auto &db = GetDatabase();
+	auto &config = DBConfig::GetConfig(db);
+	auto function = config.GetCompressionFunction(CompressionType::COMPRESSION_UNCOMPRESSED, type.InternalType());
+
+	auto new_segment = ColumnSegment::CreateTransientSegment(db, *function, type, start_row, segment_size, block_size);
+	AppendSegment(l, std::move(new_segment));
+}
+
+void ColumnData::UpdateCompressionFunction(SegmentLock &l, const CompressionFunction &function) {
+	if (!compression) {
+		// compression is empty...
+		// if we have no segments - we have not set it yet, so assign it
+		// if we have segments, the compression is mixed, so ignore it
+		if (data.GetSegmentCount(l) == 0) {
+			compression.set(function);
+		}
+	} else if (compression->type != function.type) {
+		// we already have compression set - and we are adding a segment with a different compression
+		// compression in the segment is mixed - clear the compression pointer
+		compression.reset();
+	}
+}
+
+void ColumnData::AppendSegment(SegmentLock &l, unique_ptr<ColumnSegment> segment) {
+	UpdateCompressionFunction(l, segment->GetCompressionFunction());
+	data.AppendSegment(l, std::move(segment));
 }
 
 void ColumnData::CommitDropColumn() {
@@ -566,20 +630,16 @@ unique_ptr<ColumnCheckpointState> ColumnData::Checkpoint(RowGroup &row_group, Co
 	auto checkpoint_state = CreateCheckpointState(row_group, checkpoint_info.info.manager);
 	checkpoint_state->global_stats = BaseStatistics::CreateEmpty(type).ToUnique();
 
-	auto l = data.Lock();
-	auto nodes = data.MoveSegments(l);
+	auto &nodes = data.ReferenceSegments();
 	if (nodes.empty()) {
 		// empty table: flush the empty list
 		return checkpoint_state;
 	}
 
-	ColumnDataCheckpointer checkpointer(*this, row_group, *checkpoint_state, checkpoint_info);
-	checkpointer.Checkpoint(std::move(nodes));
-
-	// replace the old tree with the new one
-	data.Replace(l, checkpoint_state->new_tree);
-	ClearUpdates();
-
+	vector<reference<ColumnCheckpointState>> states {*checkpoint_state};
+	ColumnDataCheckpointer checkpointer(states, GetDatabase(), row_group, checkpoint_info);
+	checkpointer.Checkpoint();
+	checkpointer.FinalizeCheckpoint();
 	return checkpoint_state;
 }
 
@@ -606,7 +666,8 @@ void ColumnData::InitializeColumn(PersistentColumnData &column_data, BaseStatist
 		    data_pointer.row_start, data_pointer.tuple_count, data_pointer.compression_type,
 		    std::move(data_pointer.statistics), std::move(data_pointer.segment_state));
 
-		data.AppendSegment(std::move(segment));
+		auto l = data.Lock();
+		AppendSegment(l, std::move(segment));
 	}
 }
 
@@ -814,7 +875,7 @@ void ColumnData::GetColumnSegmentInfo(idx_t row_group_index, vector<idx_t> col_p
 		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.get().type);
+		column_info.compression_type = CompressionTypeToString(segment->GetCompressionFunction().type);
 		{
 			lock_guard<mutex> l(stats_lock);
 			column_info.segment_stats = segment->stats.statistics.ToString();
@@ -833,6 +894,7 @@ void ColumnData::GetColumnSegmentInfo(idx_t row_group_index, vector<idx_t> col_p
 		auto segment_state = segment->GetSegmentState();
 		if (segment_state) {
 			column_info.segment_info = segment_state->GetSegmentInfo();
+			column_info.additional_blocks = segment_state->GetAdditionalBlocks();
 		}
 		result.emplace_back(column_info);