duckdb 1.0.1-dev21.0 → 1.0.1-dev27.0

package/src/duckdb/src/common/types/bit.cpp

@@ -9,7 +9,7 @@ namespace duckdb {
 
 // **** helper functions ****
 static char ComputePadding(idx_t len) {
-	return (8 - (len % 8)) % 8;
+	return UnsafeNumericCast<char>((8 - (len % 8)) % 8);
 }
 
 idx_t Bit::ComputeBitstringLen(idx_t len) {
@@ -89,7 +89,7 @@ void Bit::ToString(string_t bits, char *output) {
 
 string Bit::ToString(string_t str) {
 	auto len = BitLength(str);
-	auto buffer = make_unsafe_uniq_array<char>(len);
+	auto buffer = make_unsafe_uniq_array_uninitialized<char>(len);
 	ToString(str, buffer.get());
 	return string(buffer.get(), len);
 }
@@ -150,7 +150,7 @@ void Bit::ToBit(string_t str, string_t &output_str) {
 
 string Bit::ToBit(string_t str) {
 	auto bit_len = GetBitSize(str);
-	auto buffer = make_unsafe_uniq_array<char>(bit_len);
+	auto buffer = make_unsafe_uniq_array_uninitialized<char>(bit_len);
 	string_t output_str(buffer.get(), UnsafeNumericCast<uint32_t>(bit_len));
 	Bit::ToBit(str, output_str);
 	return output_str.GetString();
@@ -166,7 +166,7 @@ void Bit::BlobToBit(string_t blob, string_t &output_str) {
 }
 
 string Bit::BlobToBit(string_t blob) {
-	auto buffer = make_unsafe_uniq_array<char>(blob.GetSize() + 1);
+	auto buffer = make_unsafe_uniq_array_uninitialized<char>(blob.GetSize() + 1);
 	string_t output_str(buffer.get(), UnsafeNumericCast<uint32_t>(blob.GetSize() + 1));
 	Bit::BlobToBit(blob, output_str);
 	return output_str.GetString();
@@ -192,7 +192,7 @@ void Bit::BitToBlob(string_t bit, string_t &output_blob) {
 string Bit::BitToBlob(string_t bit) {
 	D_ASSERT(bit.GetSize() > 1);
 
-	auto buffer = make_unsafe_uniq_array<char>(bit.GetSize() - 1);
+	auto buffer = make_unsafe_uniq_array_uninitialized<char>(bit.GetSize() - 1);
 	string_t output_str(buffer.get(), UnsafeNumericCast<uint32_t>(bit.GetSize() - 1));
 	Bit::BitToBlob(bit, output_str);
 	return output_str.GetString();
@@ -281,7 +281,7 @@ idx_t Bit::GetBitInternal(string_t bit_string, idx_t n) {
 	const char *buf = bit_string.GetData();
 	auto idx = Bit::GetBitIndex(n);
 	D_ASSERT(idx < bit_string.GetSize());
-	char byte = buf[idx] >> (7 - (n % 8));
+	auto byte = buf[idx] >> (7 - (n % 8));
 	return (byte & 1 ? 1 : 0);
 }
 
@@ -291,7 +291,7 @@ void Bit::SetBit(string_t &bit_string, idx_t n, idx_t new_value) {
 }
 
 void Bit::SetBitInternal(string_t &bit_string, idx_t n, idx_t new_value) {
-	auto buf = bit_string.GetDataWriteable();
+	uint8_t *buf = reinterpret_cast<uint8_t *>(bit_string.GetDataWriteable());
 
 	auto idx = Bit::GetBitIndex(n);
 	D_ASSERT(idx < bit_string.GetSize());
@@ -306,8 +306,9 @@ void Bit::SetBitInternal(string_t &bit_string, idx_t n, idx_t new_value) {
 
 // **** BITWISE operators ****
 void Bit::RightShift(const string_t &bit_string, const idx_t &shift, string_t &result) {
-	char *res_buf = result.GetDataWriteable();
-	const char *buf = bit_string.GetData();
+	uint8_t *res_buf = reinterpret_cast<uint8_t *>(result.GetDataWriteable());
+	const uint8_t *buf = reinterpret_cast<const uint8_t *>(bit_string.GetData());
+
 	res_buf[0] = buf[0];
 	for (idx_t i = 0; i < Bit::BitLength(result); i++) {
 		if (i < shift) {
@@ -321,8 +322,9 @@ void Bit::RightShift(const string_t &bit_string, const idx_t &shift, string_t &r
 }
 
 void Bit::LeftShift(const string_t &bit_string, const idx_t &shift, string_t &result) {
-	char *res_buf = result.GetDataWriteable();
-	const char *buf = bit_string.GetData();
+	uint8_t *res_buf = reinterpret_cast<uint8_t *>(result.GetDataWriteable());
+	const uint8_t *buf = reinterpret_cast<const uint8_t *>(bit_string.GetData());
+
 	res_buf[0] = buf[0];
 	for (idx_t i = 0; i < Bit::BitLength(bit_string); i++) {
 		if (i < (Bit::BitLength(bit_string) - shift)) {
@@ -340,9 +342,9 @@ void Bit::BitwiseAnd(const string_t &rhs, const string_t &lhs, string_t &result)
 		throw InvalidInputException("Cannot AND bit strings of different sizes");
 	}
 
-	char *buf = result.GetDataWriteable();
-	const char *r_buf = rhs.GetData();
-	const char *l_buf = lhs.GetData();
+	uint8_t *buf = reinterpret_cast<uint8_t *>(result.GetDataWriteable());
+	const uint8_t *r_buf = reinterpret_cast<const uint8_t *>(rhs.GetData());
+	const uint8_t *l_buf = reinterpret_cast<const uint8_t *>(lhs.GetData());
 
 	buf[0] = l_buf[0];
 	for (idx_t i = 1; i < lhs.GetSize(); i++) {
@@ -356,9 +358,9 @@ void Bit::BitwiseOr(const string_t &rhs, const string_t &lhs, string_t &result)
 		throw InvalidInputException("Cannot OR bit strings of different sizes");
 	}
 
-	char *buf = result.GetDataWriteable();
-	const char *r_buf = rhs.GetData();
-	const char *l_buf = lhs.GetData();
+	uint8_t *buf = reinterpret_cast<uint8_t *>(result.GetDataWriteable());
+	const uint8_t *r_buf = reinterpret_cast<const uint8_t *>(rhs.GetData());
+	const uint8_t *l_buf = reinterpret_cast<const uint8_t *>(lhs.GetData());
 
 	buf[0] = l_buf[0];
 	for (idx_t i = 1; i < lhs.GetSize(); i++) {
@@ -372,9 +374,9 @@ void Bit::BitwiseXor(const string_t &rhs, const string_t &lhs, string_t &result)
 		throw InvalidInputException("Cannot XOR bit strings of different sizes");
 	}
 
-	char *buf = result.GetDataWriteable();
-	const char *r_buf = rhs.GetData();
-	const char *l_buf = lhs.GetData();
+	uint8_t *buf = reinterpret_cast<uint8_t *>(result.GetDataWriteable());
+	const uint8_t *r_buf = reinterpret_cast<const uint8_t *>(rhs.GetData());
+	const uint8_t *l_buf = reinterpret_cast<const uint8_t *>(lhs.GetData());
 
 	buf[0] = l_buf[0];
 	for (idx_t i = 1; i < lhs.GetSize(); i++) {
@@ -384,8 +386,8 @@ void Bit::BitwiseXor(const string_t &rhs, const string_t &lhs, string_t &result)
 }
 
 void Bit::BitwiseNot(const string_t &input, string_t &result) {
-	char *result_buf = result.GetDataWriteable();
-	const char *buf = input.GetData();
+	uint8_t *result_buf = reinterpret_cast<uint8_t *>(result.GetDataWriteable());
+	const uint8_t *buf = reinterpret_cast<const uint8_t *>(input.GetData());
 
 	result_buf[0] = buf[0];
 	for (idx_t i = 1; i < input.GetSize(); i++) {

package/src/duckdb/src/common/types/blob.cpp

@@ -1,10 +1,11 @@
-#include "duckdb/common/types/string_type.hpp"
 #include "duckdb/common/types/blob.hpp"
+
 #include "duckdb/common/assert.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/numeric_utils.hpp"
-#include "duckdb/common/string_util.hpp"
 #include "duckdb/common/operator/cast_operators.hpp"
+#include "duckdb/common/string_util.hpp"
+#include "duckdb/common/types/string_type.hpp"
 
 namespace duckdb {
 
@@ -65,7 +66,7 @@ void Blob::ToString(string_t blob, char *output) {
 
 string Blob::ToString(string_t blob) {
 	auto str_len = GetStringSize(blob);
-	auto buffer = make_unsafe_uniq_array<char>(str_len);
+	auto buffer = make_unsafe_uniq_array_uninitialized<char>(str_len);
 	Blob::ToString(blob, buffer.get());
 	return string(buffer.get(), str_len);
 }
@@ -77,15 +78,16 @@ bool Blob::TryGetBlobSize(string_t str, idx_t &str_len, CastParameters &paramete
 	for (idx_t i = 0; i < len; i++) {
 		if (data[i] == '\\') {
 			if (i + 3 >= len) {
-				string error = "Invalid hex escape code encountered in string -> blob conversion: "
-				               "unterminated escape code at end of blob";
+				string error = StringUtil::Format("Invalid hex escape code encountered in string -> blob conversion of "
+				                                  "string \"%s\": unterminated escape code at end of blob",
+				                                  str.GetString());
 				HandleCastError::AssignError(error, parameters);
 				return false;
 			}
 			if (data[i + 1] != 'x' || Blob::HEX_MAP[data[i + 2]] < 0 || Blob::HEX_MAP[data[i + 3]] < 0) {
-				string error =
-				    StringUtil::Format("Invalid hex escape code encountered in string -> blob conversion: %s",
-				                       string(const_char_ptr_cast(data) + i, 4));
+				string error = StringUtil::Format(
+				    "Invalid hex escape code encountered in string -> blob conversion of string \"%s\": %s",
+				    str.GetString(), string(const_char_ptr_cast(data) + i, 4));
 				HandleCastError::AssignError(error, parameters);
 				return false;
 			}
@@ -94,8 +96,10 @@ bool Blob::TryGetBlobSize(string_t str, idx_t &str_len, CastParameters &paramete
 		} else if (data[i] <= 127) {
 			str_len++;
 		} else {
-			string error = "Invalid byte encountered in STRING -> BLOB conversion. All non-ascii characters "
-			               "must be escaped with hex codes (e.g. \\xAA)";
+			string error = StringUtil::Format(
+			    "Invalid byte encountered in STRING -> BLOB conversion of string \"%s\". All non-ascii characters "
+			    "must be escaped with hex codes (e.g. \\xAA)",
+			    str.GetString());
 			HandleCastError::AssignError(error, parameters);
 			return false;
 		}
@@ -147,7 +151,7 @@ string Blob::ToBlob(string_t str) {
 
 string Blob::ToBlob(string_t str, CastParameters &parameters) {
 	auto blob_len = GetBlobSize(str, parameters);
-	auto buffer = make_unsafe_uniq_array<char>(blob_len);
+	auto buffer = make_unsafe_uniq_array_uninitialized<char>(blob_len);
 	Blob::ToBlob(str, data_ptr_cast(buffer.get()));
 	return string(buffer.get(), blob_len);
 }

package/src/duckdb/src/common/types/column/column_data_allocator.cpp

@@ -61,13 +61,13 @@ BufferHandle ColumnDataAllocator::Pin(uint32_t block_id) {
 
 BufferHandle ColumnDataAllocator::AllocateBlock(idx_t size) {
 	D_ASSERT(type == ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR || type == ColumnDataAllocatorType::HYBRID);
-	auto block_size = MaxValue<idx_t>(size, Storage::BLOCK_SIZE);
+	auto max_size = MaxValue<idx_t>(size, GetBufferManager().GetBlockSize());
 	BlockMetaData data;
 	data.size = 0;
-	data.capacity = NumericCast<uint32_t>(block_size);
-	auto pin = alloc.buffer_manager->Allocate(MemoryTag::COLUMN_DATA, block_size, false, &data.handle);
+	data.capacity = NumericCast<uint32_t>(max_size);
+	auto pin = alloc.buffer_manager->Allocate(MemoryTag::COLUMN_DATA, max_size, false, &data.handle);
 	blocks.push_back(std::move(data));
-	allocated_size += block_size;
+	allocated_size += max_size;
 	return pin;
 }
 
@@ -75,7 +75,7 @@ void ColumnDataAllocator::AllocateEmptyBlock(idx_t size) {
 	auto allocation_amount = MaxValue<idx_t>(NextPowerOfTwo(size), 4096);
 	if (!blocks.empty()) {
 		idx_t last_capacity = blocks.back().capacity;
-		auto next_capacity = MinValue<idx_t>(last_capacity * 2, last_capacity + Storage::BLOCK_SIZE);
+		auto next_capacity = MinValue<idx_t>(last_capacity * 2, last_capacity + Storage::DEFAULT_BLOCK_SIZE);
 		allocation_amount = MaxValue<idx_t>(next_capacity, allocation_amount);
 	}
 	D_ASSERT(type == ColumnDataAllocatorType::IN_MEMORY_ALLOCATOR);
@@ -220,13 +220,22 @@ void ColumnDataAllocator::UnswizzlePointers(ChunkManagementState &state, Vector
 	}
 }
 
-void ColumnDataAllocator::DeleteBlock(uint32_t block_id) {
-	blocks[block_id].handle->SetCanDestroy(true);
+void ColumnDataAllocator::SetDestroyBufferUponUnpin(uint32_t block_id) {
+	blocks[block_id].handle->SetDestroyBufferUpon(DestroyBufferUpon::UNPIN);
 }
 
 Allocator &ColumnDataAllocator::GetAllocator() {
-	return type == ColumnDataAllocatorType::IN_MEMORY_ALLOCATOR ? *alloc.allocator
-	                                                            : alloc.buffer_manager->GetBufferAllocator();
+	if (type == ColumnDataAllocatorType::IN_MEMORY_ALLOCATOR) {
+		return *alloc.allocator;
+	}
+	return alloc.buffer_manager->GetBufferAllocator();
+}
+
+BufferManager &ColumnDataAllocator::GetBufferManager() {
+	if (type == ColumnDataAllocatorType::IN_MEMORY_ALLOCATOR) {
+		throw InternalException("cannot obtain the buffer manager for in memory allocations");
+	}
+	return *alloc.buffer_manager;
 }
 
 void ColumnDataAllocator::InitializeChunkState(ChunkManagementState &state, ChunkMetaData &chunk) {

package/src/duckdb/src/common/types/column/column_data_collection.cpp

@@ -467,6 +467,7 @@ void ColumnDataCopy<string_t>(ColumnDataMetaData &meta_data, const UnifiedVector
 
 	auto current_index = meta_data.vector_data_index;
 	idx_t remaining = copy_count;
+	auto block_size = meta_data.segment.allocator->GetBufferManager().GetBlockSize();
 	while (remaining > 0) {
 		// how many values fit in the current string vector
 		idx_t vector_remaining =
@@ -485,19 +486,18 @@ void ColumnDataCopy<string_t>(ColumnDataMetaData &meta_data, const UnifiedVector
 			if (entry.IsInlined()) {
 				continue;
 			}
-			if (heap_size + entry.GetSize() > Storage::BLOCK_SIZE) {
+			if (heap_size + entry.GetSize() > block_size) {
 				break;
 			}
 			heap_size += entry.GetSize();
 		}
 
 		if (vector_remaining != 0 && append_count == 0) {
-			// single string is longer than Storage::BLOCK_SIZE
-			// we allocate one block at a time for long strings
+			// The string exceeds Storage::DEFAULT_BLOCK_SIZE, so we allocate one block at a time for long strings.
 			auto source_idx = source_data.sel->get_index(offset + append_count);
 			D_ASSERT(source_data.validity.RowIsValid(source_idx));
 			D_ASSERT(!source_entries[source_idx].IsInlined());
-			D_ASSERT(source_entries[source_idx].GetSize() > Storage::BLOCK_SIZE);
+			D_ASSERT(source_entries[source_idx].GetSize() > block_size);
 			heap_size += source_entries[source_idx].GetSize();
 			append_count++;
 		}

package/src/duckdb/src/common/types/column/column_data_collection_segment.cpp

@@ -24,9 +24,9 @@ VectorDataIndex ColumnDataCollectionSegment::AllocateVectorInternal(const Logica
 	meta_data.count = 0;
 
 	auto internal_type = type.InternalType();
-	auto type_size = ((internal_type == PhysicalType::STRUCT) || (internal_type == PhysicalType::ARRAY))
-	                     ? 0
-	                     : GetTypeIdSize(internal_type);
+	auto struct_or_array = internal_type == PhysicalType::STRUCT || internal_type == PhysicalType::ARRAY;
+	auto type_size = struct_or_array ? 0 : GetTypeIdSize(internal_type);
+
 	allocator->AllocateData(GetDataSize(type_size) + ValidityMask::STANDARD_MASK_SIZE, meta_data.block_id,
 	                        meta_data.offset, chunk_state);
 	if (allocator->GetType() == ColumnDataAllocatorType::BUFFER_MANAGER_ALLOCATOR ||
@@ -77,7 +77,6 @@ VectorDataIndex ColumnDataCollectionSegment::AllocateStringHeap(idx_t size, Chun
 
 	VectorMetaData meta_data;
 	meta_data.count = 0;
-
 	allocator->AllocateData(AlignValue(size), meta_data.block_id, meta_data.offset, &append_state.current_chunk_state);
 	chunk_meta.block_ids.insert(meta_data.block_id);
 

package/src/duckdb/src/common/types/column/column_data_consumer.cpp

@@ -88,13 +88,13 @@ void ColumnDataConsumer::ConsumeChunks(idx_t delete_index_start, idx_t delete_in
 		if (prev_allocator != curr_allocator) {
 			// Moved to the next allocator, delete all remaining blocks in the previous one
 			for (uint32_t block_id = prev_min_block_id; block_id < prev_allocator->BlockCount(); block_id++) {
-				prev_allocator->DeleteBlock(block_id);
+				prev_allocator->SetDestroyBufferUponUnpin(block_id);
 			}
 			continue;
 		}
 		// Same allocator, see if we can delete blocks
 		for (uint32_t block_id = prev_min_block_id; block_id < curr_min_block_id; block_id++) {
-			prev_allocator->DeleteBlock(block_id);
+			prev_allocator->SetDestroyBufferUponUnpin(block_id);
 		}
 	}
 }

package/src/duckdb/src/common/types/column/partitioned_column_data.cpp

@@ -34,6 +34,10 @@ void PartitionedColumnData::InitializeAppendState(PartitionedColumnDataAppendSta
 	InitializeAppendStateInternal(state);
 }
 
+bool PartitionedColumnData::UseFixedSizeMap() const {
+	return MaxPartitionIndex() < PartitionedTupleDataAppendState::MAP_THRESHOLD;
+}
+
 unique_ptr<DataChunk> PartitionedColumnData::CreatePartitionBuffer() const {
 	auto result = make_uniq<DataChunk>();
 	result->Initialize(BufferAllocator::Get(context), types, BufferSize());
@@ -44,59 +48,104 @@ void PartitionedColumnData::Append(PartitionedColumnDataAppendState &state, Data
 	// Compute partition indices and store them in state.partition_indices
 	ComputePartitionIndices(state, input);
 
-	// Compute the counts per partition
-	const auto count = input.size();
-	const auto partition_indices = FlatVector::GetData<idx_t>(state.partition_indices);
-	auto &partition_entries = state.partition_entries;
+	// Build the selection vector for the partitions
+	BuildPartitionSel(state, input.size());
+
+	// Early out: check if everything belongs to a single partition
+	const auto partition_index = state.GetPartitionIndexIfSinglePartition(UseFixedSizeMap());
+	if (partition_index.IsValid()) {
+		auto &partition = *partitions[partition_index.GetIndex()];
+		auto &partition_append_state = *state.partition_append_states[partition_index.GetIndex()];
+		partition.Append(partition_append_state, input);
+		return;
+	}
+
+	if (UseFixedSizeMap()) {
+		AppendInternal<true>(state, input);
+	} else {
+		AppendInternal<false>(state, input);
+	}
+}
+
+void PartitionedColumnData::BuildPartitionSel(PartitionedColumnDataAppendState &state, const idx_t append_count) const {
+	if (UseFixedSizeMap()) {
+		BuildPartitionSel<true>(state, append_count);
+	} else {
+		BuildPartitionSel<false>(state, append_count);
+	}
+}
+
+template <class MAP_TYPE>
+MAP_TYPE &PartitionedColumnDataGetMap(PartitionedColumnDataAppendState &) {
+	throw InternalException("Unknown MAP_TYPE for PartitionedTupleDataGetMap");
+}
+
+template <>
+fixed_size_map_t<list_entry_t> &PartitionedColumnDataGetMap(PartitionedColumnDataAppendState &state) {
+	return state.fixed_partition_entries;
+}
+
+template <>
+perfect_map_t<list_entry_t> &PartitionedColumnDataGetMap(PartitionedColumnDataAppendState &state) {
+	return state.partition_entries;
+}
+
+template <bool fixed>
+void PartitionedColumnData::BuildPartitionSel(PartitionedColumnDataAppendState &state, const idx_t append_count) {
+	using GETTER = TemplatedMapGetter<list_entry_t, fixed>;
+	auto &partition_entries = state.GetMap<fixed>();
 	partition_entries.clear();
+	const auto partition_indices = FlatVector::GetData<idx_t>(state.partition_indices);
 	switch (state.partition_indices.GetVectorType()) {
 	case VectorType::FLAT_VECTOR:
-		for (idx_t i = 0; i < count; i++) {
+		for (idx_t i = 0; i < append_count; i++) {
 			const auto &partition_index = partition_indices[i];
 			auto partition_entry = partition_entries.find(partition_index);
 			if (partition_entry == partition_entries.end()) {
 				partition_entries[partition_index] = list_entry_t(0, 1);
 			} else {
-				partition_entry->second.length++;
+				GETTER::GetValue(partition_entry).length++;
 			}
 		}
 		break;
 	case VectorType::CONSTANT_VECTOR:
-		partition_entries[partition_indices[0]] = list_entry_t(0, count);
+		partition_entries[partition_indices[0]] = list_entry_t(0, append_count);
 		break;
 	default:
-		throw InternalException("Unexpected VectorType in PartitionedColumnData::Append");
+		throw InternalException("Unexpected VectorType in PartitionedTupleData::Append");
 	}
 
 	// Early out: check if everything belongs to a single partition
 	if (partition_entries.size() == 1) {
-		const auto &partition_index = partition_entries.begin()->first;
-		auto &partition = *partitions[partition_index];
-		auto &partition_append_state = *state.partition_append_states[partition_index];
-		partition.Append(partition_append_state, input);
 		return;
 	}
 
 	// Compute offsets from the counts
 	idx_t offset = 0;
-	for (auto &pc : partition_entries) {
-		auto &partition_entry = pc.second;
+	for (auto it = partition_entries.begin(); it != partition_entries.end(); ++it) {
+		auto &partition_entry = GETTER::GetValue(it);
 		partition_entry.offset = offset;
 		offset += partition_entry.length;
 	}
 
 	// Now initialize a single selection vector that acts as a selection vector for every partition
-	auto &all_partitions_sel = state.partition_sel;
-	for (idx_t i = 0; i < count; i++) {
+	auto &partition_sel = state.partition_sel;
+	for (idx_t i = 0; i < append_count; i++) {
 		const auto &partition_index = partition_indices[i];
 		auto &partition_offset = partition_entries[partition_index].offset;
-		all_partitions_sel[partition_offset++] = NumericCast<sel_t>(i);
+		partition_sel[partition_offset++] = UnsafeNumericCast<sel_t>(i);
 	}
+}
+
+template <bool fixed>
+void PartitionedColumnData::AppendInternal(PartitionedColumnDataAppendState &state, DataChunk &input) {
+	using GETTER = TemplatedMapGetter<list_entry_t, fixed>;
+	const auto &partition_entries = state.GetMap<fixed>();
 
 	// Loop through the partitions to append the new data to the partition buffers, and flush the buffers if necessary
 	SelectionVector partition_sel;
-	for (auto &pc : partition_entries) {
-		const auto &partition_index = pc.first;
+	for (auto it = partition_entries.begin(); it != partition_entries.end(); ++it) {
+		const auto &partition_index = GETTER::GetKey(it);
 
 		// Partition, buffer, and append state for this partition index
 		auto &partition = *partitions[partition_index];
@@ -104,12 +153,12 @@ void PartitionedColumnData::Append(PartitionedColumnDataAppendState &state, Data
 		auto &partition_append_state = *state.partition_append_states[partition_index];
 
 		// Length and offset into the selection vector for this chunk, for this partition
-		const auto &partition_entry = pc.second;
+		const auto &partition_entry = GETTER::GetValue(it);
 		const auto &partition_length = partition_entry.length;
 		const auto partition_offset = partition_entry.offset - partition_length;
 
 		// Create a selection vector for this partition using the offset into the single selection vector
-		partition_sel.Initialize(all_partitions_sel.data() + partition_offset);
+		partition_sel.Initialize(state.partition_sel.data() + partition_offset);
 
 		if (partition_length >= HalfBufferSize()) {
 			// Slice the input chunk using the selection vector

package/src/duckdb/src/common/types/data_chunk.cpp

@@ -37,6 +37,15 @@ void DataChunk::Initialize(ClientContext &context, const vector<LogicalType> &ty
 	Initialize(Allocator::Get(context), types, capacity_p);
 }
 
+idx_t DataChunk::GetAllocationSize() const {
+	idx_t total_size = 0;
+	auto cardinality = size();
+	for (auto &vec : data) {
+		total_size += vec.GetAllocationSize(cardinality);
+	}
+	return total_size;
+}
+
 void DataChunk::Initialize(Allocator &allocator, vector<LogicalType>::const_iterator begin,
                            vector<LogicalType>::const_iterator end, idx_t capacity_p) {
 	D_ASSERT(data.empty());                   // can only be initialized once
@@ -134,7 +143,7 @@ void DataChunk::Copy(DataChunk &other, idx_t offset) const {
 void DataChunk::Copy(DataChunk &other, const SelectionVector &sel, const idx_t source_count, const idx_t offset) const {
 	D_ASSERT(ColumnCount() == other.ColumnCount());
 	D_ASSERT(other.size() == 0);
-	D_ASSERT((offset + source_count) <= size());
+	D_ASSERT(source_count <= size());
 
 	for (idx_t i = 0; i < ColumnCount(); i++) {
 		D_ASSERT(other.data[i].GetVectorType() == VectorType::FLAT_VECTOR);

package/src/duckdb/src/common/types/date.cpp

@@ -250,11 +250,16 @@ bool Date::TryConvertDate(const char *buf, idx_t len, idx_t &pos, date_t &result
 		return pos == len;
 	}
 	// first parse the year
+	idx_t year_length = 0;
 	for (; pos < len && StringUtil::CharacterIsDigit(buf[pos]); pos++) {
 		if (year >= 100000000) {
 			return false;
 		}
 		year = (buf[pos] - '0') + year * 10;
+		year_length++;
+	}
+	if (year_length < 2 && strict) {
+		return false;
 	}
 	if (yearneg) {
 		year = -year;
@@ -362,7 +367,7 @@ string Date::ToString(date_t date) {
 	Date::Convert(date, date_units[0], date_units[1], date_units[2]);
 
 	auto length = DateToStringCast::Length(date_units, year_length, add_bc);
-	auto buffer = make_unsafe_uniq_array<char>(length);
+	auto buffer = make_unsafe_uniq_array_uninitialized<char>(length);
 	DateToStringCast::Format(buffer.get(), date_units, year_length, add_bc);
 	return string(buffer.get(), length);
 }
@@ -450,22 +455,6 @@ int64_t Date::EpochMilliseconds(date_t date) {
 	return result;
 }
 
-int32_t Date::ExtractYear(date_t d, int32_t *last_year) {
-	auto n = d.days;
-	// cached look up: check if year of this date is the same as the last one we looked up
-	// note that this only works for years in the range [1970, 2370]
-	if (n >= Date::CUMULATIVE_YEAR_DAYS[*last_year] && n < Date::CUMULATIVE_YEAR_DAYS[*last_year + 1]) {
-		return Date::EPOCH_YEAR + *last_year;
-	}
-	int32_t year;
-	Date::ExtractYearOffset(n, year, *last_year);
-	return year;
-}
-
-int32_t Date::ExtractYear(timestamp_t ts, int32_t *last_year) {
-	return Date::ExtractYear(Timestamp::GetDate(ts), last_year);
-}
-
 int32_t Date::ExtractYear(date_t d) {
 	int32_t year, year_offset;
 	Date::ExtractYearOffset(d.days, year, year_offset);
@@ -515,10 +504,10 @@ int32_t Date::ExtractISODayOfTheWeek(date_t date) {
 	// 7  = 4
 	if (date.days < 0) {
 		// negative date: start off at 4 and cycle downwards
-		return (7 - ((-int64_t(date.days) + 3) % 7));
+		return UnsafeNumericCast<int32_t>((7 - ((-int64_t(date.days) + 3) % 7)));
 	} else {
 		// positive date: start off at 4 and cycle upwards
-		return ((int64_t(date.days) + 3) % 7) + 1;
+		return UnsafeNumericCast<int32_t>(((int64_t(date.days) + 3) % 7) + 1);
 	}
 }
 

package/src/duckdb/src/common/types/decimal.cpp

@@ -1,4 +1,5 @@
 #include "duckdb/common/types/decimal.hpp"
+
 #include "duckdb/common/types/cast_helpers.hpp"
 
 namespace duckdb {
@@ -6,7 +7,7 @@ namespace duckdb {
 template <class SIGNED>
 string TemplatedDecimalToString(SIGNED value, uint8_t width, uint8_t scale) {
 	auto len = DecimalToString::DecimalLength<SIGNED>(value, width, scale);
-	auto data = make_unsafe_uniq_array<char>(UnsafeNumericCast<size_t>(len + 1));
+	auto data = make_unsafe_uniq_array_uninitialized<char>(UnsafeNumericCast<size_t>(len + 1));
 	DecimalToString::FormatDecimal<SIGNED>(value, width, scale, data.get(), UnsafeNumericCast<idx_t>(len));
 	return string(data.get(), UnsafeNumericCast<uint32_t>(len));
 }
@@ -25,7 +26,7 @@ string Decimal::ToString(int64_t value, uint8_t width, uint8_t scale) {
 
 string Decimal::ToString(hugeint_t value, uint8_t width, uint8_t scale) {
 	auto len = DecimalToString::DecimalLength(value, width, scale);
-	auto data = make_unsafe_uniq_array<char>(UnsafeNumericCast<size_t>(len + 1));
+	auto data = make_unsafe_uniq_array_uninitialized<char>(UnsafeNumericCast<size_t>(len + 1));
 	DecimalToString::FormatDecimal(value, width, scale, data.get(), UnsafeNumericCast<idx_t>(len));
 	return string(data.get(), UnsafeNumericCast<uint32_t>(len));
 }

package/src/duckdb/src/common/types/hugeint.cpp

@@ -64,7 +64,7 @@ const hugeint_t Hugeint::POWERS_OF_TEN[] {
 
 template <>
 void Hugeint::NegateInPlace<false>(hugeint_t &input) {
-	input.lower = NumericLimits<uint64_t>::Maximum() - input.lower + 1;
+	input.lower = NumericLimits<uint64_t>::Maximum() - input.lower + 1ull;
 	input.upper = -1 - input.upper + (input.lower == 0);
 }
 
@@ -77,6 +77,14 @@ bool Hugeint::TryNegate(hugeint_t input, hugeint_t &result) {
 	return true;
 }
 
+hugeint_t Hugeint::Abs(hugeint_t n) {
+	if (n < 0) {
+		return Hugeint::Negate(n);
+	} else {
+		return n;
+	}
+}
+
 //===--------------------------------------------------------------------===//
 // Divide
 //===--------------------------------------------------------------------===//
@@ -646,7 +654,7 @@ bool CastBigintToFloating(hugeint_t input, REAL_T &result) {
 		result = -REAL_T(NumericLimits<uint64_t>::Maximum() - input.lower) - 1;
 		break;
 	default:
-		result = REAL_T(input.lower) + REAL_T(input.upper) * REAL_T(NumericLimits<uint64_t>::Maximum());
+		result = REAL_T(input.lower) + REAL_T(input.upper) * (REAL_T(NumericLimits<uint64_t>::Maximum()) + 1);
 		break;
 	}
 	return true;
@@ -864,7 +872,7 @@ hugeint_t hugeint_t::operator<<(const hugeint_t &rhs) const {
 	} else {
 		D_ASSERT(shift < 128);
 		result.lower = 0;
-		result.upper = (lower << (shift - 64)) & 0x7FFFFFFFFFFFFFFF;
+		result.upper = UnsafeNumericCast<int64_t>((lower << (shift - 64)) & 0x7FFFFFFFFFFFFFFF);
 	}
 	return result;
 }