duckdb 0.10.1-dev9.0 → 0.10.1

package/src/duckdb/src/common/operator/ub_duckdb_common_operators.cpp

@@ -0,0 +1,4 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/common/operator/cast_operators.cpp>
+#include </Users/carlo/duckdb/src/common/operator/convert_to_string.cpp>
+#include </Users/carlo/duckdb/src/common/operator/string_cast.cpp>

package/src/duckdb/src/common/progress_bar/ub_duckdb_progress_bar.cpp

@@ -0,0 +1,3 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/common/progress_bar/progress_bar.cpp>
+#include </Users/carlo/duckdb/src/common/progress_bar/terminal_progress_bar_display.cpp>

package/src/duckdb/src/common/re2_regex.cpp

@@ -1,3 +1,4 @@
+#include "duckdb/common/numeric_utils.hpp"
 #include "duckdb/common/vector.hpp"
 #include <memory>
 
@@ -25,7 +26,7 @@ bool RegexSearchInternal(const char *input, Match &match, const Regex &r, RE2::A
 	for (auto &group : target_groups) {
 		GroupMatch group_match;
 		group_match.text = group.ToString();
-		group_match.position = group.data() - input;
+		group_match.position = group.data() != nullptr ? duckdb::NumericCast<uint32_t>(group.data() - input) : 0;
 		match.groups.emplace_back(group_match);
 	}
 	return true;

package/src/duckdb/src/common/row_operations/row_heap_scatter.cpp

@@ -245,7 +245,7 @@ static void HeapScatterStringVector(Vector &v, idx_t vcount, const SelectionVect
 			if (vdata.validity.RowIsValid(source_idx)) {
 				auto &string_entry = strings[source_idx];
 				// store string size
-				Store<uint32_t>(string_entry.GetSize(), key_locations[i]);
+				Store<uint32_t>(NumericCast<uint32_t>(string_entry.GetSize()), key_locations[i]);
 				key_locations[i] += sizeof(uint32_t);
 				// store the string
 				memcpy(key_locations[i], string_entry.GetData(), string_entry.GetSize());
@@ -259,7 +259,7 @@ static void HeapScatterStringVector(Vector &v, idx_t vcount, const SelectionVect
 			if (vdata.validity.RowIsValid(source_idx)) {
 				auto &string_entry = strings[source_idx];
 				// store string size
-				Store<uint32_t>(string_entry.GetSize(), key_locations[i]);
+				Store<uint32_t>(NumericCast<uint32_t>(string_entry.GetSize()), key_locations[i]);
 				key_locations[i] += sizeof(uint32_t);
 				// store the string
 				memcpy(key_locations[i], string_entry.GetData(), string_entry.GetSize());

package/src/duckdb/src/common/row_operations/row_matcher.cpp

@@ -177,6 +177,7 @@ static idx_t GenericNestedMatch(Vector &lhs_vector, const TupleDataVectorFormat
 	const auto gather_function = TupleDataCollection::GetGatherFunction(type);
 	gather_function.function(rhs_layout, rhs_row_locations, col_idx, sel, count, key,
 	                         *FlatVector::IncrementalSelectionVector(), nullptr, gather_function.child_functions);
+	Vector::Verify(key, *FlatVector::IncrementalSelectionVector(), count);
 
 	// Densify the input column
 	Vector sliced(lhs_vector, sel, count);

package/src/duckdb/src/common/row_operations/row_scatter.cpp

@@ -82,7 +82,7 @@ static void ScatterStringVector(UnifiedVectorFormat &col, Vector &rows, data_ptr
 			Store<string_t>(string_data[col_idx], row + col_offset);
 		} else {
 			const auto &str = string_data[col_idx];
-			string_t inserted(const_char_ptr_cast(str_locations[i]), str.GetSize());
+			string_t inserted(const_char_ptr_cast(str_locations[i]), UnsafeNumericCast<uint32_t>(str.GetSize()));
 			memcpy(inserted.GetDataWriteable(), str.GetData(), str.GetSize());
 			str_locations[i] += str.GetSize();
 			inserted.Finalize();
@@ -167,7 +167,7 @@ void RowOperations::Scatter(DataChunk &columns, UnifiedVectorFormat col_data[],
 			// Pointer to this row in the heap block
 			Store<data_ptr_t>(data_locations[i], row + heap_pointer_offset);
 			// Row size is stored in the heap in front of each row
-			Store<uint32_t>(entry_sizes[i], data_locations[i]);
+			Store<uint32_t>(NumericCast<uint32_t>(entry_sizes[i]), data_locations[i]);
 			data_locations[i] += sizeof(uint32_t);
 		}
 	}

package/src/duckdb/src/common/row_operations/ub_duckdb_row_operations.cpp

@@ -0,0 +1,9 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/common/row_operations/row_aggregate.cpp>
+#include </Users/carlo/duckdb/src/common/row_operations/row_scatter.cpp>
+#include </Users/carlo/duckdb/src/common/row_operations/row_gather.cpp>
+#include </Users/carlo/duckdb/src/common/row_operations/row_matcher.cpp>
+#include </Users/carlo/duckdb/src/common/row_operations/row_external.cpp>
+#include </Users/carlo/duckdb/src/common/row_operations/row_radix_scatter.cpp>
+#include </Users/carlo/duckdb/src/common/row_operations/row_heap_scatter.cpp>
+#include </Users/carlo/duckdb/src/common/row_operations/row_heap_gather.cpp>

package/src/duckdb/src/common/serializer/binary_serializer.cpp

@@ -150,19 +150,19 @@ void BinarySerializer::WriteValue(double value) {
 }
 
 void BinarySerializer::WriteValue(const string &value) {
-	uint32_t len = value.length();
+	auto len = NumericCast<uint32_t>(value.length());
 	VarIntEncode(len);
 	WriteData(value.c_str(), len);
 }
 
 void BinarySerializer::WriteValue(const string_t value) {
-	uint32_t len = value.GetSize();
+	auto len = NumericCast<uint32_t>(value.GetSize());
 	VarIntEncode(len);
 	WriteData(value.GetDataUnsafe(), len);
 }
 
 void BinarySerializer::WriteValue(const char *value) {
-	uint32_t len = strlen(value);
+	auto len = NumericCast<uint32_t>(strlen(value));
 	VarIntEncode(len);
 	WriteData(value, len);
 }

package/src/duckdb/src/common/serializer/ub_duckdb_common_serializer.cpp

@@ -0,0 +1,7 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/common/serializer/binary_serializer.cpp>
+#include </Users/carlo/duckdb/src/common/serializer/binary_deserializer.cpp>
+#include </Users/carlo/duckdb/src/common/serializer/buffered_file_reader.cpp>
+#include </Users/carlo/duckdb/src/common/serializer/buffered_file_writer.cpp>
+#include </Users/carlo/duckdb/src/common/serializer/memory_stream.cpp>
+#include </Users/carlo/duckdb/src/common/serializer/serializer.cpp>

package/src/duckdb/src/common/sort/partition_state.cpp

@@ -3,7 +3,7 @@
 #include "duckdb/common/types/column/column_data_consumer.hpp"
 #include "duckdb/common/row_operations/row_operations.hpp"
 #include "duckdb/main/config.hpp"
-#include "duckdb/parallel/event.hpp"
+#include "duckdb/parallel/executor_task.hpp"
 
 #include <numeric>
 
@@ -565,7 +565,7 @@ class PartitionMergeTask : public ExecutorTask {
 public:
 	PartitionMergeTask(shared_ptr<Event> event_p, ClientContext &context_p, PartitionGlobalMergeStates &hash_groups_p,
 	                   PartitionGlobalSinkState &gstate)
-	    : ExecutorTask(context_p), event(std::move(event_p)), local_state(gstate), hash_groups(hash_groups_p) {
+	    : ExecutorTask(context_p, std::move(event_p)), local_state(gstate), hash_groups(hash_groups_p) {
 	}
 
 	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override;
@@ -582,7 +582,6 @@ private:
 		Executor &executor;
 	};
 
-	shared_ptr<Event> event;
 	PartitionLocalMergeState local_state;
 	PartitionGlobalMergeStates &hash_groups;
 };

package/src/duckdb/src/common/sort/ub_duckdb_sort.cpp

@@ -0,0 +1,7 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/common/sort/comparators.cpp>
+#include </Users/carlo/duckdb/src/common/sort/merge_sorter.cpp>
+#include </Users/carlo/duckdb/src/common/sort/partition_state.cpp>
+#include </Users/carlo/duckdb/src/common/sort/radix_sort.cpp>
+#include </Users/carlo/duckdb/src/common/sort/sort_state.cpp>
+#include </Users/carlo/duckdb/src/common/sort/sorted_block.cpp>

package/src/duckdb/src/common/string_util.cpp

@@ -44,13 +44,13 @@ void StringUtil::LTrim(string &str) {
 
 // Remove trailing ' ', '\f', '\n', '\r', '\t', '\v'
 void StringUtil::RTrim(string &str) {
-	str.erase(find_if(str.rbegin(), str.rend(), [](int ch) { return ch > 0 && !CharacterIsSpace(ch); }).base(),
+	str.erase(find_if(str.rbegin(), str.rend(), [](char ch) { return ch > 0 && !CharacterIsSpace(ch); }).base(),
 	          str.end());
 }
 
 void StringUtil::RTrim(string &str, const string &chars_to_trim) {
 	str.erase(find_if(str.rbegin(), str.rend(),
-	                  [&chars_to_trim](int ch) { return ch > 0 && chars_to_trim.find(ch) == string::npos; })
+	                  [&chars_to_trim](char ch) { return ch > 0 && chars_to_trim.find(ch) == string::npos; })
 	              .base(),
 	          str.end());
 }
@@ -355,7 +355,7 @@ idx_t StringUtil::LevenshteinDistance(const string &s1_p, const string &s2_p, id
 			// d[i][j] = std::min({ d[i - 1][j] + 1,
 			//                      d[i][j - 1] + 1,
 			//                      d[i - 1][j - 1] + (s1[i - 1] == s2[j - 1] ? 0 : 1) });
-			int equal = s1[i - 1] == s2[j - 1] ? 0 : not_equal_penalty;
+			auto equal = s1[i - 1] == s2[j - 1] ? 0 : not_equal_penalty;
 			idx_t adjacent_score1 = array.Score(i - 1, j) + 1;
 			idx_t adjacent_score2 = array.Score(i, j - 1) + 1;
 			idx_t adjacent_score3 = array.Score(i - 1, j - 1) + equal;

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

@@ -1,4 +1,5 @@
 #include "duckdb/common/assert.hpp"
+#include "duckdb/common/numeric_utils.hpp"
 #include "duckdb/common/operator/cast_operators.hpp"
 #include "duckdb/common/typedefs.hpp"
 #include "duckdb/common/types/bit.hpp"
@@ -129,7 +130,7 @@ void Bit::ToBit(string_t str, string_t &output_str) {
 		}
 	}
 	if (padded_byte != 0) {
-		*(output++) = (8 - padded_byte); // the first byte contains the number of padded zeroes
+		*(output++) = UnsafeNumericCast<char>((8 - padded_byte)); // the first byte contains the number of padded zeroes
 	}
 	*(output++) = byte;
 
@@ -150,7 +151,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);
-	string_t output_str(buffer.get(), bit_len);
+	string_t output_str(buffer.get(), UnsafeNumericCast<uint32_t>(bit_len));
 	Bit::ToBit(str, output_str);
 	return output_str.GetString();
 }
@@ -166,7 +167,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);
-	string_t output_str(buffer.get(), 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 +193,7 @@ string Bit::BitToBlob(string_t bit) {
 	D_ASSERT(bit.GetSize() > 1);
 
 	auto buffer = make_unsafe_uniq_array<char>(bit.GetSize() - 1);
-	string_t output_str(buffer.get(), bit.GetSize() - 1);
+	string_t output_str(buffer.get(), UnsafeNumericCast<uint32_t>(bit.GetSize() - 1));
 	Bit::BitToBlob(bit, output_str);
 	return output_str.GetString();
 }
@@ -289,11 +290,11 @@ 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) {
-	char *buf = bit_string.GetDataWriteable();
+	auto buf = bit_string.GetDataWriteable();
 
 	auto idx = Bit::GetBitIndex(n);
 	D_ASSERT(idx < bit_string.GetSize());
-	char shift_byte = 1 << (7 - (n % 8));
+	auto shift_byte = UnsafeNumericCast<uint8_t>(1 << (7 - (n % 8)));
 	if (new_value == 0) {
 		shift_byte = ~shift_byte;
 		buf[idx] &= shift_byte;

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

@@ -2,6 +2,7 @@
 #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"
 
@@ -69,7 +70,7 @@ string Blob::ToString(string_t blob) {
 	return string(buffer.get(), str_len);
 }
 
-bool Blob::TryGetBlobSize(string_t str, idx_t &str_len, string *error_message) {
+bool Blob::TryGetBlobSize(string_t str, idx_t &str_len, CastParameters &parameters) {
 	auto data = const_data_ptr_cast(str.GetData());
 	auto len = str.GetSize();
 	str_len = 0;
@@ -78,14 +79,14 @@ bool Blob::TryGetBlobSize(string_t str, idx_t &str_len, string *error_message) {
 			if (i + 3 >= len) {
 				string error = "Invalid hex escape code encountered in string -> blob conversion: "
 				               "unterminated escape code at end of blob";
-				HandleCastError::AssignError(error, error_message);
+				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));
-				HandleCastError::AssignError(error, error_message);
+				HandleCastError::AssignError(error, parameters);
 				return false;
 			}
 			str_len++;
@@ -95,7 +96,7 @@ bool Blob::TryGetBlobSize(string_t str, idx_t &str_len, string *error_message) {
 		} else {
 			string error = "Invalid byte encountered in STRING -> BLOB conversion. All non-ascii characters "
 			               "must be escaped with hex codes (e.g. \\xAA)";
-			HandleCastError::AssignError(error, error_message);
+			HandleCastError::AssignError(error, parameters);
 			return false;
 		}
 	}
@@ -103,10 +104,15 @@ bool Blob::TryGetBlobSize(string_t str, idx_t &str_len, string *error_message) {
 }
 
 idx_t Blob::GetBlobSize(string_t str) {
-	string error_message;
+	CastParameters parameters;
+	return GetBlobSize(str, parameters);
+}
+
+idx_t Blob::GetBlobSize(string_t str, CastParameters &parameters) {
 	idx_t str_len;
-	if (!Blob::TryGetBlobSize(str, str_len, &error_message)) {
-		throw ConversionException(error_message);
+	auto result = Blob::TryGetBlobSize(str, str_len, parameters);
+	if (!result) {
+		throw InternalException("Blob::TryGetBlobSize failed but no exception was thrown!?");
 	}
 	return str_len;
 }
@@ -122,7 +128,7 @@ void Blob::ToBlob(string_t str, data_ptr_t output) {
 			D_ASSERT(i + 3 < len);
 			D_ASSERT(byte_a >= 0 && byte_b >= 0);
 			D_ASSERT(data[i + 1] == 'x');
-			output[blob_idx++] = (byte_a << 4) + byte_b;
+			output[blob_idx++] = UnsafeNumericCast<data_t>((byte_a << 4) + byte_b);
 			i += 3;
 		} else if (data[i] <= 127) {
 			output[blob_idx++] = data_t(data[i]);
@@ -135,7 +141,12 @@ void Blob::ToBlob(string_t str, data_ptr_t output) {
 }
 
 string Blob::ToBlob(string_t str) {
-	auto blob_len = GetBlobSize(str);
+	CastParameters parameters;
+	return Blob::ToBlob(str, parameters);
+}
+
+string Blob::ToBlob(string_t str, CastParameters &parameters) {
+	auto blob_len = GetBlobSize(str, parameters);
 	auto buffer = make_unsafe_uniq_array<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

@@ -64,9 +64,10 @@ BufferHandle ColumnDataAllocator::AllocateBlock(idx_t size) {
 	auto block_size = MaxValue<idx_t>(size, Storage::BLOCK_SIZE);
 	BlockMetaData data;
 	data.size = 0;
-	data.capacity = block_size;
+	data.capacity = NumericCast<uint32_t>(block_size);
 	auto pin = alloc.buffer_manager->Allocate(MemoryTag::COLUMN_DATA, block_size, false, &data.handle);
 	blocks.push_back(std::move(data));
+	allocated_size += block_size;
 	return pin;
 }
 
@@ -80,9 +81,10 @@ void ColumnDataAllocator::AllocateEmptyBlock(idx_t size) {
 	D_ASSERT(type == ColumnDataAllocatorType::IN_MEMORY_ALLOCATOR);
 	BlockMetaData data;
 	data.size = 0;
-	data.capacity = allocation_amount;
+	data.capacity = NumericCast<uint32_t>(allocation_amount);
 	data.handle = nullptr;
 	blocks.push_back(std::move(data));
+	allocated_size += allocation_amount;
 }
 
 void ColumnDataAllocator::AssignPointer(uint32_t &block_id, uint32_t &offset, data_ptr_t pointer) {
@@ -110,7 +112,7 @@ void ColumnDataAllocator::AllocateBuffer(idx_t size, uint32_t &block_id, uint32_
 	}
 	auto &block = blocks.back();
 	D_ASSERT(size <= block.capacity - block.size);
-	block_id = blocks.size() - 1;
+	block_id = NumericCast<uint32_t>(blocks.size() - 1);
 	if (chunk_state && chunk_state->handles.find(block_id) == chunk_state->handles.end()) {
 		// not guaranteed to be pinned already by this thread (if shared allocator)
 		chunk_state->handles[block_id] = alloc.buffer_manager->Pin(blocks[block_id].handle);
@@ -186,8 +188,8 @@ void ColumnDataAllocator::UnswizzlePointers(ChunkManagementState &state, Vector
 	auto strings = FlatVector::GetData<string_t>(result);
 
 	// find first non-inlined string
-	uint32_t i = v_offset;
-	const uint32_t end = v_offset + count;
+	auto i = NumericCast<uint32_t>(v_offset);
+	const uint32_t end = NumericCast<uint32_t>(v_offset + count);
 	for (; i < end; i++) {
 		if (!validity.RowIsValid(i)) {
 			continue;
@@ -237,7 +239,7 @@ void ColumnDataAllocator::InitializeChunkState(ChunkManagementState &state, Chun
 	do {
 		found_handle = false;
 		for (auto it = state.handles.begin(); it != state.handles.end(); it++) {
-			if (chunk.block_ids.find(it->first) != chunk.block_ids.end()) {
+			if (chunk.block_ids.find(NumericCast<uint32_t>(it->first)) != chunk.block_ids.end()) {
 				// still required: do not release
 				continue;
 			}

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

@@ -111,6 +111,14 @@ idx_t ColumnDataCollection::SizeInBytes() const {
 	return total_size;
 }
 
+idx_t ColumnDataCollection::AllocationSize() const {
+	idx_t total_size = 0;
+	for (const auto &segment : segments) {
+		total_size += segment->AllocationSize();
+	}
+	return total_size;
+}
+
 //===--------------------------------------------------------------------===//
 // ColumnDataRow
 //===--------------------------------------------------------------------===//
@@ -289,6 +297,7 @@ const ColumnDataRow &ColumnDataRowIterationHelper::ColumnDataRowIterator::operat
 //===--------------------------------------------------------------------===//
 void ColumnDataCollection::InitializeAppend(ColumnDataAppendState &state) {
 	D_ASSERT(!finished_append);
+	state.current_chunk_state.handles.clear();
 	state.vector_data.resize(types.size());
 	if (segments.empty()) {
 		CreateSegment();
@@ -532,7 +541,8 @@ void ColumnDataCopy<string_t>(ColumnDataMetaData &meta_data, const UnifiedVector
 			} else {
 				D_ASSERT(heap_ptr != nullptr);
 				memcpy(heap_ptr, source_entry.GetData(), source_entry.GetSize());
-				target_entry = string_t(const_char_ptr_cast(heap_ptr), source_entry.GetSize());
+				target_entry =
+				    string_t(const_char_ptr_cast(heap_ptr), UnsafeNumericCast<uint32_t>(source_entry.GetSize()));
 				heap_ptr += source_entry.GetSize();
 			}
 		}

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

@@ -255,6 +255,11 @@ idx_t ColumnDataCollectionSegment::SizeInBytes() const {
 	return allocator->SizeInBytes() + heap->SizeInBytes();
 }
 
+idx_t ColumnDataCollectionSegment::AllocationSize() const {
+	D_ASSERT(!allocator->IsShared());
+	return allocator->AllocationSize() + heap->AllocationSize();
+}
+
 void ColumnDataCollectionSegment::FetchChunk(idx_t chunk_idx, DataChunk &result) {
 	vector<column_t> column_ids;
 	column_ids.reserve(types.size());

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

@@ -92,7 +92,7 @@ void PartitionedColumnData::Append(PartitionedColumnDataAppendState &state, Data
 	for (idx_t i = 0; i < count; i++) {
 		const auto &partition_index = partition_indices[i];
 		auto &partition_offset = partition_entries[partition_index].offset;
-		all_partitions_sel[partition_offset++] = i;
+		all_partitions_sel[partition_offset++] = NumericCast<sel_t>(i);
 	}
 
 	// Loop through the partitions to append the new data to the partition buffers, and flush the buffers if necessary

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

@@ -0,0 +1,6 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/common/types/column/column_data_allocator.cpp>
+#include </Users/carlo/duckdb/src/common/types/column/column_data_collection.cpp>
+#include </Users/carlo/duckdb/src/common/types/column/column_data_collection_segment.cpp>
+#include </Users/carlo/duckdb/src/common/types/column/column_data_consumer.cpp>
+#include </Users/carlo/duckdb/src/common/types/column/partitioned_column_data.cpp>

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

@@ -238,7 +238,7 @@ void DataChunk::Serialize(Serializer &serializer) const {
 
 	// write the count
 	auto row_count = size();
-	serializer.WriteProperty<sel_t>(100, "rows", row_count);
+	serializer.WriteProperty<sel_t>(100, "rows", NumericCast<sel_t>(row_count));
 
 	// we should never try to serialize empty data chunks
 	auto column_count = ColumnCount();

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

@@ -417,7 +417,7 @@ int32_t Date::EpochDays(date_t date) {
 }
 
 date_t Date::EpochToDate(int64_t epoch) {
-	return date_t(epoch / Interval::SECS_PER_DAY);
+	return date_t(UnsafeNumericCast<int32_t>(epoch / Interval::SECS_PER_DAY));
 }
 
 int64_t Date::Epoch(date_t date) {

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

@@ -4,6 +4,7 @@
 #include "duckdb/common/algorithm.hpp"
 #include "duckdb/common/hugeint.hpp"
 #include "duckdb/common/limits.hpp"
+#include "duckdb/common/numeric_utils.hpp"
 #include "duckdb/common/windows_undefs.hpp"
 #include "duckdb/common/types/value.hpp"
 #include "duckdb/common/operator/cast_operators.hpp"
@@ -165,7 +166,7 @@ string Hugeint::ToString(hugeint_t input) {
 			break;
 		}
 		input = Hugeint::DivModPositive(input, 10, remainder);
-		result = string(1, '0' + remainder) + result; // NOLINT
+		result = string(1, UnsafeNumericCast<char>('0' + remainder)) + result; // NOLINT
 	}
 	if (result.empty()) {
 		// value is zero
@@ -677,7 +678,7 @@ bool Hugeint::TryConvert(int8_t value, hugeint_t &result) {
 template <>
 bool Hugeint::TryConvert(const char *value, hugeint_t &result) {
 	auto len = strlen(value);
-	string_t string_val(value, len);
+	string_t string_val(value, UnsafeNumericCast<uint32_t>(len));
 	return TryCast::Operation<string_t, hugeint_t>(string_val, result, true);
 }
 

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

@@ -111,7 +111,7 @@ interval_parse_number:
 				return false;
 			}
 			// finished the number, parse it from the string
-			string_t nr_string(str + start_pos, pos - start_pos);
+			string_t nr_string(str + start_pos, UnsafeNumericCast<uint32_t>(pos - start_pos));
 			number = Cast::Operation<string_t, int64_t>(nr_string);
 			fraction = 0;
 			if (c == '.') {

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

@@ -1,4 +1,5 @@
 #include "duckdb/common/types/list_segment.hpp"
+#include "duckdb/common/numeric_utils.hpp"
 #include "duckdb/common/uhugeint.hpp"
 
 namespace duckdb {
@@ -190,7 +191,7 @@ static ListSegment *GetSegment(const ListSegmentFunctions &functions, ArenaAlloc
 	if (!linked_list.last_segment) {
 		// empty linked list, create the first (and last) segment
 		auto capacity = ListSegment::INITIAL_CAPACITY;
-		segment = functions.create_segment(functions, allocator, capacity);
+		segment = functions.create_segment(functions, allocator, UnsafeNumericCast<uint16_t>(capacity));
 		linked_list.first_segment = segment;
 		linked_list.last_segment = segment;
 

package/src/duckdb/src/common/types/row/partitioned_tuple_data.cpp

@@ -32,12 +32,6 @@ void PartitionedTupleData::InitializeAppendState(PartitionedTupleDataAppendState
 	state.partition_sel.Initialize();
 	state.reverse_partition_sel.Initialize();
 
-	vector<column_t> column_ids;
-	column_ids.reserve(layout.ColumnCount());
-	for (idx_t col_idx = 0; col_idx < layout.ColumnCount(); col_idx++) {
-		column_ids.emplace_back(col_idx);
-	}
-
 	InitializeAppendStateInternal(state, properties);
 }
 
@@ -223,7 +217,7 @@ void PartitionedTupleData::BuildPartitionSel(PartitionedTupleDataAppendState &st
 		// This needs to be initialized, even if we go the short path here
 		for (idx_t i = 0; i < append_count; i++) {
 			const auto index = append_sel.get_index(i);
-			state.reverse_partition_sel[index] = i;
+			state.reverse_partition_sel[index] = NumericCast<sel_t>(i);
 		}
 		return;
 	}
@@ -243,8 +237,8 @@ void PartitionedTupleData::BuildPartitionSel(PartitionedTupleDataAppendState &st
 		const auto index = append_sel.get_index(i);
 		const auto &partition_index = partition_indices[index];
 		auto &partition_offset = partition_entries[partition_index].offset;
-		reverse_partition_sel[index] = partition_offset;
-		partition_sel[partition_offset++] = index;
+		reverse_partition_sel[index] = UnsafeNumericCast<sel_t>(partition_offset);
+		partition_sel[partition_offset++] = UnsafeNumericCast<sel_t>(index);
 	}
 }
 

package/src/duckdb/src/common/types/row/tuple_data_allocator.cpp

@@ -110,12 +110,12 @@ TupleDataChunkPart TupleDataAllocator::BuildChunkPart(TupleDataPinState &pin_sta
 	if (row_blocks.empty() || row_blocks.back().RemainingCapacity() < layout.GetRowWidth()) {
 		row_blocks.emplace_back(buffer_manager, (idx_t)Storage::BLOCK_SIZE);
 	}
-	result.row_block_index = row_blocks.size() - 1;
+	result.row_block_index = NumericCast<uint32_t>(row_blocks.size() - 1);
 	auto &row_block = row_blocks[result.row_block_index];
-	result.row_block_offset = row_block.size;
+	result.row_block_offset = NumericCast<uint32_t>(row_block.size);
 
 	// Set count (might be reduced later when checking heap space)
-	result.count = MinValue<idx_t>(row_block.RemainingCapacity(layout.GetRowWidth()), append_count);
+	result.count = NumericCast<uint32_t>(MinValue(row_block.RemainingCapacity(layout.GetRowWidth()), append_count));
 	if (!layout.AllConstant()) {
 		const auto heap_sizes = FlatVector::GetData<idx_t>(chunk_state.heap_sizes);
 
@@ -138,21 +138,21 @@ TupleDataChunkPart TupleDataAllocator::BuildChunkPart(TupleDataPinState &pin_sta
 				const auto size = MaxValue<idx_t>((idx_t)Storage::BLOCK_SIZE, heap_sizes[append_offset]);
 				heap_blocks.emplace_back(buffer_manager, size);
 			}
-			result.heap_block_index = heap_blocks.size() - 1;
+			result.heap_block_index = NumericCast<uint32_t>(heap_blocks.size() - 1);
 			auto &heap_block = heap_blocks[result.heap_block_index];
-			result.heap_block_offset = heap_block.size;
+			result.heap_block_offset = NumericCast<uint32_t>(heap_block.size);
 
 			const auto heap_remaining = heap_block.RemainingCapacity();
 			if (total_heap_size <= heap_remaining) {
 				// Everything fits
-				result.total_heap_size = total_heap_size;
+				result.total_heap_size = NumericCast<uint32_t>(total_heap_size);
 			} else {
 				// Not everything fits - determine how many we can read next
 				result.total_heap_size = 0;
 				for (idx_t i = 0; i < result.count; i++) {
 					const auto &heap_size = heap_sizes[append_offset + i];
 					if (result.total_heap_size + heap_size > heap_remaining) {
-						result.count = i;
+						result.count = NumericCast<uint32_t>(i);
 						break;
 					}
 					result.total_heap_size += heap_size;

package/src/duckdb/src/common/types/row/tuple_data_collection.cpp

@@ -214,27 +214,7 @@ void TupleDataCollection::AppendUnified(TupleDataPinState &pin_state, TupleDataC
 	}
 
 	Build(pin_state, chunk_state, 0, actual_append_count);
-
-#ifdef DEBUG
-	Vector heap_locations_copy(LogicalType::POINTER);
-	if (!layout.AllConstant()) {
-		VectorOperations::Copy(chunk_state.heap_locations, heap_locations_copy, actual_append_count, 0, 0);
-	}
-#endif
-
 	Scatter(chunk_state, new_chunk, append_sel, actual_append_count);
-
-#ifdef DEBUG
-	// Verify that the size of the data written to the heap is the same as the size we computed it would be
-	if (!layout.AllConstant()) {
-		const auto original_heap_locations = FlatVector::GetData<data_ptr_t>(heap_locations_copy);
-		const auto heap_sizes = FlatVector::GetData<idx_t>(chunk_state.heap_sizes);
-		const auto offset_heap_locations = FlatVector::GetData<data_ptr_t>(chunk_state.heap_locations);
-		for (idx_t i = 0; i < actual_append_count; i++) {
-			D_ASSERT(offset_heap_locations[i] == original_heap_locations[i] + heap_sizes[i]);
-		}
-	}
-#endif
 }
 
 static inline void ToUnifiedFormatInternal(TupleDataVectorFormat &format, Vector &vector, const idx_t count) {
@@ -261,20 +241,23 @@ static inline void ToUnifiedFormatInternal(TupleDataVectorFormat &format, Vector
 
 		// For arrays, we cheat a bit and pretend that they are lists by creating and assigning list_entry_t's to the
 		// vector This allows us to reuse all the list serialization functions for array types too.
+		auto array_size = ArrayType::GetSize(vector.GetType());
 
-		// This is kind of hacky, but we need to create a list_entry_t for each array entry
-		idx_t array_count = ArrayVector::GetTotalSize(vector) / ArrayType::GetSize(vector.GetType());
-		format.array_list_entries = make_uniq_array<list_entry_t>(array_count);
+		// How many list_entry_t's do we need to cover the whole child array?
+		// Make sure we round up so its all covered
+		auto child_array_total_size = ArrayVector::GetTotalSize(vector);
+		auto list_entry_t_count = MaxValue((child_array_total_size + array_size) / array_size, count);
 
-		auto array_size = ArrayType::GetSize(vector.GetType());
-		// create list entries
-		for (idx_t i = 0; i < array_count; i++) {
+		// Create list entries!
+		format.array_list_entries = make_uniq_array<list_entry_t>(list_entry_t_count);
+		for (idx_t i = 0; i < list_entry_t_count; i++) {
 			format.array_list_entries[i].length = array_size;
 			format.array_list_entries[i].offset = i * array_size;
 		}
 		format.unified.data = reinterpret_cast<data_ptr_t>(format.array_list_entries.get());
 
-		ToUnifiedFormatInternal(format.children[0], ArrayVector::GetEntry(vector), ArrayVector::GetTotalSize(vector));
+		ToUnifiedFormatInternal(reinterpret_cast<TupleDataVectorFormat &>(format.children[0]),
+		                        ArrayVector::GetEntry(vector), count * array_size);
 	} break;
 	default:
 		break;