duckdb 0.7.2-dev12.0 → 0.7.2-dev1238.0

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

@@ -10,32 +10,39 @@
 #include "duckdb/storage/table/column_data_checkpointer.hpp"
 #include "duckdb/storage/table/list_column_data.hpp"
 #include "duckdb/storage/table/standard_column_data.hpp"
-#include "duckdb/transaction/transaction.hpp"
 
 #include "duckdb/storage/table/struct_column_data.hpp"
 #include "duckdb/storage/table/update_segment.hpp"
 #include "duckdb/storage/table_storage_info.hpp"
+#include "duckdb/storage/table/append_state.hpp"
+#include "duckdb/storage/table/scan_state.hpp"
 #include "duckdb/main/attached_database.hpp"
 
 namespace duckdb {
 
 ColumnData::ColumnData(BlockManager &block_manager, DataTableInfo &info, idx_t column_index, idx_t start_row,
-                       LogicalType type, ColumnData *parent)
-    : block_manager(block_manager), info(info), column_index(column_index), start(start_row), type(std::move(type)),
-      parent(parent), version(0) {
+                       LogicalType type_p, ColumnData *parent)
+    : start(start_row), count(0), block_manager(block_manager), info(info), column_index(column_index),
+      type(std::move(type_p)), parent(parent), version(0) {
+	if (!parent) {
+		stats = make_unique<SegmentStatistics>(type);
+	}
 }
 
 ColumnData::ColumnData(ColumnData &other, idx_t start, ColumnData *parent)
-    : block_manager(other.block_manager), info(other.info), column_index(other.column_index), start(start),
-      type(std::move(other.type)), parent(parent), version(parent ? parent->version + 1 : 0) {
+    : start(start), count(other.count), block_manager(other.block_manager), info(other.info),
+      column_index(other.column_index), type(std::move(other.type)), parent(parent),
+      version(parent ? parent->version + 1 : 0) {
 	if (other.updates) {
 		updates = make_unique<UpdateSegment>(*other.updates, *this);
 	}
+	if (other.stats) {
+		stats = make_unique<SegmentStatistics>(other.stats->statistics.Copy());
+	}
 	idx_t offset = 0;
-	for (auto segment = other.data.GetRootSegment(); segment; segment = segment->Next()) {
-		auto &other = (ColumnSegment &)*segment;
-		this->data.AppendSegment(ColumnSegment::CreateSegment(other, start + offset));
-		offset += segment->count;
+	for (auto &segment : other.data.Segments()) {
+		this->data.AppendSegment(ColumnSegment::CreateSegment(segment, start + offset));
+		offset += segment.count;
 	}
 }
 
@@ -62,34 +69,29 @@ void ColumnData::IncrementVersion() {
 }
 
 idx_t ColumnData::GetMaxEntry() {
-	auto l = data.Lock();
-	auto first_segment = data.GetRootSegment(l);
-	auto last_segment = data.GetLastSegment(l);
-	if (!first_segment) {
-		D_ASSERT(!last_segment);
-		return 0;
-	} else {
-		D_ASSERT(last_segment->start >= first_segment->start);
-		return last_segment->start + last_segment->count - first_segment->start;
-	}
+	return count;
 }
 
 void ColumnData::InitializeScan(ColumnScanState &state) {
-	state.current = (ColumnSegment *)data.GetRootSegment();
+	state.current = data.GetRootSegment();
+	state.segment_tree = &data;
 	state.row_index = state.current ? state.current->start : 0;
 	state.internal_index = state.row_index;
 	state.initialized = false;
 	state.version = version;
 	state.scan_state.reset();
+	state.last_offset = 0;
 }
 
 void ColumnData::InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx) {
-	state.current = (ColumnSegment *)data.GetSegment(row_idx);
+	state.current = data.GetSegment(row_idx);
+	state.segment_tree = &data;
 	state.row_index = row_idx;
 	state.internal_index = state.current->start;
 	state.initialized = false;
 	state.version = version;
 	state.scan_state.reset();
+	state.last_offset = 0;
 }
 
 idx_t ColumnData::ScanVector(ColumnScanState &state, Vector &result, idx_t remaining) {
@@ -125,11 +127,12 @@ idx_t ColumnData::ScanVector(ColumnScanState &state, Vector &result, idx_t remai
 		}
 
 		if (remaining > 0) {
-			if (!state.current->next) {
+			auto next = data.GetNextSegment(state.current);
+			if (!next) {
 				break;
 			}
 			state.previous_states.emplace_back(std::move(state.scan_state));
-			state.current = (ColumnSegment *)state.current->Next();
+			state.current = next;
 			state.current->InitializeScan(state);
 			state.segment_checked = false;
 			D_ASSERT(state.row_index >= state.current->start &&
@@ -228,20 +231,60 @@ void ColumnData::Append(BaseStatistics &stats, ColumnAppendState &state, Vector
 	AppendData(stats, state, vdata, count);
 }
 
+void ColumnData::Append(ColumnAppendState &state, Vector &vector, idx_t count) {
+	if (parent || !stats) {
+		throw InternalException("ColumnData::Append called on a column with a parent or without stats");
+	}
+	Append(stats->statistics, state, vector, count);
+}
+
+bool ColumnData::CheckZonemap(TableFilter &filter) {
+	if (!stats) {
+		throw InternalException("ColumnData::CheckZonemap called on a column without stats");
+	}
+	auto propagate_result = filter.CheckStatistics(stats->statistics);
+	if (propagate_result == FilterPropagateResult::FILTER_ALWAYS_FALSE ||
+	    propagate_result == FilterPropagateResult::FILTER_FALSE_OR_NULL) {
+		return false;
+	}
+	return true;
+}
+
+unique_ptr<BaseStatistics> ColumnData::GetStatistics() {
+	if (!stats) {
+		throw InternalException("ColumnData::GetStatistics called on a column without stats");
+	}
+	return stats->statistics.ToUnique();
+}
+
+void ColumnData::MergeStatistics(const BaseStatistics &other) {
+	if (!stats) {
+		throw InternalException("ColumnData::MergeStatistics called on a column without stats");
+	}
+	return stats->statistics.Merge(other);
+}
+
+void ColumnData::MergeIntoStatistics(BaseStatistics &other) {
+	if (!stats) {
+		throw InternalException("ColumnData::MergeIntoStatistics called on a column without stats");
+	}
+	return other.Merge(stats->statistics);
+}
+
 void ColumnData::InitializeAppend(ColumnAppendState &state) {
 	auto l = data.Lock();
 	if (data.IsEmpty(l)) {
 		// no segments yet, append an empty segment
 		AppendTransientSegment(l, start);
 	}
-	auto segment = (ColumnSegment *)data.GetLastSegment(l);
+	auto segment = data.GetLastSegment(l);
 	if (segment->segment_type == ColumnSegmentType::PERSISTENT) {
 		// no transient segments yet
 		auto total_rows = segment->start + segment->count;
 		AppendTransientSegment(l, total_rows);
-		state.current = (ColumnSegment *)data.GetLastSegment(l);
+		state.current = data.GetLastSegment(l);
 	} else {
-		state.current = (ColumnSegment *)segment;
+		state.current = segment;
 	}
 
 	D_ASSERT(state.current->segment_type == ColumnSegmentType::TRANSIENT);
@@ -251,10 +294,11 @@ void ColumnData::InitializeAppend(ColumnAppendState &state) {
 
 void ColumnData::AppendData(BaseStatistics &stats, ColumnAppendState &state, UnifiedVectorFormat &vdata, idx_t count) {
 	idx_t offset = 0;
+	this->count += count;
 	while (true) {
 		// append the data from the vector
 		idx_t copied_elements = state.current->Append(state, vdata, offset, count);
-		stats.Merge(*state.current->stats.statistics);
+		stats.Merge(state.current->stats.statistics);
 		if (copied_elements == count) {
 			// finished copying everything
 			break;
@@ -264,7 +308,7 @@ void ColumnData::AppendData(BaseStatistics &stats, ColumnAppendState &state, Uni
 		{
 			auto l = data.Lock();
 			AppendTransientSegment(l, state.current->start + state.current->count);
-			state.current = (ColumnSegment *)data.GetLastSegment(l);
+			state.current = data.GetLastSegment(l);
 			state.current->InitializeAppend(state);
 		}
 		offset += copied_elements;
@@ -284,12 +328,13 @@ void ColumnData::RevertAppend(row_t start_row) {
 	// find the segment index that the current row belongs to
 	idx_t segment_index = data.GetSegmentIndex(l, start_row);
 	auto segment = data.GetSegmentByIndex(l, segment_index);
-	auto &transient = (ColumnSegment &)*segment;
+	auto &transient = *segment;
 	D_ASSERT(transient.segment_type == ColumnSegmentType::TRANSIENT);
 
 	// remove any segments AFTER this segment: they should be deleted entirely
 	data.EraseSegments(l, segment_index);
 
+	this->count = start_row - this->start;
 	segment->next = nullptr;
 	transient.RevertAppend(start_row);
 }
@@ -299,14 +344,14 @@ idx_t ColumnData::Fetch(ColumnScanState &state, row_t row_id, Vector &result) {
 	D_ASSERT(idx_t(row_id) >= start);
 	// perform the fetch within the segment
 	state.row_index = start + ((row_id - start) / STANDARD_VECTOR_SIZE * STANDARD_VECTOR_SIZE);
-	state.current = (ColumnSegment *)data.GetSegment(state.row_index);
+	state.current = data.GetSegment(state.row_index);
 	state.internal_index = state.current->start;
 	return ScanVector(state, result, STANDARD_VECTOR_SIZE);
 }
 
 void ColumnData::FetchRow(TransactionData transaction, ColumnFetchState &state, row_t row_id, Vector &result,
                           idx_t result_idx) {
-	auto segment = (ColumnSegment *)data.GetSegment(row_id);
+	auto segment = data.GetSegment(row_id);
 
 	// now perform the fetch within the segment
 	segment->FetchRow(state, row_id, result, result_idx);
@@ -357,15 +402,14 @@ void ColumnData::AppendTransientSegment(SegmentLock &l, idx_t start_row) {
 }
 
 void ColumnData::CommitDropColumn() {
-	auto segment = (ColumnSegment *)data.GetRootSegment();
-	while (segment) {
-		if (segment->segment_type == ColumnSegmentType::PERSISTENT) {
-			auto block_id = segment->GetBlockId();
+	for (auto &segment_p : data.Segments()) {
+		auto &segment = segment_p;
+		if (segment.segment_type == ColumnSegmentType::PERSISTENT) {
+			auto block_id = segment.GetBlockId();
 			if (block_id != INVALID_BLOCK) {
 				block_manager.MarkBlockAsModified(block_id);
 			}
 		}
-		segment = (ColumnSegment *)segment->Next();
 	}
 }
 
@@ -389,7 +433,7 @@ unique_ptr<ColumnCheckpointState> ColumnData::Checkpoint(RowGroup &row_group,
 	// scan the segments of the column data
 	// set up the checkpoint state
 	auto checkpoint_state = CreateCheckpointState(row_group, partial_block_manager);
-	checkpoint_state->global_stats = BaseStatistics::CreateEmpty(type, StatisticsType::LOCAL_STATS);
+	checkpoint_state->global_stats = BaseStatistics::CreateEmpty(type).ToUnique();
 
 	auto l = data.Lock();
 	auto nodes = data.MoveSegments(l);
@@ -411,16 +455,28 @@ unique_ptr<ColumnCheckpointState> ColumnData::Checkpoint(RowGroup &row_group,
 
 void ColumnData::DeserializeColumn(Deserializer &source) {
 	// load the data pointers for the column
+	this->count = 0;
 	idx_t data_pointer_count = source.Read<idx_t>();
 	for (idx_t data_ptr = 0; data_ptr < data_pointer_count; data_ptr++) {
 		// read the data pointer
-		DataPointer data_pointer;
-		data_pointer.row_start = source.Read<idx_t>();
-		data_pointer.tuple_count = source.Read<idx_t>();
-		data_pointer.block_pointer.block_id = source.Read<block_id_t>();
-		data_pointer.block_pointer.offset = source.Read<uint32_t>();
-		data_pointer.compression_type = source.Read<CompressionType>();
-		data_pointer.statistics = BaseStatistics::Deserialize(source, type);
+		auto row_start = source.Read<idx_t>();
+		auto tuple_count = source.Read<idx_t>();
+		auto block_pointer_block_id = source.Read<block_id_t>();
+		auto block_pointer_offset = source.Read<uint32_t>();
+		auto compression_type = source.Read<CompressionType>();
+		auto segment_stats = BaseStatistics::Deserialize(source, type);
+		if (stats) {
+			stats->statistics.Merge(segment_stats);
+		}
+
+		DataPointer data_pointer(std::move(segment_stats));
+		data_pointer.row_start = row_start;
+		data_pointer.tuple_count = tuple_count;
+		data_pointer.block_pointer.block_id = block_pointer_block_id;
+		data_pointer.block_pointer.offset = block_pointer_offset;
+		data_pointer.compression_type = compression_type;
+
+		this->count += tuple_count;
 
 		// create a persistent segment
 		auto segment = ColumnSegment::CreatePersistentSegment(
@@ -458,7 +514,6 @@ void ColumnData::GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, T
 	while (segment) {
 		ColumnSegmentInfo column_info;
 		column_info.row_group_index = row_group_index;
-		;
 		column_info.column_id = col_path[0];
 		column_info.column_path = col_path_str;
 		column_info.segment_idx = segment_idx;
@@ -466,8 +521,7 @@ void ColumnData::GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, T
 		column_info.segment_start = segment->start;
 		column_info.segment_count = segment->count;
 		column_info.compression_type = CompressionTypeToString(segment->function->type);
-		column_info.segment_stats =
-		    segment->stats.statistics ? segment->stats.statistics->ToString() : string("No Stats");
+		column_info.segment_stats = segment->stats.statistics.ToString();
 		column_info.has_updates = updates ? true : false;
 		// persistent
 		// block_id
@@ -482,7 +536,7 @@ void ColumnData::GetStorageInfo(idx_t row_group_index, vector<idx_t> col_path, T
 		result.column_segments.push_back(std::move(column_info));
 
 		segment_idx++;
-		segment = (ColumnSegment *)segment->Next();
+		segment = (ColumnSegment *)data.GetNextSegment(segment);
 	}
 }
 
@@ -490,20 +544,22 @@ void ColumnData::Verify(RowGroup &parent) {
 #ifdef DEBUG
 	D_ASSERT(this->start == parent.start);
 	data.Verify();
-	auto root = data.GetRootSegment();
-	if (root) {
-		D_ASSERT(root != nullptr);
-		D_ASSERT(root->start == this->start);
-		idx_t prev_end = root->start;
-		while (root) {
-			D_ASSERT(prev_end == root->start);
-			prev_end = root->start + root->count;
-			if (!root->next) {
-				D_ASSERT(prev_end == parent.start + parent.count);
-			}
-			root = root->Next();
-		}
+	if (type.InternalType() == PhysicalType::STRUCT) {
+		// structs don't have segments
+		D_ASSERT(!data.GetRootSegment());
+		return;
+	}
+	idx_t current_index = 0;
+	idx_t current_start = this->start;
+	idx_t total_count = 0;
+	for (auto &segment : data.Segments()) {
+		D_ASSERT(segment.index == current_index);
+		D_ASSERT(segment.start == current_start);
+		current_start += segment.count;
+		total_count += segment.count;
+		current_index++;
 	}
+	D_ASSERT(this->count == total_count);
 #endif
 }
 

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,
@@ -38,7 +40,7 @@ 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.get();
 		ColumnScanState scan_state;
 		scan_state.current = segment;
 		segment->InitializeScan(scan_state);
@@ -161,9 +163,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 +196,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,20 +216,19 @@ 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
-		DataPointer pointer;
+		DataPointer pointer(segment->stats.statistics.Copy());
 		pointer.block_pointer.block_id = segment->GetBlockId();
 		pointer.block_pointer.offset = segment->GetBlockOffset();
 		pointer.row_start = segment->start;
 		pointer.tuple_count = segment->count;
 		pointer.compression_type = segment->function->type;
-		pointer.statistics = segment->stats.statistics->Copy();
 
 		// merge the persistent stats into the global column stats
-		state.global_stats->Merge(*segment->stats.statistics);
+		state.global_stats->Merge(segment->stats.statistics);
 
 		// directly append the current segment to the new tree
 		state.new_tree.AppendSegment(std::move(nodes[segment_idx].node));
@@ -236,7 +237,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

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>
 
@@ -19,7 +18,7 @@ unique_ptr<ColumnSegment> ColumnSegment::CreatePersistentSegment(DatabaseInstanc
                                                                  block_id_t block_id, idx_t offset,
                                                                  const LogicalType &type, idx_t start, idx_t count,
                                                                  CompressionType compression_type,
-                                                                 unique_ptr<BaseStatistics> statistics) {
+                                                                 BaseStatistics statistics) {
 	auto &config = DBConfig::GetConfig(db);
 	CompressionFunction *function;
 	shared_ptr<BlockHandle> block;
@@ -48,7 +47,7 @@ unique_ptr<ColumnSegment> ColumnSegment::CreateTransientSegment(DatabaseInstance
 		buffer_manager.Allocate(segment_size, false, &block);
 	}
 	return make_unique<ColumnSegment>(db, std::move(block), type, ColumnSegmentType::TRANSIENT, start, 0, function,
-	                                  nullptr, INVALID_BLOCK, 0, segment_size);
+	                                  BaseStatistics::CreateEmpty(type), INVALID_BLOCK, 0, segment_size);
 }
 
 unique_ptr<ColumnSegment> ColumnSegment::CreateSegment(ColumnSegment &other, idx_t start) {
@@ -57,11 +56,11 @@ unique_ptr<ColumnSegment> ColumnSegment::CreateSegment(ColumnSegment &other, idx
 
 ColumnSegment::ColumnSegment(DatabaseInstance &db, shared_ptr<BlockHandle> block, LogicalType type_p,
                              ColumnSegmentType segment_type, idx_t start, idx_t count, CompressionFunction *function_p,
-                             unique_ptr<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(type, std::move(statistics)), block(std::move(block)),
-      block_id(block_id_p), offset(offset_p), segment_size(segment_size_p) {
+                             BaseStatistics statistics, block_id_t block_id_p, idx_t offset_p, idx_t segment_size_p)
+    : 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) {
 	D_ASSERT(function);
 	if (function->init_segment) {
 		segment_state = function->init_segment(*this, block_id);
@@ -69,10 +68,10 @@ ColumnSegment::ColumnSegment(DatabaseInstance &db, shared_ptr<BlockHandle> block
 }
 
 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() {
@@ -181,13 +180,12 @@ void ColumnSegment::ConvertToPersistent(BlockManager *block_manager, block_id_t
 	block_id = block_id_p;
 	offset = 0;
 
-	D_ASSERT(stats.statistics);
 	if (block_id == INVALID_BLOCK) {
 		// constant block: reset the block buffer
-		D_ASSERT(stats.statistics->IsConstant());
+		D_ASSERT(stats.statistics.IsConstant());
 		block.reset();
 	} else {
-		D_ASSERT(!stats.statistics->IsConstant());
+		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
@@ -218,12 +216,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);
 		}
 	}
@@ -231,7 +229,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
@@ -372,104 +370,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;