duckdb 0.7.2-dev314.0 → 0.7.2-dev3154.0

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

@@ -3,6 +3,8 @@
 #include "duckdb/storage/table/update_segment.hpp"
 #include "duckdb/storage/data_table.hpp"
 #include "duckdb/parser/column_definition.hpp"
+#include "duckdb/storage/table/scan_state.hpp"
+
 namespace duckdb {
 
 ColumnDataCheckpointer::ColumnDataCheckpointer(ColumnData &col_data_p, RowGroup &row_group_p,
@@ -12,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() {
@@ -38,16 +43,16 @@ ColumnCheckpointState &ColumnDataCheckpointer::GetCheckpointState() {
 void ColumnDataCheckpointer::ScanSegments(const std::function<void(Vector &, idx_t)> &callback) {
 	Vector scan_vector(intermediate.GetType(), nullptr);
 	for (idx_t segment_idx = 0; segment_idx < nodes.size(); segment_idx++) {
-		auto segment = (ColumnSegment *)nodes[segment_idx].node.get();
+		auto &segment = *nodes[segment_idx].node;
 		ColumnScanState scan_state;
-		scan_state.current = segment;
-		segment->InitializeScan(scan_state);
+		scan_state.current = &segment;
+		segment.InitializeScan(scan_state);
 
-		for (idx_t base_row_index = 0; base_row_index < segment->count; base_row_index += STANDARD_VECTOR_SIZE) {
+		for (idx_t base_row_index = 0; base_row_index < segment.count; base_row_index += STANDARD_VECTOR_SIZE) {
 			scan_vector.Reference(intermediate);
 
-			idx_t count = MinValue<idx_t>(segment->count - base_row_index, STANDARD_VECTOR_SIZE);
-			scan_state.row_index = segment->start + base_row_index;
+			idx_t count = MinValue<idx_t>(segment.count - base_row_index, STANDARD_VECTOR_SIZE);
+			scan_state.row_index = segment.start + base_row_index;
 
 			col_data.CheckpointScan(segment, scan_state, row_group.start, count, scan_vector);
 
@@ -56,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;
 		}
@@ -72,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;
 			}
 		}
@@ -161,9 +168,9 @@ void ColumnDataCheckpointer::WriteToDisk() {
 	// first we check the current segments
 	// if there are any persistent segments, we will mark their old block ids as modified
 	// since the segments will be rewritten their old on disk data is no longer required
-	auto &block_manager = col_data.block_manager;
+	auto &block_manager = col_data.GetBlockManager();
 	for (idx_t segment_idx = 0; segment_idx < nodes.size(); segment_idx++) {
-		auto segment = (ColumnSegment *)nodes[segment_idx].node.get();
+		auto segment = nodes[segment_idx].node.get();
 		if (segment->segment_type == ColumnSegmentType::PERSISTENT) {
 			// persistent segment has updates: mark it as modified and rewrite the block with the merged updates
 			auto block_id = segment->GetBlockId();
@@ -194,7 +201,7 @@ void ColumnDataCheckpointer::WriteToDisk() {
 
 bool ColumnDataCheckpointer::HasChanges() {
 	for (idx_t segment_idx = 0; segment_idx < nodes.size(); segment_idx++) {
-		auto segment = (ColumnSegment *)nodes[segment_idx].node.get();
+		auto segment = nodes[segment_idx].node.get();
 		if (segment->segment_type == ColumnSegmentType::TRANSIENT) {
 			// transient segment: always need to write to disk
 			return true;
@@ -214,7 +221,7 @@ void ColumnDataCheckpointer::WritePersistentSegments() {
 	// all segments are persistent and there are no updates
 	// we only need to write the metadata
 	for (idx_t segment_idx = 0; segment_idx < nodes.size(); segment_idx++) {
-		auto segment = (ColumnSegment *)nodes[segment_idx].node.get();
+		auto segment = nodes[segment_idx].node.get();
 		D_ASSERT(segment->segment_type == ColumnSegmentType::PERSISTENT);
 
 		// set up the data pointer directly using the data from the persistent segment
@@ -223,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);
@@ -235,7 +242,7 @@ void ColumnDataCheckpointer::WritePersistentSegments() {
 	}
 }
 
-void ColumnDataCheckpointer::Checkpoint(vector<SegmentNode> nodes) {
+void ColumnDataCheckpointer::Checkpoint(vector<SegmentNode<ColumnSegment>> nodes) {
 	D_ASSERT(!nodes.empty());
 	this->nodes = std::move(nodes);
 	// first check if any of the segments have changes
@@ -243,9 +250,16 @@ void ColumnDataCheckpointer::Checkpoint(vector<SegmentNode> nodes) {
 		// no changes: only need to write the metadata for this column
 		WritePersistentSegments();
 	} else {
-		// there are changes: rewrite the set of columns
+		// there are changes: rewrite the set of columns);
 		WriteToDisk();
 	}
 }
 
+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

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

@@ -3,13 +3,12 @@
 #include "duckdb/storage/table/update_segment.hpp"
 #include "duckdb/common/types/null_value.hpp"
 #include "duckdb/common/types/vector.hpp"
-#include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/storage/table/append_state.hpp"
 #include "duckdb/storage/storage_manager.hpp"
 #include "duckdb/planner/filter/conjunction_filter.hpp"
 #include "duckdb/planner/filter/constant_filter.hpp"
-#include "duckdb/planner/filter/null_filter.hpp"
 #include "duckdb/main/config.hpp"
+#include "duckdb/storage/table/scan_state.hpp"
 
 #include <cstring>
 
@@ -21,7 +20,7 @@ unique_ptr<ColumnSegment> ColumnSegment::CreatePersistentSegment(DatabaseInstanc
                                                                  CompressionType compression_type,
                                                                  BaseStatistics statistics) {
 	auto &config = DBConfig::GetConfig(db);
-	CompressionFunction *function;
+	optional_ptr<CompressionFunction> function;
 	shared_ptr<BlockHandle> block;
 	if (block_id == INVALID_BLOCK) {
 		// constant segment, no need to allocate an actual block
@@ -31,8 +30,8 @@ unique_ptr<ColumnSegment> ColumnSegment::CreatePersistentSegment(DatabaseInstanc
 		block = block_manager.RegisterBlock(block_id);
 	}
 	auto segment_size = Storage::BLOCK_SIZE;
-	return make_unique<ColumnSegment>(db, std::move(block), type, ColumnSegmentType::PERSISTENT, start, count, function,
-	                                  std::move(statistics), block_id, offset, segment_size);
+	return make_uniq<ColumnSegment>(db, std::move(block), type, ColumnSegmentType::PERSISTENT, start, count, *function,
+	                                std::move(statistics), block_id, offset, segment_size);
 }
 
 unique_ptr<ColumnSegment> ColumnSegment::CreateTransientSegment(DatabaseInstance &db, const LogicalType &type,
@@ -47,31 +46,31 @@ unique_ptr<ColumnSegment> ColumnSegment::CreateTransientSegment(DatabaseInstance
 	} else {
 		buffer_manager.Allocate(segment_size, false, &block);
 	}
-	return make_unique<ColumnSegment>(db, std::move(block), type, ColumnSegmentType::TRANSIENT, start, 0, function,
-	                                  BaseStatistics::CreateEmpty(type), INVALID_BLOCK, 0, segment_size);
+	return make_uniq<ColumnSegment>(db, std::move(block), type, ColumnSegmentType::TRANSIENT, start, 0, *function,
+	                                BaseStatistics::CreateEmpty(type), INVALID_BLOCK, 0, segment_size);
 }
 
 unique_ptr<ColumnSegment> ColumnSegment::CreateSegment(ColumnSegment &other, idx_t start) {
-	return make_unique<ColumnSegment>(other, start);
+	return make_uniq<ColumnSegment>(other, start);
 }
 
 ColumnSegment::ColumnSegment(DatabaseInstance &db, shared_ptr<BlockHandle> block, LogicalType type_p,
-                             ColumnSegmentType segment_type, idx_t start, idx_t count, CompressionFunction *function_p,
+                             ColumnSegmentType segment_type, idx_t start, idx_t count, CompressionFunction &function_p,
                              BaseStatistics statistics, block_id_t block_id_p, idx_t offset_p, idx_t segment_size_p)
-    : SegmentBase(start, count), db(db), type(std::move(type_p)), type_size(GetTypeIdSize(type.InternalType())),
-      segment_type(segment_type), function(function_p), stats(std::move(statistics)), block(std::move(block)),
-      block_id(block_id_p), offset(offset_p), segment_size(segment_size_p) {
-	D_ASSERT(function);
-	if (function->init_segment) {
-		segment_state = function->init_segment(*this, block_id);
+    : SegmentBase<ColumnSegment>(start, count), db(db), type(std::move(type_p)),
+      type_size(GetTypeIdSize(type.InternalType())), segment_type(segment_type), function(function_p),
+      stats(std::move(statistics)), block(std::move(block)), block_id(block_id_p), offset(offset_p),
+      segment_size(segment_size_p) {
+	if (function.get().init_segment) {
+		segment_state = function.get().init_segment(*this, block_id);
 	}
 }
 
 ColumnSegment::ColumnSegment(ColumnSegment &other, idx_t start)
-    : SegmentBase(start, other.count), db(other.db), type(std::move(other.type)), type_size(other.type_size),
-      segment_type(other.segment_type), function(other.function), stats(std::move(other.stats)),
-      block(std::move(other.block)), block_id(other.block_id), offset(other.offset), segment_size(other.segment_size),
-      segment_state(std::move(other.segment_state)) {
+    : SegmentBase<ColumnSegment>(start, other.count.load()), db(other.db), type(std::move(other.type)),
+      type_size(other.type_size), segment_type(other.segment_type), function(other.function),
+      stats(std::move(other.stats)), block(std::move(other.block)), block_id(other.block_id), offset(other.offset),
+      segment_size(other.segment_size), segment_state(std::move(other.segment_state)) {
 }
 
 ColumnSegment::~ColumnSegment() {
@@ -81,7 +80,7 @@ ColumnSegment::~ColumnSegment() {
 // Scan
 //===--------------------------------------------------------------------===//
 void ColumnSegment::InitializeScan(ColumnScanState &state) {
-	state.scan_state = function->init_scan(*this);
+	state.scan_state = function.get().init_scan(*this);
 }
 
 void ColumnSegment::Scan(ColumnScanState &state, idx_t scan_count, Vector &result, idx_t result_offset,
@@ -97,23 +96,23 @@ void ColumnSegment::Scan(ColumnScanState &state, idx_t scan_count, Vector &resul
 }
 
 void ColumnSegment::Skip(ColumnScanState &state) {
-	function->skip(*this, state, state.row_index - state.internal_index);
+	function.get().skip(*this, state, state.row_index - state.internal_index);
 	state.internal_index = state.row_index;
 }
 
 void ColumnSegment::Scan(ColumnScanState &state, idx_t scan_count, Vector &result) {
-	function->scan_vector(*this, state, scan_count, result);
+	function.get().scan_vector(*this, state, scan_count, result);
 }
 
 void ColumnSegment::ScanPartial(ColumnScanState &state, idx_t scan_count, Vector &result, idx_t result_offset) {
-	function->scan_partial(*this, state, scan_count, result, result_offset);
+	function.get().scan_partial(*this, state, scan_count, result, result_offset);
 }
 
 //===--------------------------------------------------------------------===//
 // Fetch
 //===--------------------------------------------------------------------===//
 void ColumnSegment::FetchRow(ColumnFetchState &state, row_t row_id, Vector &result, idx_t result_idx) {
-	function->fetch_row(*this, state, row_id - this->start, result, result_idx);
+	function.get().fetch_row(*this, state, row_id - this->start, result, result_idx);
 }
 
 //===--------------------------------------------------------------------===//
@@ -138,34 +137,34 @@ void ColumnSegment::Resize(idx_t new_size) {
 
 void ColumnSegment::InitializeAppend(ColumnAppendState &state) {
 	D_ASSERT(segment_type == ColumnSegmentType::TRANSIENT);
-	if (!function->init_append) {
+	if (!function.get().init_append) {
 		throw InternalException("Attempting to init append to a segment without init_append method");
 	}
-	state.append_state = function->init_append(*this);
+	state.append_state = function.get().init_append(*this);
 }
 
 idx_t ColumnSegment::Append(ColumnAppendState &state, UnifiedVectorFormat &append_data, idx_t offset, idx_t count) {
 	D_ASSERT(segment_type == ColumnSegmentType::TRANSIENT);
-	if (!function->append) {
+	if (!function.get().append) {
 		throw InternalException("Attempting to append to a segment without append method");
 	}
-	return function->append(*state.append_state, *this, stats, append_data, offset, count);
+	return function.get().append(*state.append_state, *this, stats, append_data, offset, count);
 }
 
 idx_t ColumnSegment::FinalizeAppend(ColumnAppendState &state) {
 	D_ASSERT(segment_type == ColumnSegmentType::TRANSIENT);
-	if (!function->finalize_append) {
+	if (!function.get().finalize_append) {
 		throw InternalException("Attempting to call FinalizeAppend on a segment without a finalize_append method");
 	}
-	auto result_count = function->finalize_append(*this, stats);
+	auto result_count = function.get().finalize_append(*this, stats);
 	state.append_state.reset();
 	return result_count;
 }
 
 void ColumnSegment::RevertAppend(idx_t start_row) {
 	D_ASSERT(segment_type == ColumnSegmentType::TRANSIENT);
-	if (function->revert_append) {
-		function->revert_append(*this, start_row);
+	if (function.get().revert_append) {
+		function.get().revert_append(*this, start_row);
 	}
 	this->count = start_row - this->start;
 }
@@ -173,7 +172,7 @@ void ColumnSegment::RevertAppend(idx_t start_row) {
 //===--------------------------------------------------------------------===//
 // Convert To Persistent
 //===--------------------------------------------------------------------===//
-void ColumnSegment::ConvertToPersistent(BlockManager *block_manager, block_id_t block_id_p) {
+void ColumnSegment::ConvertToPersistent(optional_ptr<BlockManager> block_manager, block_id_t block_id_p) {
 	D_ASSERT(segment_type == ColumnSegmentType::TRANSIENT);
 	segment_type = ColumnSegmentType::PERSISTENT;
 
@@ -193,8 +192,8 @@ void ColumnSegment::ConvertToPersistent(BlockManager *block_manager, block_id_t
 	}
 
 	segment_state.reset();
-	if (function->init_segment) {
-		segment_state = function->init_segment(*this, block_id);
+	if (function.get().init_segment) {
+		segment_state = function.get().init_segment(*this, block_id);
 	}
 }
 
@@ -207,8 +206,8 @@ void ColumnSegment::MarkAsPersistent(shared_ptr<BlockHandle> block_p, uint32_t o
 	block = std::move(block_p);
 
 	segment_state.reset();
-	if (function->init_segment) {
-		segment_state = function->init_segment(*this, block_id);
+	if (function.get().init_segment) {
+		segment_state = function.get().init_segment(*this, block_id);
 	}
 }
 
@@ -216,12 +215,12 @@ void ColumnSegment::MarkAsPersistent(shared_ptr<BlockHandle> block_p, uint32_t o
 // Filter Selection
 //===--------------------------------------------------------------------===//
 template <class T, class OP, bool HAS_NULL>
-static idx_t TemplatedFilterSelection(T *vec, T *predicate, SelectionVector &sel, idx_t approved_tuple_count,
+static idx_t TemplatedFilterSelection(T *vec, T predicate, SelectionVector &sel, idx_t approved_tuple_count,
                                       ValidityMask &mask, SelectionVector &result_sel) {
 	idx_t result_count = 0;
 	for (idx_t i = 0; i < approved_tuple_count; i++) {
 		auto idx = sel.get_index(i);
-		if ((!HAS_NULL || mask.RowIsValid(idx)) && OP::Operation(vec[idx], *predicate)) {
+		if ((!HAS_NULL || mask.RowIsValid(idx)) && OP::Operation(vec[idx], predicate)) {
 			result_sel.set_index(result_count++, idx);
 		}
 	}
@@ -229,7 +228,7 @@ static idx_t TemplatedFilterSelection(T *vec, T *predicate, SelectionVector &sel
 }
 
 template <class T>
-static void FilterSelectionSwitch(T *vec, T *predicate, SelectionVector &sel, idx_t &approved_tuple_count,
+static void FilterSelectionSwitch(T *vec, T predicate, SelectionVector &sel, idx_t &approved_tuple_count,
                                   ExpressionType comparison_type, ValidityMask &mask) {
 	SelectionVector new_sel(approved_tuple_count);
 	// the inplace loops take the result as the last parameter
@@ -370,104 +369,91 @@ idx_t ColumnSegment::FilterSelection(SelectionVector &sel, Vector &result, const
 		switch (result.GetType().InternalType()) {
 		case PhysicalType::UINT8: {
 			auto result_flat = FlatVector::GetData<uint8_t>(result);
-			Vector predicate_vector(constant_filter.constant);
-			auto predicate = FlatVector::GetData<uint8_t>(predicate_vector);
+			auto predicate = UTinyIntValue::Get(constant_filter.constant);
 			FilterSelectionSwitch<uint8_t>(result_flat, predicate, sel, approved_tuple_count,
 			                               constant_filter.comparison_type, mask);
 			break;
 		}
 		case PhysicalType::UINT16: {
 			auto result_flat = FlatVector::GetData<uint16_t>(result);
-			Vector predicate_vector(constant_filter.constant);
-			auto predicate = FlatVector::GetData<uint16_t>(predicate_vector);
+			auto predicate = USmallIntValue::Get(constant_filter.constant);
 			FilterSelectionSwitch<uint16_t>(result_flat, predicate, sel, approved_tuple_count,
 			                                constant_filter.comparison_type, mask);
 			break;
 		}
 		case PhysicalType::UINT32: {
 			auto result_flat = FlatVector::GetData<uint32_t>(result);
-			Vector predicate_vector(constant_filter.constant);
-			auto predicate = FlatVector::GetData<uint32_t>(predicate_vector);
+			auto predicate = UIntegerValue::Get(constant_filter.constant);
 			FilterSelectionSwitch<uint32_t>(result_flat, predicate, sel, approved_tuple_count,
 			                                constant_filter.comparison_type, mask);
 			break;
 		}
 		case PhysicalType::UINT64: {
 			auto result_flat = FlatVector::GetData<uint64_t>(result);
-			Vector predicate_vector(constant_filter.constant);
-			auto predicate = FlatVector::GetData<uint64_t>(predicate_vector);
+			auto predicate = UBigIntValue::Get(constant_filter.constant);
 			FilterSelectionSwitch<uint64_t>(result_flat, predicate, sel, approved_tuple_count,
 			                                constant_filter.comparison_type, mask);
 			break;
 		}
 		case PhysicalType::INT8: {
 			auto result_flat = FlatVector::GetData<int8_t>(result);
-			Vector predicate_vector(constant_filter.constant);
-			auto predicate = FlatVector::GetData<int8_t>(predicate_vector);
+			auto predicate = TinyIntValue::Get(constant_filter.constant);
 			FilterSelectionSwitch<int8_t>(result_flat, predicate, sel, approved_tuple_count,
 			                              constant_filter.comparison_type, mask);
 			break;
 		}
 		case PhysicalType::INT16: {
 			auto result_flat = FlatVector::GetData<int16_t>(result);
-			Vector predicate_vector(constant_filter.constant);
-			auto predicate = FlatVector::GetData<int16_t>(predicate_vector);
+			auto predicate = SmallIntValue::Get(constant_filter.constant);
 			FilterSelectionSwitch<int16_t>(result_flat, predicate, sel, approved_tuple_count,
 			                               constant_filter.comparison_type, mask);
 			break;
 		}
 		case PhysicalType::INT32: {
 			auto result_flat = FlatVector::GetData<int32_t>(result);
-			Vector predicate_vector(constant_filter.constant);
-			auto predicate = FlatVector::GetData<int32_t>(predicate_vector);
+			auto predicate = IntegerValue::Get(constant_filter.constant);
 			FilterSelectionSwitch<int32_t>(result_flat, predicate, sel, approved_tuple_count,
 			                               constant_filter.comparison_type, mask);
 			break;
 		}
 		case PhysicalType::INT64: {
 			auto result_flat = FlatVector::GetData<int64_t>(result);
-			Vector predicate_vector(constant_filter.constant);
-			auto predicate = FlatVector::GetData<int64_t>(predicate_vector);
+			auto predicate = BigIntValue::Get(constant_filter.constant);
 			FilterSelectionSwitch<int64_t>(result_flat, predicate, sel, approved_tuple_count,
 			                               constant_filter.comparison_type, mask);
 			break;
 		}
 		case PhysicalType::INT128: {
 			auto result_flat = FlatVector::GetData<hugeint_t>(result);
-			Vector predicate_vector(constant_filter.constant);
-			auto predicate = FlatVector::GetData<hugeint_t>(predicate_vector);
+			auto predicate = HugeIntValue::Get(constant_filter.constant);
 			FilterSelectionSwitch<hugeint_t>(result_flat, predicate, sel, approved_tuple_count,
 			                                 constant_filter.comparison_type, mask);
 			break;
 		}
 		case PhysicalType::FLOAT: {
 			auto result_flat = FlatVector::GetData<float>(result);
-			Vector predicate_vector(constant_filter.constant);
-			auto predicate = FlatVector::GetData<float>(predicate_vector);
+			auto predicate = FloatValue::Get(constant_filter.constant);
 			FilterSelectionSwitch<float>(result_flat, predicate, sel, approved_tuple_count,
 			                             constant_filter.comparison_type, mask);
 			break;
 		}
 		case PhysicalType::DOUBLE: {
 			auto result_flat = FlatVector::GetData<double>(result);
-			Vector predicate_vector(constant_filter.constant);
-			auto predicate = FlatVector::GetData<double>(predicate_vector);
+			auto predicate = DoubleValue::Get(constant_filter.constant);
 			FilterSelectionSwitch<double>(result_flat, predicate, sel, approved_tuple_count,
 			                              constant_filter.comparison_type, mask);
 			break;
 		}
 		case PhysicalType::VARCHAR: {
 			auto result_flat = FlatVector::GetData<string_t>(result);
-			Vector predicate_vector(constant_filter.constant);
-			auto predicate = FlatVector::GetData<string_t>(predicate_vector);
+			auto predicate = string_t(StringValue::Get(constant_filter.constant));
 			FilterSelectionSwitch<string_t>(result_flat, predicate, sel, approved_tuple_count,
 			                                constant_filter.comparison_type, mask);
 			break;
 		}
 		case PhysicalType::BOOL: {
 			auto result_flat = FlatVector::GetData<bool>(result);
-			Vector predicate_vector(constant_filter.constant);
-			auto predicate = FlatVector::GetData<bool>(predicate_vector);
+			auto predicate = BooleanValue::Get(constant_filter.constant);
 			FilterSelectionSwitch<bool>(result_flat, predicate, sel, approved_tuple_count,
 			                            constant_filter.comparison_type, mask);
 			break;

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

@@ -1,23 +1,26 @@
 #include "duckdb/storage/table/list_column_data.hpp"
 #include "duckdb/storage/statistics/list_stats.hpp"
 #include "duckdb/transaction/transaction.hpp"
+#include "duckdb/storage/table/column_checkpoint_state.hpp"
+#include "duckdb/storage/table/append_state.hpp"
+#include "duckdb/storage/table/scan_state.hpp"
 
 namespace duckdb {
 
 ListColumnData::ListColumnData(BlockManager &block_manager, DataTableInfo &info, idx_t column_index, idx_t start_row,
-                               LogicalType type_p, ColumnData *parent)
+                               LogicalType type_p, optional_ptr<ColumnData> parent)
     : ColumnData(block_manager, info, column_index, start_row, std::move(type_p), parent),
-      validity(block_manager, info, 0, start_row, this) {
+      validity(block_manager, info, 0, start_row, *this) {
 	D_ASSERT(type.InternalType() == PhysicalType::LIST);
 	auto &child_type = ListType::GetChildType(type);
 	// the child column, with column index 1 (0 is the validity mask)
 	child_column = ColumnData::CreateColumnUnique(block_manager, info, 1, start_row, child_type, this);
 }
 
-ListColumnData::ListColumnData(ColumnData &original, idx_t start_row, ColumnData *parent)
-    : ColumnData(original, start_row, parent), validity(((ListColumnData &)original).validity, start_row, this) {
-	auto &list_data = (ListColumnData &)original;
-	child_column = ColumnData::CreateColumnUnique(*list_data.child_column, start_row, this);
+void ListColumnData::SetStart(idx_t new_start) {
+	ColumnData::SetStart(new_start);
+	child_column->SetStart(new_start);
+	validity.SetStart(new_start);
 }
 
 bool ListColumnData::CheckZonemap(ColumnScanState &state, TableFilter &filter) {
@@ -29,18 +32,15 @@ void ListColumnData::InitializeScan(ColumnScanState &state) {
 	ColumnData::InitializeScan(state);
 
 	// initialize the validity segment
-	ColumnScanState validity_state;
-	validity.InitializeScan(validity_state);
-	state.child_states.push_back(std::move(validity_state));
+	D_ASSERT(state.child_states.size() == 2);
+	validity.InitializeScan(state.child_states[0]);
 
 	// initialize the child scan
-	ColumnScanState child_state;
-	child_column->InitializeScan(child_state);
-	state.child_states.push_back(std::move(child_state));
+	child_column->InitializeScan(state.child_states[1]);
 }
 
 uint64_t ListColumnData::FetchListOffset(idx_t row_idx) {
-	auto segment = (ColumnSegment *)data.GetSegment(row_idx);
+	auto segment = data.GetSegment(row_idx);
 	ColumnFetchState fetch_state;
 	Vector result(type, 1);
 	segment->FetchRow(fetch_state, row_idx, result, 0);
@@ -57,19 +57,16 @@ void ListColumnData::InitializeScanWithOffset(ColumnScanState &state, idx_t row_
 	ColumnData::InitializeScanWithOffset(state, row_idx);
 
 	// initialize the validity segment
-	ColumnScanState validity_state;
-	validity.InitializeScanWithOffset(validity_state, row_idx);
-	state.child_states.push_back(std::move(validity_state));
+	D_ASSERT(state.child_states.size() == 2);
+	validity.InitializeScanWithOffset(state.child_states[0], row_idx);
 
 	// we need to read the list at position row_idx to get the correct row offset of the child
 	auto child_offset = row_idx == start ? 0 : FetchListOffset(row_idx - 1);
 
 	D_ASSERT(child_offset <= child_column->GetMaxEntry());
-	ColumnScanState child_state;
 	if (child_offset < child_column->GetMaxEntry()) {
-		child_column->InitializeScanWithOffset(child_state, start + child_offset);
+		child_column->InitializeScanWithOffset(state.child_states[1], start + child_offset);
 	}
-	state.child_states.push_back(std::move(child_state));
 }
 
 idx_t ListColumnData::Scan(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result) {
@@ -261,7 +258,7 @@ void ListColumnData::FetchRow(TransactionData transaction, ColumnFetchState &sta
 	// note that we need a scan state for the child vector
 	// this is because we will (potentially) fetch more than one tuple from the list child
 	if (state.child_states.empty()) {
-		auto child_state = make_unique<ColumnFetchState>();
+		auto child_state = make_uniq<ColumnFetchState>();
 		state.child_states.push_back(std::move(child_state));
 	}
 
@@ -285,10 +282,11 @@ void ListColumnData::FetchRow(TransactionData transaction, ColumnFetchState &sta
 	// now we need to read from the child all the elements between [offset...length]
 	auto child_scan_count = list_entry.length;
 	if (child_scan_count > 0) {
-		auto child_state = make_unique<ColumnScanState>();
+		auto child_state = make_uniq<ColumnScanState>();
 		auto &child_type = ListType::GetChildType(result.GetType());
 		Vector child_scan(child_type, child_scan_count);
 		// seek the scan towards the specified position and read [length] entries
+		child_state->Initialize(child_type);
 		child_column->InitializeScanWithOffset(*child_state, start + start_offset);
 		D_ASSERT(child_type.InternalType() == PhysicalType::STRUCT ||
 		         child_state->row_index + child_scan_count - this->start <= child_column->GetMaxEntry());
@@ -324,16 +322,11 @@ public:
 		validity_state->WriteDataPointers(writer);
 		child_state->WriteDataPointers(writer);
 	}
-	void GetBlockIds(unordered_set<block_id_t> &result) override {
-		ColumnCheckpointState::GetBlockIds(result);
-		validity_state->GetBlockIds(result);
-		child_state->GetBlockIds(result);
-	}
 };
 
 unique_ptr<ColumnCheckpointState> ListColumnData::CreateCheckpointState(RowGroup &row_group,
                                                                         PartialBlockManager &partial_block_manager) {
-	return make_unique<ListColumnCheckpointState>(row_group, *this, partial_block_manager);
+	return make_uniq<ListColumnCheckpointState>(row_group, *this, partial_block_manager);
 }
 
 unique_ptr<ColumnCheckpointState> ListColumnData::Checkpoint(RowGroup &row_group,

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

@@ -3,7 +3,8 @@
 
 namespace duckdb {
 
-PersistentTableData::PersistentTableData(idx_t column_count) {
+PersistentTableData::PersistentTableData(idx_t column_count)
+    : total_rows(0), row_group_count(0), block_id(INVALID_BLOCK), offset(0) {
 }
 
 PersistentTableData::~PersistentTableData() {