duckdb 1.1.2-dev6.0 → 1.1.4-dev11.0

package/src/duckdb/src/storage/standard_buffer_manager.cpp

@@ -15,8 +15,14 @@
 namespace duckdb {
 
 #ifdef DUCKDB_DEBUG_DESTROY_BLOCKS
-static void WriteGarbageIntoBuffer(FileBuffer &buffer) {
-	memset(buffer.buffer, 0xa5, buffer.size); // 0xa5 is default memory in debug mode
+static void WriteGarbageIntoBuffer(BlockLock &lock, BlockHandle &block) {
+	auto &buffer = block.GetBuffer(lock);
+	memset(buffer->buffer, 0xa5, buffer->size); // 0xa5 is default memory in debug mode
+}
+
+static void WriteGarbageIntoBuffer(BlockHandle &block) {
+	auto lock = block.GetLock();
+	WriteGarbageIntoBuffer(lock, block);
 }
 #endif
 
@@ -30,6 +36,9 @@ struct BufferAllocatorData : PrivateAllocatorData {
 unique_ptr<FileBuffer> StandardBufferManager::ConstructManagedBuffer(idx_t size, unique_ptr<FileBuffer> &&source,
                                                                      FileBufferType type) {
 	unique_ptr<FileBuffer> result;
+	if (type == FileBufferType::BLOCK) {
+		throw InternalException("ConstructManagedBuffer cannot be used to construct blocks");
+	}
 	if (source) {
 		auto tmp = std::move(source);
 		D_ASSERT(tmp->AllocSize() == BufferManager::GetAllocSize(size));
@@ -123,27 +132,26 @@ shared_ptr<BlockHandle> StandardBufferManager::RegisterTransientMemory(const idx
 	// Otherwise, any non-default block size would register as small memory, causing problems when
 	// trying to convert that memory to consistent blocks later on.
 	if (size < block_size) {
-		return RegisterSmallMemory(size);
+		return RegisterSmallMemory(MemoryTag::IN_MEMORY_TABLE, size);
 	}
 
 	auto buffer_handle = Allocate(MemoryTag::IN_MEMORY_TABLE, size, false);
 	return buffer_handle.GetBlockHandle();
 }
 
-shared_ptr<BlockHandle> StandardBufferManager::RegisterSmallMemory(const idx_t size) {
+shared_ptr<BlockHandle> StandardBufferManager::RegisterSmallMemory(MemoryTag tag, const idx_t size) {
 	D_ASSERT(size < GetBlockSize());
-	auto reservation = EvictBlocksOrThrow(MemoryTag::BASE_TABLE, size, nullptr, "could not allocate block of size %s%s",
+	auto reservation = EvictBlocksOrThrow(tag, size, nullptr, "could not allocate block of size %s%s",
 	                                      StringUtil::BytesToHumanReadableString(size));
 
 	auto buffer = ConstructManagedBuffer(size, nullptr, FileBufferType::TINY_BUFFER);
 
 	// Create a new block pointer for this block.
-	auto result =
-	    make_shared_ptr<BlockHandle>(*temp_block_manager, ++temporary_id, MemoryTag::BASE_TABLE, std::move(buffer),
-	                                 DestroyBufferUpon::BLOCK, size, std::move(reservation));
+	auto result = make_shared_ptr<BlockHandle>(*temp_block_manager, ++temporary_id, tag, std::move(buffer),
+	                                           DestroyBufferUpon::BLOCK, size, std::move(reservation));
 #ifdef DUCKDB_DEBUG_DESTROY_BLOCKS
 	// Initialize the memory with garbage data
-	WriteGarbageIntoBuffer(*result->buffer);
+	WriteGarbageIntoBuffer(*result);
 #endif
 	return result;
 }
@@ -168,20 +176,22 @@ BufferHandle StandardBufferManager::Allocate(MemoryTag tag, idx_t block_size, bo
 
 #ifdef DUCKDB_DEBUG_DESTROY_BLOCKS
 	// Initialize the memory with garbage data
-	WriteGarbageIntoBuffer(*block->buffer);
+	WriteGarbageIntoBuffer(*block);
 #endif
 	return Pin(block);
 }
 
 void StandardBufferManager::ReAllocate(shared_ptr<BlockHandle> &handle, idx_t block_size) {
 	D_ASSERT(block_size >= GetBlockSize());
-	unique_lock<mutex> lock(handle->lock);
-	D_ASSERT(handle->state == BlockState::BLOCK_LOADED);
-	D_ASSERT(handle->memory_usage == handle->buffer->AllocSize());
-	D_ASSERT(handle->memory_usage == handle->memory_charge.size);
+	auto lock = handle->GetLock();
 
-	auto req = handle->buffer->CalculateMemory(block_size);
-	int64_t memory_delta = NumericCast<int64_t>(req.alloc_size) - NumericCast<int64_t>(handle->memory_usage);
+	auto handle_memory_usage = handle->GetMemoryUsage();
+	D_ASSERT(handle->GetState() == BlockState::BLOCK_LOADED);
+	D_ASSERT(handle_memory_usage == handle->GetBuffer(lock)->AllocSize());
+	D_ASSERT(handle_memory_usage == handle->GetMemoryCharge(lock).size);
+
+	auto req = handle->GetBuffer(lock)->CalculateMemory(block_size);
+	int64_t memory_delta = NumericCast<int64_t>(req.alloc_size) - NumericCast<int64_t>(handle_memory_usage);
 
 	if (memory_delta == 0) {
 		return;
@@ -189,20 +199,20 @@ void StandardBufferManager::ReAllocate(shared_ptr<BlockHandle> &handle, idx_t bl
 		// evict blocks until we have space to resize this block
 		// unlock the handle lock during the call to EvictBlocksOrThrow
 		lock.unlock();
-		auto reservation = EvictBlocksOrThrow(handle->tag, NumericCast<idx_t>(memory_delta), nullptr,
+		auto reservation = EvictBlocksOrThrow(handle->GetMemoryTag(), NumericCast<idx_t>(memory_delta), nullptr,
 		                                      "failed to resize block from %s to %s%s",
-		                                      StringUtil::BytesToHumanReadableString(handle->memory_usage),
+		                                      StringUtil::BytesToHumanReadableString(handle_memory_usage),
 		                                      StringUtil::BytesToHumanReadableString(req.alloc_size));
 		lock.lock();
 
 		// EvictBlocks decrements 'current_memory' for us.
-		handle->memory_charge.Merge(std::move(reservation));
+		handle->MergeMemoryReservation(lock, std::move(reservation));
 	} else {
 		// no need to evict blocks, but we do need to decrement 'current_memory'.
-		handle->memory_charge.Resize(req.alloc_size);
+		handle->ResizeMemory(lock, req.alloc_size);
 	}
 
-	handle->ResizeBuffer(block_size, memory_delta);
+	handle->ResizeBuffer(lock, block_size, memory_delta);
 }
 
 void StandardBufferManager::BatchRead(vector<shared_ptr<BlockHandle>> &handles, const map<block_id_t, idx_t> &load_map,
@@ -231,27 +241,25 @@ void StandardBufferManager::BatchRead(vector<shared_ptr<BlockHandle>> &handles,
 		auto &handle = handles[entry->second];
 
 		// reserve memory for the block
-		idx_t required_memory = handle->memory_usage;
+		idx_t required_memory = handle->GetMemoryUsage();
 		unique_ptr<FileBuffer> reusable_buffer;
-		auto reservation =
-		    EvictBlocksOrThrow(handle->tag, required_memory, &reusable_buffer, "failed to pin block of size %s%s",
-		                       StringUtil::BytesToHumanReadableString(required_memory));
+		auto reservation = EvictBlocksOrThrow(handle->GetMemoryTag(), required_memory, &reusable_buffer,
+		                                      "failed to pin block of size %s%s",
+		                                      StringUtil::BytesToHumanReadableString(required_memory));
 		// now load the block from the buffer
 		// note that we discard the buffer handle - we do not keep it around
 		// the prefetching relies on the block handle being pinned again during the actual read before it is evicted
 		BufferHandle buf;
 		{
-			lock_guard<mutex> lock(handle->lock);
-			if (handle->state == BlockState::BLOCK_LOADED) {
+			auto lock = handle->GetLock();
+			if (handle->GetState() == BlockState::BLOCK_LOADED) {
 				// the block is loaded already by another thread - free up the reservation and continue
 				reservation.Resize(0);
 				continue;
 			}
 			auto block_ptr =
 			    intermediate_buffer.GetFileBuffer().InternalBuffer() + block_idx * block_manager.GetBlockAllocSize();
-			buf = handle->LoadFromBuffer(block_ptr, std::move(reusable_buffer));
-			handle->readers = 1;
-			handle->memory_charge = std::move(reservation);
+			buf = handle->LoadFromBuffer(lock, block_ptr, std::move(reusable_buffer), std::move(reservation));
 		}
 	}
 }
@@ -261,8 +269,7 @@ void StandardBufferManager::Prefetch(vector<shared_ptr<BlockHandle>> &handles) {
 	map<block_id_t, idx_t> to_be_loaded;
 	for (idx_t block_idx = 0; block_idx < handles.size(); block_idx++) {
 		auto &handle = handles[block_idx];
-		lock_guard<mutex> lock(handle->lock);
-		if (handle->state != BlockState::BLOCK_LOADED) {
+		if (handle->GetState() != BlockState::BLOCK_LOADED) {
 			// need to load this block - add it to the map
 			to_be_loaded.insert(make_pair(handle->BlockId(), block_idx));
 		}
@@ -305,14 +312,13 @@ BufferHandle StandardBufferManager::Pin(shared_ptr<BlockHandle> &handle) {
 	idx_t required_memory;
 	{
 		// lock the block
-		lock_guard<mutex> lock(handle->lock);
+		auto lock = handle->GetLock();
 		// check if the block is already loaded
-		if (handle->state == BlockState::BLOCK_LOADED) {
+		if (handle->GetState() == BlockState::BLOCK_LOADED) {
 			// the block is loaded, increment the reader count and set the BufferHandle
-			handle->readers++;
 			buf = handle->Load();
 		}
-		required_memory = handle->memory_usage;
+		required_memory = handle->GetMemoryUsage();
 	}
 
 	if (buf.IsValid()) {
@@ -320,33 +326,30 @@ BufferHandle StandardBufferManager::Pin(shared_ptr<BlockHandle> &handle) {
 	} else {
 		// evict blocks until we have space for the current block
 		unique_ptr<FileBuffer> reusable_buffer;
-		auto reservation =
-		    EvictBlocksOrThrow(handle->tag, required_memory, &reusable_buffer, "failed to pin block of size %s%s",
-		                       StringUtil::BytesToHumanReadableString(required_memory));
+		auto reservation = EvictBlocksOrThrow(handle->GetMemoryTag(), required_memory, &reusable_buffer,
+		                                      "failed to pin block of size %s%s",
+		                                      StringUtil::BytesToHumanReadableString(required_memory));
 
 		// lock the handle again and repeat the check (in case anybody loaded in the meantime)
-		lock_guard<mutex> lock(handle->lock);
+		auto lock = handle->GetLock();
 		// check if the block is already loaded
-		if (handle->state == BlockState::BLOCK_LOADED) {
+		if (handle->GetState() == BlockState::BLOCK_LOADED) {
 			// the block is loaded, increment the reader count and return a pointer to the handle
-			handle->readers++;
 			reservation.Resize(0);
 			buf = handle->Load();
 		} else {
 			// now we can actually load the current block
-			D_ASSERT(handle->readers == 0);
+			D_ASSERT(handle->Readers() == 0);
 			buf = handle->Load(std::move(reusable_buffer));
-			handle->readers = 1;
-			handle->memory_charge = std::move(reservation);
+			auto &memory_charge = handle->GetMemoryCharge(lock);
+			memory_charge = std::move(reservation);
 			// in the case of a variable sized block, the buffer may be smaller than a full block.
-			int64_t delta =
-			    NumericCast<int64_t>(handle->buffer->AllocSize()) - NumericCast<int64_t>(handle->memory_usage);
+			int64_t delta = NumericCast<int64_t>(handle->GetBuffer(lock)->AllocSize()) -
+			                NumericCast<int64_t>(handle->GetMemoryUsage());
 			if (delta) {
-				D_ASSERT(delta < 0);
-				handle->memory_usage += static_cast<idx_t>(delta);
-				handle->memory_charge.Resize(handle->memory_usage);
+				handle->ChangeMemoryUsage(lock, delta);
 			}
-			D_ASSERT(handle->memory_usage == handle->buffer->AllocSize());
+			D_ASSERT(handle->GetMemoryUsage() == handle->GetBuffer(lock)->AllocSize());
 		}
 	}
 
@@ -356,46 +359,54 @@ BufferHandle StandardBufferManager::Pin(shared_ptr<BlockHandle> &handle) {
 	return buf;
 }
 
-void StandardBufferManager::PurgeQueue(FileBufferType type) {
-	buffer_pool.PurgeQueue(type);
+void StandardBufferManager::PurgeQueue(const BlockHandle &handle) {
+	buffer_pool.PurgeQueue(handle);
 }
 
 void StandardBufferManager::AddToEvictionQueue(shared_ptr<BlockHandle> &handle) {
 	buffer_pool.AddToEvictionQueue(handle);
 }
 
-void StandardBufferManager::VerifyZeroReaders(shared_ptr<BlockHandle> &handle) {
+void StandardBufferManager::VerifyZeroReaders(BlockLock &lock, shared_ptr<BlockHandle> &handle) {
 #ifdef DUCKDB_DEBUG_DESTROY_BLOCKS
-	auto replacement_buffer = make_uniq<FileBuffer>(Allocator::Get(db), handle->buffer->type,
-	                                                handle->memory_usage - Storage::DEFAULT_BLOCK_HEADER_SIZE);
-	memcpy(replacement_buffer->buffer, handle->buffer->buffer, handle->buffer->size);
-	WriteGarbageIntoBuffer(*handle->buffer);
-	handle->buffer = std::move(replacement_buffer);
+	unique_ptr<FileBuffer> replacement_buffer;
+	auto &allocator = Allocator::Get(db);
+	auto alloc_size = handle->GetMemoryUsage() - Storage::DEFAULT_BLOCK_HEADER_SIZE;
+	auto &buffer = handle->GetBuffer(lock);
+	if (handle->GetBufferType() == FileBufferType::BLOCK) {
+		auto block = reinterpret_cast<Block *>(buffer.get());
+		replacement_buffer = make_uniq<Block>(allocator, block->id, alloc_size);
+	} else {
+		replacement_buffer = make_uniq<FileBuffer>(allocator, buffer->GetBufferType(), alloc_size);
+	}
+	memcpy(replacement_buffer->buffer, buffer->buffer, buffer->size);
+	WriteGarbageIntoBuffer(lock, *handle);
+	buffer = std::move(replacement_buffer);
 #endif
 }
 
 void StandardBufferManager::Unpin(shared_ptr<BlockHandle> &handle) {
 	bool purge = false;
 	{
-		lock_guard<mutex> lock(handle->lock);
-		if (!handle->buffer || handle->buffer->type == FileBufferType::TINY_BUFFER) {
+		auto lock = handle->GetLock();
+		if (!handle->GetBuffer(lock) || handle->GetBufferType() == FileBufferType::TINY_BUFFER) {
 			return;
 		}
-		D_ASSERT(handle->readers > 0);
-		handle->readers--;
-		if (handle->readers == 0) {
-			VerifyZeroReaders(handle);
+		D_ASSERT(handle->Readers() > 0);
+		auto new_readers = handle->DecrementReaders();
+		if (new_readers == 0) {
+			VerifyZeroReaders(lock, handle);
 			if (handle->MustAddToEvictionQueue()) {
 				purge = buffer_pool.AddToEvictionQueue(handle);
 			} else {
-				handle->Unload();
+				handle->Unload(lock);
 			}
 		}
 	}
 
 	// We do not have to keep the handle locked while purging.
 	if (purge) {
-		PurgeQueue(handle->buffer->type);
+		PurgeQueue(*handle);
 	}
 }
 
@@ -458,15 +469,15 @@ void StandardBufferManager::WriteTemporaryBuffer(MemoryTag tag, block_id_t block
 	RequireTemporaryDirectory();
 
 	// Append to a few grouped files.
-	if (buffer.size == GetBlockSize()) {
-		evicted_data_per_tag[uint8_t(tag)] += GetBlockSize();
+	if (buffer.AllocSize() == GetBlockAllocSize()) {
+		evicted_data_per_tag[uint8_t(tag)] += GetBlockAllocSize();
 		temporary_directory.handle->GetTempFile().WriteTemporaryBuffer(block_id, buffer);
 		return;
 	}
 
 	// Get the path to write to.
 	auto path = GetTemporaryPath(block_id);
-	evicted_data_per_tag[uint8_t(tag)] += buffer.size;
+	evicted_data_per_tag[uint8_t(tag)] += buffer.AllocSize();
 
 	// Create the file and write the size followed by the buffer contents.
 	auto &fs = FileSystem::GetFileSystem(db);
@@ -517,7 +528,7 @@ void StandardBufferManager::DeleteTemporaryFile(BlockHandle &block) {
 	}
 	// check if we should delete the file from the shared pool of files, or from the general file system
 	if (temporary_directory.handle->GetTempFile().HasTemporaryBuffer(id)) {
-		evicted_data_per_tag[uint8_t(block.GetMemoryTag())] -= GetBlockSize();
+		evicted_data_per_tag[uint8_t(block.GetMemoryTag())] -= GetBlockAllocSize();
 		temporary_directory.handle->GetTempFile().DeleteTemporaryBuffer(id);
 		return;
 	}

package/src/duckdb/src/storage/statistics/column_statistics.cpp

@@ -44,12 +44,12 @@ void ColumnStatistics::SetDistinct(unique_ptr<DistinctStatistics> distinct) {
 	this->distinct_stats = std::move(distinct);
 }
 
-void ColumnStatistics::UpdateDistinctStatistics(Vector &v, idx_t count) {
+void ColumnStatistics::UpdateDistinctStatistics(Vector &v, idx_t count, Vector &hashes) {
 	if (!distinct_stats) {
 		return;
 	}
-	// We sample for non-integral types to save cost, and because integers are more likely to be join keys
-	distinct_stats->Update(v, count);
+	// we use a sample to update the distinct statistics for performance reasons
+	distinct_stats->UpdateSample(v, count, hashes);
 }
 
 shared_ptr<ColumnStatistics> ColumnStatistics::Copy() const {

package/src/duckdb/src/storage/statistics/distinct_statistics.cpp

@@ -15,7 +15,6 @@ DistinctStatistics::DistinctStatistics(unique_ptr<HyperLogLog> log, idx_t sample
 }
 
 unique_ptr<DistinctStatistics> DistinctStatistics::Copy() const {
-	lock_guard<mutex> guard(lock);
 	return make_uniq<DistinctStatistics>(log->Copy(), sample_count, total_count);
 }
 
@@ -25,26 +24,28 @@ void DistinctStatistics::Merge(const DistinctStatistics &other) {
 	total_count += other.total_count;
 }
 
-void DistinctStatistics::Update(Vector &v, idx_t count, bool sample) {
+void DistinctStatistics::UpdateSample(Vector &new_data, idx_t count, Vector &hashes) {
 	total_count += count;
-	if (sample) {
-		const auto original_count = count;
-		const auto sample_rate = v.GetType().IsIntegral() ? INTEGRAL_SAMPLE_RATE : BASE_SAMPLE_RATE;
-		// Sample up to 'sample_rate' of STANDARD_VECTOR_SIZE of this vector (at least 1)
-		count = MaxValue<idx_t>(LossyNumericCast<idx_t>(sample_rate * static_cast<double>(STANDARD_VECTOR_SIZE)), 1);
-		// But never more than the original count
-		count = MinValue<idx_t>(count, original_count);
-	}
-	sample_count += count;
+	const auto original_count = count;
+	const auto sample_rate = new_data.GetType().IsIntegral() ? INTEGRAL_SAMPLE_RATE : BASE_SAMPLE_RATE;
+	// Sample up to 'sample_rate' of STANDARD_VECTOR_SIZE of this vector (at least 1)
+	count = MaxValue<idx_t>(LossyNumericCast<idx_t>(sample_rate * static_cast<double>(STANDARD_VECTOR_SIZE)), 1);
+	// But never more than the original count
+	count = MinValue<idx_t>(count, original_count);
+
+	UpdateInternal(new_data, count, hashes);
+}
 
-	lock_guard<mutex> guard(lock);
-	Vector hash_vec(LogicalType::HASH, count);
-	VectorOperations::Hash(v, hash_vec, count);
+void DistinctStatistics::Update(Vector &new_data, idx_t count, Vector &hashes) {
+	total_count += count;
+	UpdateInternal(new_data, count, hashes);
+}
 
-	UnifiedVectorFormat vdata;
-	v.ToUnifiedFormat(count, vdata);
+void DistinctStatistics::UpdateInternal(Vector &new_data, idx_t count, Vector &hashes) {
+	sample_count += count;
+	VectorOperations::Hash(new_data, hashes, count);
 
-	log->Update(v, hash_vec, count);
+	log->Update(new_data, hashes, count);
 }
 
 string DistinctStatistics::ToString() const {

package/src/duckdb/src/storage/statistics/numeric_stats.cpp

@@ -143,11 +143,8 @@ bool ConstantValueInRange(T min, T max, T constant) {
 }
 
 template <class T>
-FilterPropagateResult CheckZonemapTemplated(const BaseStatistics &stats, ExpressionType comparison_type,
-                                            const Value &constant_value) {
-	T min_value = NumericStats::GetMinUnsafe<T>(stats);
-	T max_value = NumericStats::GetMaxUnsafe<T>(stats);
-	T constant = constant_value.GetValueUnsafe<T>();
+FilterPropagateResult CheckZonemapTemplated(const BaseStatistics &stats, ExpressionType comparison_type, T min_value,
+                                            T max_value, T constant) {
 	switch (comparison_type) {
 	case ExpressionType::COMPARE_EQUAL:
 		if (ConstantExactRange(min_value, max_value, constant)) {
@@ -214,40 +211,55 @@ FilterPropagateResult CheckZonemapTemplated(const BaseStatistics &stats, Express
 	}
 }
 
-FilterPropagateResult NumericStats::CheckZonemap(const BaseStatistics &stats, ExpressionType comparison_type,
-                                                 const Value &constant) {
-	D_ASSERT(constant.type() == stats.GetType());
-	if (constant.IsNull()) {
-		return FilterPropagateResult::FILTER_ALWAYS_FALSE;
+template <class T>
+FilterPropagateResult CheckZonemapTemplated(const BaseStatistics &stats, ExpressionType comparison_type,
+                                            array_ptr<Value> constants) {
+	T min_value = NumericStats::GetMinUnsafe<T>(stats);
+	T max_value = NumericStats::GetMaxUnsafe<T>(stats);
+	for (auto &constant_value : constants) {
+		D_ASSERT(constant_value.type() == stats.GetType());
+		D_ASSERT(!constant_value.IsNull());
+		T constant = constant_value.GetValueUnsafe<T>();
+		auto prune_result = CheckZonemapTemplated(stats, comparison_type, min_value, max_value, constant);
+		if (prune_result == FilterPropagateResult::NO_PRUNING_POSSIBLE) {
+			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
+		} else if (prune_result == FilterPropagateResult::FILTER_ALWAYS_TRUE) {
+			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
+		}
 	}
+	return FilterPropagateResult::FILTER_ALWAYS_FALSE;
+}
+
+FilterPropagateResult NumericStats::CheckZonemap(const BaseStatistics &stats, ExpressionType comparison_type,
+                                                 array_ptr<Value> constants) {
 	if (!NumericStats::HasMinMax(stats)) {
 		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
 	}
 	switch (stats.GetType().InternalType()) {
 	case PhysicalType::INT8:
-		return CheckZonemapTemplated<int8_t>(stats, comparison_type, constant);
+		return CheckZonemapTemplated<int8_t>(stats, comparison_type, constants);
 	case PhysicalType::INT16:
-		return CheckZonemapTemplated<int16_t>(stats, comparison_type, constant);
+		return CheckZonemapTemplated<int16_t>(stats, comparison_type, constants);
 	case PhysicalType::INT32:
-		return CheckZonemapTemplated<int32_t>(stats, comparison_type, constant);
+		return CheckZonemapTemplated<int32_t>(stats, comparison_type, constants);
 	case PhysicalType::INT64:
-		return CheckZonemapTemplated<int64_t>(stats, comparison_type, constant);
+		return CheckZonemapTemplated<int64_t>(stats, comparison_type, constants);
 	case PhysicalType::UINT8:
-		return CheckZonemapTemplated<uint8_t>(stats, comparison_type, constant);
+		return CheckZonemapTemplated<uint8_t>(stats, comparison_type, constants);
 	case PhysicalType::UINT16:
-		return CheckZonemapTemplated<uint16_t>(stats, comparison_type, constant);
+		return CheckZonemapTemplated<uint16_t>(stats, comparison_type, constants);
 	case PhysicalType::UINT32:
-		return CheckZonemapTemplated<uint32_t>(stats, comparison_type, constant);
+		return CheckZonemapTemplated<uint32_t>(stats, comparison_type, constants);
 	case PhysicalType::UINT64:
-		return CheckZonemapTemplated<uint64_t>(stats, comparison_type, constant);
+		return CheckZonemapTemplated<uint64_t>(stats, comparison_type, constants);
 	case PhysicalType::INT128:
-		return CheckZonemapTemplated<hugeint_t>(stats, comparison_type, constant);
+		return CheckZonemapTemplated<hugeint_t>(stats, comparison_type, constants);
 	case PhysicalType::UINT128:
-		return CheckZonemapTemplated<uhugeint_t>(stats, comparison_type, constant);
+		return CheckZonemapTemplated<uhugeint_t>(stats, comparison_type, constants);
 	case PhysicalType::FLOAT:
-		return CheckZonemapTemplated<float>(stats, comparison_type, constant);
+		return CheckZonemapTemplated<float>(stats, comparison_type, constants);
 	case PhysicalType::DOUBLE:
-		return CheckZonemapTemplated<double>(stats, comparison_type, constant);
+		return CheckZonemapTemplated<double>(stats, comparison_type, constants);
 	default:
 		throw InternalException("Unsupported type for NumericStats::CheckZonemap");
 	}

package/src/duckdb/src/storage/statistics/string_stats.cpp

@@ -184,10 +184,21 @@ void StringStats::Merge(BaseStatistics &stats, const BaseStatistics &other) {
 }
 
 FilterPropagateResult StringStats::CheckZonemap(const BaseStatistics &stats, ExpressionType comparison_type,
-                                                const string &constant) {
+                                                array_ptr<Value> constants) {
 	auto &string_data = StringStats::GetDataUnsafe(stats);
-	return CheckZonemap(string_data.min, StringStatsData::MAX_STRING_MINMAX_SIZE, string_data.max,
-	                    StringStatsData::MAX_STRING_MINMAX_SIZE, comparison_type, constant);
+	for (auto &constant_value : constants) {
+		D_ASSERT(constant_value.type() == stats.GetType());
+		D_ASSERT(!constant_value.IsNull());
+		auto &constant = StringValue::Get(constant_value);
+		auto prune_result = CheckZonemap(string_data.min, StringStatsData::MAX_STRING_MINMAX_SIZE, string_data.max,
+		                                 StringStatsData::MAX_STRING_MINMAX_SIZE, comparison_type, constant);
+		if (prune_result == FilterPropagateResult::NO_PRUNING_POSSIBLE) {
+			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
+		} else if (prune_result == FilterPropagateResult::FILTER_ALWAYS_TRUE) {
+			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
+		}
+	}
+	return FilterPropagateResult::FILTER_ALWAYS_FALSE;
 }
 
 FilterPropagateResult StringStats::CheckZonemap(const_data_ptr_t min_data, idx_t min_len, const_data_ptr_t max_data,

package/src/duckdb/src/storage/storage_info.cpp

@@ -19,23 +19,85 @@ struct SerializationVersionInfo {
 
 // These sections are automatically generated by scripts/generate_storage_info.py
 // Do not edit them manually, your changes will be overwritten
-
+// clang-format off
 // START OF STORAGE VERSION INFO
+const uint64_t DEFAULT_STORAGE_VERSION_INFO = 64;
 static const StorageVersionInfo storage_version_info[] = {
-    {"v0.0.4", 1},   {"v0.1.0", 1},  {"v0.1.1", 1},  {"v0.1.2", 1},  {"v0.1.3", 1},   {"v0.1.4", 1},   {"v0.1.5", 1},
-    {"v0.1.6", 1},   {"v0.1.7", 1},  {"v0.1.8", 1},  {"v0.1.9", 1},  {"v0.2.0", 1},   {"v0.2.1", 1},   {"v0.2.2", 4},
-    {"v0.2.3", 6},   {"v0.2.4", 11}, {"v0.2.5", 13}, {"v0.2.6", 15}, {"v0.2.7", 17},  {"v0.2.8", 18},  {"v0.2.9", 21},
-    {"v0.3.0", 25},  {"v0.3.1", 27}, {"v0.3.2", 31}, {"v0.3.3", 33}, {"v0.3.4", 33},  {"v0.3.5", 33},  {"v0.4.0", 33},
-    {"v0.5.0", 38},  {"v0.5.1", 38}, {"v0.6.0", 39}, {"v0.6.1", 39}, {"v0.7.0", 43},  {"v0.7.1", 43},  {"v0.8.0", 51},
-    {"v0.8.1", 51},  {"v0.9.0", 64}, {"v0.9.1", 64}, {"v0.9.2", 64}, {"v0.10.0", 64}, {"v0.10.1", 64}, {"v0.10.2", 64},
-    {"v0.10.3", 64}, {"v1.0.0", 64}, {"v1.1.0", 64}, {"v1.1.1", 64}, {"v1.1.2", 64},  {"v1.1.3", 64},  {nullptr, 0}};
+	{"v0.0.4", 1},
+	{"v0.1.0", 1},
+	{"v0.1.1", 1},
+	{"v0.1.2", 1},
+	{"v0.1.3", 1},
+	{"v0.1.4", 1},
+	{"v0.1.5", 1},
+	{"v0.1.6", 1},
+	{"v0.1.7", 1},
+	{"v0.1.8", 1},
+	{"v0.1.9", 1},
+	{"v0.2.0", 1},
+	{"v0.2.1", 1},
+	{"v0.2.2", 4},
+	{"v0.2.3", 6},
+	{"v0.2.4", 11},
+	{"v0.2.5", 13},
+	{"v0.2.6", 15},
+	{"v0.2.7", 17},
+	{"v0.2.8", 18},
+	{"v0.2.9", 21},
+	{"v0.3.0", 25},
+	{"v0.3.1", 27},
+	{"v0.3.2", 31},
+	{"v0.3.3", 33},
+	{"v0.3.4", 33},
+	{"v0.3.5", 33},
+	{"v0.4.0", 33},
+	{"v0.5.0", 38},
+	{"v0.5.1", 38},
+	{"v0.6.0", 39},
+	{"v0.6.1", 39},
+	{"v0.7.0", 43},
+	{"v0.7.1", 43},
+	{"v0.8.0", 51},
+	{"v0.8.1", 51},
+	{"v0.9.0", 64},
+	{"v0.9.1", 64},
+	{"v0.9.2", 64},
+	{"v0.10.0", 64},
+	{"v0.10.1", 64},
+	{"v0.10.2", 64},
+	{"v0.10.3", 64},
+	{"v1.0.0", 64},
+	{"v1.1.0", 64},
+	{"v1.1.1", 64},
+	{"v1.1.2", 64},
+	{"v1.1.3", 64},
+	{nullptr, 0}
+};
 // END OF STORAGE VERSION INFO
+static_assert(DEFAULT_STORAGE_VERSION_INFO == VERSION_NUMBER, "Check on VERSION_INFO");
 
 // START OF SERIALIZATION VERSION INFO
+const uint64_t LATEST_SERIALIZATION_VERSION_INFO = 4;
+const uint64_t DEFAULT_SERIALIZATION_VERSION_INFO = 1;
 static const SerializationVersionInfo serialization_version_info[] = {
-    {"v0.10.0", 1}, {"v0.10.1", 1}, {"v0.10.2", 1}, {"v0.10.3", 2}, {"v1.0.0", 2}, {"v1.1.0", 3},
-    {"v1.1.1", 3},  {"v1.1.2", 3},  {"v1.1.3", 3},  {"latest", 3},  {nullptr, 0}};
+	{"v0.10.0", 1},
+	{"v0.10.1", 1},
+	{"v0.10.2", 1},
+	{"v0.10.3", 2},
+	{"v1.0.0", 2},
+	{"v1.1.0", 3},
+	{"v1.1.1", 3},
+	{"v1.1.2", 3},
+	{"v1.1.3", 3},
+	{"v1.2.0", 4},
+	{"latest", 4},
+	{nullptr, 0}
+};
 // END OF SERIALIZATION VERSION INFO
+// clang-format on
+
+static_assert(DEFAULT_SERIALIZATION_VERSION_INFO <= LATEST_SERIALIZATION_VERSION_INFO,
+              "Check on SERIALIZATION_VERSION_INFO");
 
 optional_idx GetStorageVersion(const char *version_string) {
 	for (idx_t i = 0; storage_version_info[i].version_name; i++) {