duckdb 1.3.2 → 1.3.3-dev4.0

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

@@ -25,7 +25,7 @@ unique_ptr<BaseStatistics> ColumnCheckpointState::GetStatistics() {
 PartialBlockForCheckpoint::PartialBlockForCheckpoint(ColumnData &data, ColumnSegment &segment, PartialBlockState state,
                                                      BlockManager &block_manager)
     : PartialBlock(state, block_manager, segment.block) {
-	AddSegmentToTail(data, segment, 0);
+	PartialBlockForCheckpoint::AddSegmentToTail(data, segment, 0);
 }
 
 PartialBlockForCheckpoint::~PartialBlockForCheckpoint() {
@@ -36,7 +36,7 @@ bool PartialBlockForCheckpoint::IsFlushed() {
 	return segments.empty();
 }
 
-void PartialBlockForCheckpoint::Flush(const idx_t free_space_left) {
+void PartialBlockForCheckpoint::Flush(QueryContext context, const idx_t free_space_left) {
 	if (IsFlushed()) {
 		throw InternalException("Flush called on partial block that was already flushed");
 	}
@@ -58,7 +58,7 @@ void PartialBlockForCheckpoint::Flush(const idx_t free_space_left) {
 		if (i == 0) {
 			// the first segment is converted to persistent - this writes the data for ALL segments to disk
 			D_ASSERT(segment.offset_in_block == 0);
-			segment.segment.ConvertToPersistent(&block_manager, state.block_id);
+			segment.segment.ConvertToPersistent(context, &block_manager, state.block_id);
 			// update the block after it has been converted to a persistent segment
 			block_handle = segment.segment.block;
 		} else {
@@ -126,29 +126,32 @@ void ColumnCheckpointState::FlushSegmentInternal(unique_ptr<ColumnSegment> segme
 		return;
 	} // LCOV_EXCL_STOP
 
-	// merge the segment stats into the global stats
+	// Merge the segment statistics into the global statistics.
 	global_stats->Merge(segment->stats.statistics);
 
-	// get the buffer of the segment and pin it
-	auto &db = column_data.GetDatabase();
-	auto &buffer_manager = BufferManager::GetBufferManager(db);
 	block_id_t block_id = INVALID_BLOCK;
 	uint32_t offset_in_block = 0;
 
 	unique_lock<mutex> partial_block_lock;
-	if (!segment->stats.statistics.IsConstant()) {
+	if (segment->stats.statistics.IsConstant()) {
+		// Constant block.
+		segment->ConvertToPersistent(partial_block_manager.GetClientContext(), nullptr, INVALID_BLOCK);
+
+	} else if (segment_size != 0) {
+		// Non-constant block with data that has to go to disk.
+		auto &db = column_data.GetDatabase();
+		auto &buffer_manager = BufferManager::GetBufferManager(db);
 		partial_block_lock = partial_block_manager.GetLock();
 
-		// non-constant block
-		PartialBlockAllocation allocation =
-		    partial_block_manager.GetBlockAllocation(NumericCast<uint32_t>(segment_size));
+		auto cast_segment_size = NumericCast<uint32_t>(segment_size);
+		auto allocation = partial_block_manager.GetBlockAllocation(cast_segment_size);
 		block_id = allocation.state.block_id;
 		offset_in_block = allocation.state.offset;
 
 		if (allocation.partial_block) {
 			// Use an existing block.
 			D_ASSERT(offset_in_block > 0);
-			auto &pstate = allocation.partial_block->Cast<PartialBlockForCheckpoint>();
+			auto &pstate = *allocation.partial_block;
 			// pin the source block
 			auto old_handle = buffer_manager.Pin(segment->block);
 			// pin the target block
@@ -165,13 +168,17 @@ void ColumnCheckpointState::FlushSegmentInternal(unique_ptr<ColumnSegment> segme
 				segment->Resize(block_size);
 			}
 			D_ASSERT(offset_in_block == 0);
-			allocation.partial_block = make_uniq<PartialBlockForCheckpoint>(column_data, *segment, allocation.state,
-			                                                                *allocation.block_manager);
+			allocation.partial_block = partial_block_manager.CreatePartialBlock(column_data, *segment, allocation.state,
+			                                                                    *allocation.block_manager);
 		}
 		// Writer will decide whether to reuse this block.
 		partial_block_manager.RegisterPartialBlock(std::move(allocation));
+
 	} else {
-		segment->ConvertToPersistent(nullptr, INVALID_BLOCK);
+		// Empty segment, which does not have to go to disk.
+		// We still need to change its type to persistent, because we need to write its metadata.
+		segment->segment_type = ColumnSegmentType::PERSISTENT;
+		segment->block.reset();
 	}
 
 	// construct the data pointer

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

@@ -77,6 +77,29 @@ bool ColumnData::HasChanges(idx_t start_row, idx_t end_row) const {
 	return false;
 }
 
+bool ColumnData::HasChanges() const {
+	auto l = data.Lock();
+	auto &nodes = data.ReferenceLoadedSegments(l);
+	for (idx_t segment_idx = 0; segment_idx < nodes.size(); segment_idx++) {
+		auto segment = nodes[segment_idx].node.get();
+		if (segment->segment_type == ColumnSegmentType::TRANSIENT) {
+			// transient segment: always need to write to disk
+			return true;
+		}
+		// persistent segment; check if there were any updates or deletions in this segment
+		idx_t start_row_idx = segment->start - start;
+		idx_t end_row_idx = start_row_idx + segment->count;
+		if (HasChanges(start_row_idx, end_row_idx)) {
+			return true;
+		}
+	}
+	return false;
+}
+
+bool ColumnData::HasAnyChanges() const {
+	return HasChanges();
+}
+
 void ColumnData::ClearUpdates() {
 	lock_guard<mutex> update_guard(update_lock);
 	updates.reset();
@@ -392,7 +415,8 @@ FilterPropagateResult ColumnData::CheckZonemap(ColumnScanState &state, TableFilt
 	if (!state.current) {
 		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
 	}
-	state.segment_checked = true;
+	// for dynamic filters we never consider the segment being "checked" as it can always change
+	state.segment_checked = filter.filter_type != TableFilterType::DYNAMIC_FILTER;
 	FilterPropagateResult prune_result;
 	{
 		lock_guard<mutex> l(stats_lock);
@@ -493,27 +517,37 @@ void ColumnData::AppendData(BaseStatistics &append_stats, ColumnAppendState &sta
 	}
 }
 
-void ColumnData::RevertAppend(row_t start_row) {
+void ColumnData::RevertAppend(row_t start_row_p) {
+	idx_t start_row = NumericCast<idx_t>(start_row_p);
 	auto l = data.Lock();
 	// check if this row is in the segment tree at all
 	auto last_segment = data.GetLastSegment(l);
-	if (NumericCast<idx_t>(start_row) >= last_segment->start + last_segment->count) {
+	if (!last_segment) {
+		return;
+	}
+	if (start_row >= last_segment->start + last_segment->count) {
 		// the start row is equal to the final portion of the column data: nothing was ever appended here
-		D_ASSERT(NumericCast<idx_t>(start_row) == last_segment->start + last_segment->count);
+		D_ASSERT(start_row == last_segment->start + last_segment->count);
 		return;
 	}
 	// find the segment index that the current row belongs to
-	idx_t segment_index = data.GetSegmentIndex(l, UnsafeNumericCast<idx_t>(start_row));
+	idx_t segment_index = data.GetSegmentIndex(l, start_row);
 	auto segment = data.GetSegmentByIndex(l, UnsafeNumericCast<int64_t>(segment_index));
-	auto &transient = *segment;
-	D_ASSERT(transient.segment_type == ColumnSegmentType::TRANSIENT);
+	if (segment->start == start_row) {
+		// we are truncating exactly this segment - erase it entirely
+		data.EraseSegments(l, segment_index);
+	} else {
+		// we need to truncate within the segment
+		// remove any segments AFTER this segment: they should be deleted entirely
+		data.EraseSegments(l, segment_index + 1);
 
-	// remove any segments AFTER this segment: they should be deleted entirely
-	data.EraseSegments(l, segment_index);
+		auto &transient = *segment;
+		D_ASSERT(transient.segment_type == ColumnSegmentType::TRANSIENT);
+		segment->next = nullptr;
+		transient.RevertAppend(start_row);
+	}
 
-	this->count = UnsafeNumericCast<idx_t>(start_row) - this->start;
-	segment->next = nullptr;
-	transient.RevertAppend(UnsafeNumericCast<idx_t>(start_row));
+	this->count = start_row - this->start;
 }
 
 idx_t ColumnData::Fetch(ColumnScanState &state, row_t row_id, Vector &result) {
@@ -538,13 +572,18 @@ void ColumnData::FetchRow(TransactionData transaction, ColumnFetchState &state,
 	FetchUpdateRow(transaction, row_id, result, result_idx);
 }
 
+idx_t ColumnData::FetchUpdateData(ColumnScanState &state, row_t *row_ids, Vector &base_vector) {
+	auto fetch_count = ColumnData::Fetch(state, row_ids[0], base_vector);
+	base_vector.Flatten(fetch_count);
+	return fetch_count;
+}
+
 void ColumnData::Update(TransactionData transaction, idx_t column_index, Vector &update_vector, row_t *row_ids,
                         idx_t update_count) {
 	Vector base_vector(type);
 	ColumnScanState state;
-	auto fetch_count = Fetch(state, row_ids[0], base_vector);
+	FetchUpdateData(state, row_ids, base_vector);
 
-	base_vector.Flatten(fetch_count);
 	UpdateInternal(transaction, column_index, update_vector, row_ids, update_count, base_vector);
 }
 

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

@@ -5,6 +5,7 @@
 #include "duckdb/storage/data_table.hpp"
 #include "duckdb/parser/column_definition.hpp"
 #include "duckdb/storage/table/scan_state.hpp"
+#include "duckdb/logging/log_manager.hpp"
 #include "duckdb/main/database.hpp"
 
 namespace duckdb {
@@ -38,6 +39,10 @@ ColumnCheckpointState &ColumnDataCheckpointData::GetCheckpointState() {
 	return *checkpoint_state;
 }
 
+StorageManager &ColumnDataCheckpointData::GetStorageManager() {
+	return *storage_manager;
+}
+
 //! ColumnDataCheckpointer
 
 static Vector CreateIntermediateVector(vector<reference<ColumnCheckpointState>> &states) {
@@ -49,6 +54,9 @@ static Vector CreateIntermediateVector(vector<reference<ColumnCheckpointState>>
 	if (type.id() == LogicalTypeId::VALIDITY) {
 		return Vector(LogicalType::BOOLEAN, true, /* initialize_to_zero = */ true);
 	}
+	if (type.InternalType() == PhysicalType::LIST) {
+		return Vector(LogicalType::UBIGINT, true, false);
+	}
 	return Vector(type, true, false);
 }
 
@@ -325,8 +333,8 @@ void ColumnDataCheckpointer::WriteToDisk() {
 		auto &checkpoint_state = checkpoint_states[i];
 		auto &col_data = checkpoint_state.get().column_data;
 
-		checkpoint_data[i] =
-		    ColumnDataCheckpointData(checkpoint_state, col_data, col_data.GetDatabase(), row_group, checkpoint_info);
+		checkpoint_data[i] = ColumnDataCheckpointData(checkpoint_state, col_data, col_data.GetDatabase(), row_group,
+		                                              checkpoint_info, storage_manager);
 		compression_states[i] = function->init_compression(checkpoint_data[i], std::move(analyze_state));
 	}
 
@@ -354,21 +362,7 @@ void ColumnDataCheckpointer::WriteToDisk() {
 }
 
 bool ColumnDataCheckpointer::HasChanges(ColumnData &col_data) {
-	auto &nodes = col_data.data.ReferenceSegments();
-	for (idx_t segment_idx = 0; segment_idx < nodes.size(); segment_idx++) {
-		auto segment = nodes[segment_idx].node.get();
-		if (segment->segment_type == ColumnSegmentType::TRANSIENT) {
-			// transient segment: always need to write to disk
-			return true;
-		}
-		// persistent segment; check if there were any updates or deletions in this segment
-		idx_t start_row_idx = segment->start - row_group.start;
-		idx_t end_row_idx = start_row_idx + segment->count;
-		if (col_data.HasChanges(start_row_idx, end_row_idx)) {
-			return true;
-		}
-	}
-	return false;
+	return col_data.HasChanges();
 }
 
 void ColumnDataCheckpointer::WritePersistentSegments(ColumnCheckpointState &state) {
@@ -378,8 +372,14 @@ void ColumnDataCheckpointer::WritePersistentSegments(ColumnCheckpointState &stat
 	auto &col_data = state.column_data;
 	auto nodes = col_data.data.MoveSegments();
 
+	idx_t current_row = row_group.start;
 	for (idx_t segment_idx = 0; segment_idx < nodes.size(); segment_idx++) {
 		auto segment = nodes[segment_idx].node.get();
+		if (segment->start != current_row) {
+			throw InternalException(
+			    "Failure in RowGroup::Checkpoint - column data pointer is unaligned with row group start");
+		}
+		current_row += segment->count;
 		auto pointer = segment->GetDataPointer();
 
 		// merge the persistent stats into the global column stats

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

@@ -35,10 +35,8 @@ unique_ptr<ColumnSegment> ColumnSegment::CreatePersistentSegment(DatabaseInstanc
 	optional_ptr<CompressionFunction> function;
 	shared_ptr<BlockHandle> block;
 
-	if (block_id == INVALID_BLOCK) {
-		function = config.GetCompressionFunction(CompressionType::COMPRESSION_CONSTANT, type.InternalType());
-	} else {
-		function = config.GetCompressionFunction(compression_type, type.InternalType());
+	function = config.GetCompressionFunction(compression_type, type.InternalType());
+	if (block_id != INVALID_BLOCK) {
 		block = block_manager.RegisterBlock(block_id);
 	}
 
@@ -223,35 +221,39 @@ void ColumnSegment::RevertAppend(idx_t start_row) {
 //===--------------------------------------------------------------------===//
 // Convert To Persistent
 //===--------------------------------------------------------------------===//
-void ColumnSegment::ConvertToPersistent(optional_ptr<BlockManager> block_manager, block_id_t block_id_p) {
+void ColumnSegment::ConvertToPersistent(QueryContext context, optional_ptr<BlockManager> block_manager,
+                                        const block_id_t block_id_p) {
 	D_ASSERT(segment_type == ColumnSegmentType::TRANSIENT);
 	segment_type = ColumnSegmentType::PERSISTENT;
-
 	block_id = block_id_p;
 	offset = 0;
 
-	if (block_id == INVALID_BLOCK) {
-		// constant block: no need to write anything to disk besides the stats
-		// set up the compression function to constant
-		D_ASSERT(stats.statistics.IsConstant());
-		auto &config = DBConfig::GetConfig(db);
-		function = *config.GetCompressionFunction(CompressionType::COMPRESSION_CONSTANT, type.InternalType());
-		// reset the block buffer
-		block.reset();
-	} else {
+	if (block_id != INVALID_BLOCK) {
 		D_ASSERT(!stats.statistics.IsConstant());
-		// non-constant block: write the block to disk
-		// the data for the block already exists in-memory of our block
-		// instead of copying the data we alter some metadata so the buffer points to an on-disk block
-		block = block_manager->ConvertToPersistent(block_id, std::move(block));
+		// Non-constant block: write the block to disk.
+		// The block data already exists in memory, so we alter the metadata,
+		// which ensures that the buffer points to an on-disk block.
+		block = block_manager->ConvertToPersistent(context, block_id, std::move(block));
+		return;
 	}
+
+	// Constant block: no need to write anything to disk besides the stats (metadata).
+	// I.e., we do not need to write an actual block.
+	// Thus, we set the compression function to constant and reset the block buffer.
+	D_ASSERT(stats.statistics.IsConstant());
+	auto &config = DBConfig::GetConfig(db);
+	function = *config.GetCompressionFunction(CompressionType::COMPRESSION_CONSTANT, type.InternalType());
+	block.reset();
 }
 
 void ColumnSegment::MarkAsPersistent(shared_ptr<BlockHandle> block_p, uint32_t offset_p) {
 	D_ASSERT(segment_type == ColumnSegmentType::TRANSIENT);
-	segment_type = ColumnSegmentType::PERSISTENT;
-
 	block_id = block_p->BlockId();
+	SetBlock(std::move(block_p), offset_p);
+}
+
+void ColumnSegment::SetBlock(shared_ptr<BlockHandle> block_p, uint32_t offset_p) {
+	segment_type = ColumnSegmentType::PERSISTENT;
 	offset = offset_p;
 	block = std::move(block_p);
 }

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

@@ -0,0 +1,136 @@
+#include "duckdb/storage/table/in_memory_checkpoint.hpp"
+#include "duckdb/common/serializer/binary_serializer.hpp"
+#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
+#include "duckdb/catalog/duck_catalog.hpp"
+
+namespace duckdb {
+
+//===--------------------------------------------------------------------===//
+// In-Memory Checkpoint Writer
+//===--------------------------------------------------------------------===//
+InMemoryCheckpointer::InMemoryCheckpointer(QueryContext context, AttachedDatabase &db, BlockManager &block_manager,
+                                           StorageManager &storage_manager, CheckpointType checkpoint_type)
+    : CheckpointWriter(db), context(context.GetClientContext()),
+      partial_block_manager(context, block_manager, PartialBlockType::IN_MEMORY_CHECKPOINT),
+      storage_manager(storage_manager), checkpoint_type(checkpoint_type) {
+}
+
+void InMemoryCheckpointer::CreateCheckpoint() {
+	vector<reference<SchemaCatalogEntry>> schemas;
+	// we scan the set of committed schemas
+	auto &catalog = Catalog::GetCatalog(db).Cast<DuckCatalog>();
+	catalog.ScanSchemas([&](SchemaCatalogEntry &entry) { schemas.push_back(entry); });
+
+	vector<reference<TableCatalogEntry>> tables;
+	for (const auto &schema_ref : schemas) {
+		auto &schema = schema_ref.get();
+		schema.Scan(CatalogType::TABLE_ENTRY, [&](CatalogEntry &entry) {
+			if (entry.type == CatalogType::TABLE_ENTRY) {
+				tables.push_back(entry.Cast<TableCatalogEntry>());
+			}
+		});
+	}
+
+	for (auto &table : tables) {
+		MemoryStream write_stream;
+		BinarySerializer serializer(write_stream);
+
+		WriteTable(table, serializer);
+	}
+	storage_manager.ResetInMemoryChange();
+}
+
+MetadataWriter &InMemoryCheckpointer::GetMetadataWriter() {
+	throw InternalException("Unsupported method GetMetadataWriter for InMemoryCheckpointer");
+}
+MetadataManager &InMemoryCheckpointer::GetMetadataManager() {
+	throw InternalException("Unsupported method GetMetadataManager for InMemoryCheckpointer");
+}
+unique_ptr<TableDataWriter> InMemoryCheckpointer::GetTableDataWriter(TableCatalogEntry &table) {
+	throw InternalException("Unsupported method GetTableDataWriter for InMemoryCheckpointer");
+}
+
+void InMemoryCheckpointer::WriteTable(TableCatalogEntry &table, Serializer &serializer) {
+	InMemoryTableDataWriter data_writer(*this, table);
+
+	// Write the table data
+	auto table_lock = table.GetStorage().GetCheckpointLock();
+	table.GetStorage().Checkpoint(data_writer, serializer);
+	// flush any partial blocks BEFORE releasing the table lock
+	// flushing partial blocks updates where data lives and is not thread-safe
+	partial_block_manager.FlushPartialBlocks();
+}
+
+InMemoryRowGroupWriter::InMemoryRowGroupWriter(TableCatalogEntry &table, PartialBlockManager &partial_block_manager,
+                                               InMemoryCheckpointer &checkpoint_manager)
+    : RowGroupWriter(table, partial_block_manager), checkpoint_manager(checkpoint_manager) {
+}
+
+CheckpointType InMemoryRowGroupWriter::GetCheckpointType() const {
+	return checkpoint_manager.GetCheckpointType();
+}
+
+WriteStream &InMemoryRowGroupWriter::GetPayloadWriter() {
+	return metadata_writer;
+}
+
+MetaBlockPointer InMemoryRowGroupWriter::GetMetaBlockPointer() {
+	return MetaBlockPointer();
+}
+
+optional_ptr<MetadataManager> InMemoryRowGroupWriter::GetMetadataManager() {
+	return nullptr;
+}
+
+InMemoryTableDataWriter::InMemoryTableDataWriter(InMemoryCheckpointer &checkpoint_manager, TableCatalogEntry &table)
+    : TableDataWriter(table, checkpoint_manager.GetClientContext()), checkpoint_manager(checkpoint_manager) {
+}
+
+void InMemoryTableDataWriter::WriteUnchangedTable(MetaBlockPointer pointer, idx_t total_rows) {
+}
+
+void InMemoryTableDataWriter::FinalizeTable(const TableStatistics &global_stats, DataTableInfo &info,
+                                            RowGroupCollection &collection, Serializer &serializer) {
+	// nop: no need to write anything
+}
+
+unique_ptr<RowGroupWriter> InMemoryTableDataWriter::GetRowGroupWriter(RowGroup &row_group) {
+	return make_uniq<InMemoryRowGroupWriter>(table, checkpoint_manager.GetPartialBlockManager(), checkpoint_manager);
+}
+
+CheckpointType InMemoryTableDataWriter::GetCheckpointType() const {
+	return checkpoint_manager.GetCheckpointType();
+}
+
+MetadataManager &InMemoryTableDataWriter::GetMetadataManager() {
+	return checkpoint_manager.GetMetadataManager();
+}
+
+InMemoryPartialBlock::InMemoryPartialBlock(ColumnData &data, ColumnSegment &segment, PartialBlockState state,
+                                           BlockManager &block_manager)
+    : PartialBlock(state, block_manager, segment.block) {
+	AddSegmentToTail(data, segment, 0);
+}
+
+InMemoryPartialBlock::~InMemoryPartialBlock() {
+}
+
+void InMemoryPartialBlock::Flush(QueryContext context, const idx_t free_space_left) {
+	Clear();
+}
+
+void InMemoryPartialBlock::Merge(PartialBlock &other_p, idx_t offset, idx_t other_size) {
+	auto &other = other_p.Cast<InMemoryPartialBlock>();
+	other.Clear();
+}
+
+void InMemoryPartialBlock::AddSegmentToTail(ColumnData &data, ColumnSegment &segment, uint32_t offset_in_block) {
+	segment.SetBlock(block_handle, offset_in_block);
+}
+
+void InMemoryPartialBlock::Clear() {
+	uninitialized_regions.clear();
+	block_handle.reset();
+}
+
+} // namespace duckdb

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

@@ -57,7 +57,7 @@ void ListColumnData::InitializeScan(ColumnScanState &state) {
 uint64_t ListColumnData::FetchListOffset(idx_t row_idx) {
 	auto segment = data.GetSegment(row_idx);
 	ColumnFetchState fetch_state;
-	Vector result(type, 1);
+	Vector result(LogicalType::UBIGINT, 1);
 	segment->FetchRow(fetch_state, UnsafeNumericCast<row_t>(row_idx), result, 0U);
 
 	// initialize the child scan with the required offset
@@ -235,6 +235,7 @@ void ListColumnData::Append(BaseStatistics &stats, ColumnAppendState &state, Vec
 	UnifiedVectorFormat vdata;
 	vdata.sel = FlatVector::IncrementalSelectionVector();
 	vdata.data = data_ptr_cast(append_offsets.get());
+	vdata.physical_type = PhysicalType::UINT64;
 
 	// append the child vector
 	if (child_count > 0) {
@@ -372,6 +373,10 @@ bool ListColumnData::IsPersistent() {
 	return ColumnData::IsPersistent() && validity.IsPersistent() && child_column->IsPersistent();
 }
 
+bool ListColumnData::HasAnyChanges() const {
+	return ColumnData::HasAnyChanges() || validity.HasAnyChanges() || child_column->HasAnyChanges();
+}
+
 PersistentColumnData ListColumnData::Serialize() {
 	auto persistent_data = ColumnData::Serialize();
 	persistent_data.child_columns.push_back(validity.Serialize());