duckdb 0.10.3-dev3.0 → 0.10.3-dev8.0

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

@@ -8,18 +8,22 @@ namespace duckdb {
 using ValidityBytes = TemplatedValidityMask<uint8_t>;
 
 NestedValidity::NestedValidity(data_ptr_t validitymask_location)
-    : list_validity_location(validitymask_location), struct_validity_locations(nullptr), entry_idx(0), idx_in_entry(0) {
+    : list_validity_location(validitymask_location), struct_validity_locations(nullptr), entry_idx(0), idx_in_entry(0),
+      list_validity_offset(0) {
 }
 
 NestedValidity::NestedValidity(data_ptr_t *validitymask_locations, idx_t child_vector_index)
-    : list_validity_location(nullptr), struct_validity_locations(validitymask_locations), entry_idx(0),
-      idx_in_entry(0) {
+    : list_validity_location(nullptr), struct_validity_locations(validitymask_locations), entry_idx(0), idx_in_entry(0),
+      list_validity_offset(0) {
 	ValidityBytes::GetEntryIndex(child_vector_index, entry_idx, idx_in_entry);
 }
 
 void NestedValidity::SetInvalid(idx_t idx) {
 	if (list_validity_location) {
 		// Is List
+
+		idx = idx + list_validity_offset;
+
 		idx_t list_entry_idx;
 		idx_t list_idx_in_entry;
 		ValidityBytes::GetEntryIndex(idx, list_entry_idx, list_idx_in_entry);
@@ -32,9 +36,16 @@ void NestedValidity::SetInvalid(idx_t idx) {
 	}
 }
 
+void NestedValidity::OffsetListBy(idx_t offset) {
+	list_validity_offset += offset;
+}
+
 bool NestedValidity::IsValid(idx_t idx) {
 	if (list_validity_location) {
 		// Is List
+
+		idx = idx + list_validity_offset;
+
 		idx_t list_entry_idx;
 		idx_t list_idx_in_entry;
 		ValidityBytes::GetEntryIndex(idx, list_entry_idx, list_idx_in_entry);
@@ -437,6 +448,8 @@ static void HeapScatterArrayVector(Vector &v, idx_t vcount, const SelectionVecto
 		memset(array_validitymask_location, -1, array_validitymask_size);
 		key_locations[i] += array_validitymask_size;
 
+		NestedValidity array_parent_validity(array_validitymask_location);
+
 		// If the array contains variable size entries, we reserve spaces for them here
 		data_ptr_t var_entry_size_ptr = nullptr;
 		if (child_type_is_var_size) {
@@ -474,7 +487,6 @@ static void HeapScatterArrayVector(Vector &v, idx_t vcount, const SelectionVecto
 				}
 			}
 
-			NestedValidity array_parent_validity(array_validitymask_location);
 			RowOperations::HeapScatter(child_vector, ArrayVector::GetTotalSize(v),
 			                           *FlatVector::IncrementalSelectionVector(), chunk_size, array_entry_locations,
 			                           &array_parent_validity, array_start);
@@ -482,6 +494,7 @@ static void HeapScatterArrayVector(Vector &v, idx_t vcount, const SelectionVecto
 			// update for next iteration
 			elem_remaining -= chunk_size;
 			array_start += chunk_size;
+			array_parent_validity.OffsetListBy(chunk_size);
 		}
 	}
 }

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

@@ -125,7 +125,7 @@ void RadixScatterListVector(Vector &v, UnifiedVectorFormat &vdata, const Selecti
 					key_locations[i][0] = 1;
 					key_locations[i]++;
 					RowOperations::RadixScatter(child_vector, list_size, *FlatVector::IncrementalSelectionVector(), 1,
-					                            key_locations + i, false, true, false, prefix_len, width - 1,
+					                            key_locations + i, false, true, false, prefix_len, width - 2,
 					                            list_entry.offset);
 				} else {
 					// denote that the list is empty with a 0

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

@@ -11,20 +11,20 @@ BufferedFileReader::BufferedFileReader(FileSystem &fs, const char *path, FileLoc
                                        optional_ptr<FileOpener> opener)
     : fs(fs), data(make_unsafe_uniq_array<data_t>(FILE_BUFFER_SIZE)), offset(0), read_data(0), total_read(0) {
 	handle = fs.OpenFile(path, FileFlags::FILE_FLAGS_READ | lock_type, opener.get());
-	file_size = fs.GetFileSize(*handle);
+	file_size = NumericCast<idx_t>(fs.GetFileSize(*handle));
 }
 
 BufferedFileReader::BufferedFileReader(FileSystem &fs, unique_ptr<FileHandle> handle_p)
     : fs(fs), data(make_unsafe_uniq_array<data_t>(FILE_BUFFER_SIZE)), offset(0), read_data(0),
       handle(std::move(handle_p)), total_read(0) {
-	file_size = fs.GetFileSize(*handle);
+	file_size = NumericCast<idx_t>(fs.GetFileSize(*handle));
 }
 
 void BufferedFileReader::ReadData(data_ptr_t target_buffer, uint64_t read_size) {
 	// first copy anything we can from the buffer
 	data_ptr_t end_ptr = target_buffer + read_size;
 	while (true) {
-		idx_t to_read = MinValue<idx_t>(end_ptr - target_buffer, read_data - offset);
+		idx_t to_read = MinValue<idx_t>(UnsafeNumericCast<idx_t>(end_ptr - target_buffer), read_data - offset);
 		if (to_read > 0) {
 			memcpy(target_buffer, data.get() + offset, to_read);
 			offset += to_read;
@@ -36,7 +36,7 @@ void BufferedFileReader::ReadData(data_ptr_t target_buffer, uint64_t read_size)
 			// did not finish reading yet but exhausted buffer
 			// read data into buffer
 			offset = 0;
-			read_data = fs.Read(*handle, data.get(), FILE_BUFFER_SIZE);
+			read_data = UnsafeNumericCast<idx_t>(fs.Read(*handle, data.get(), FILE_BUFFER_SIZE));
 			if (read_data == 0) {
 				throw SerializationException("not enough data in file to deserialize result");
 			}

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

@@ -15,7 +15,7 @@ BufferedFileWriter::BufferedFileWriter(FileSystem &fs, const string &path_p, Fil
 }
 
 int64_t BufferedFileWriter::GetFileSize() {
-	return fs.GetFileSize(*handle) + offset;
+	return fs.GetFileSize(*handle) + NumericCast<int64_t>(offset);
 }
 
 idx_t BufferedFileWriter::GetTotalWritten() {
@@ -37,13 +37,14 @@ void BufferedFileWriter::WriteData(const_data_ptr_t buffer, idx_t write_size) {
 			Flush(); // Flush buffer before writing every things else
 		}
 		idx_t remaining_to_write = write_size - to_copy;
-		fs.Write(*handle, const_cast<data_ptr_t>(buffer + to_copy), remaining_to_write); // NOLINT: wrong API in Write
+		fs.Write(*handle, const_cast<data_ptr_t>(buffer + to_copy), // NOLINT: wrong API in Write
+		         UnsafeNumericCast<int64_t>(remaining_to_write));
 		total_written += remaining_to_write;
 	} else {
 		// first copy anything we can from the buffer
 		const_data_ptr_t end_ptr = buffer + write_size;
 		while (buffer < end_ptr) {
-			idx_t to_write = MinValue<idx_t>((end_ptr - buffer), FILE_BUFFER_SIZE - offset);
+			idx_t to_write = MinValue<idx_t>(UnsafeNumericCast<idx_t>((end_ptr - buffer)), FILE_BUFFER_SIZE - offset);
 			D_ASSERT(to_write > 0);
 			memcpy(data.get() + offset, buffer, to_write);
 			offset += to_write;
@@ -59,7 +60,7 @@ void BufferedFileWriter::Flush() {
 	if (offset == 0) {
 		return;
 	}
-	fs.Write(*handle, data.get(), offset);
+	fs.Write(*handle, data.get(), UnsafeNumericCast<int64_t>(offset));
 	total_written += offset;
 	offset = 0;
 }
@@ -70,11 +71,11 @@ void BufferedFileWriter::Sync() {
 }
 
 void BufferedFileWriter::Truncate(int64_t size) {
-	uint64_t persistent = fs.GetFileSize(*handle);
-	D_ASSERT((uint64_t)size <= persistent + offset);
-	if (persistent <= (uint64_t)size) {
+	auto persistent = fs.GetFileSize(*handle);
+	D_ASSERT(size <= persistent + NumericCast<int64_t>(offset));
+	if (persistent <= size) {
 		// truncating into the pending write buffer.
-		offset = size - persistent;
+		offset = NumericCast<idx_t>(size - persistent);
 	} else {
 		// truncate the physical file on disk
 		handle->Truncate(size);

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

@@ -2,8 +2,12 @@
 
 namespace duckdb {
 
-MemoryStream::MemoryStream(idx_t capacity)
-    : position(0), capacity(capacity), owns_data(true), data(static_cast<data_ptr_t>(malloc(capacity))) {
+MemoryStream::MemoryStream(idx_t capacity) : position(0), capacity(capacity), owns_data(true) {
+	auto data_malloc_result = malloc(capacity);
+	if (!data_malloc_result) {
+		throw std::bad_alloc();
+	}
+	data = static_cast<data_ptr_t>(data_malloc_result);
 }
 
 MemoryStream::MemoryStream(data_ptr_t buffer, idx_t capacity)
@@ -25,7 +29,6 @@ void MemoryStream::WriteData(const_data_ptr_t source, idx_t write_size) {
 			throw SerializationException("Failed to serialize: not enough space in buffer to fulfill write request");
 		}
 	}
-
 	memcpy(data + position, source, write_size);
 	position += write_size;
 }

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

@@ -17,7 +17,7 @@ template <>
 void Serializer::WritePropertyWithDefault<Value>(const field_id_t field_id, const char *tag, const Value &value,
                                                  const Value &&default_value) {
 	// If current value is default, don't write it
-	if (!serialize_default_values && ValueOperations::NotDistinctFrom(value, default_value)) {
+	if (!options.serialize_default_values && ValueOperations::NotDistinctFrom(value, default_value)) {
 		OnOptionalPropertyBegin(field_id, tag, false);
 		OnOptionalPropertyEnd(false);
 		return;

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

@@ -501,7 +501,7 @@ void Comparators::SwizzleSingleValue(data_ptr_t data_ptr, const data_ptr_t &heap
 	if (type.InternalType() == PhysicalType::VARCHAR) {
 		data_ptr += string_t::HEADER_SIZE;
 	}
-	Store<idx_t>(Load<data_ptr_t>(data_ptr) - heap_ptr, data_ptr);
+	Store<idx_t>(UnsafeNumericCast<idx_t>(Load<data_ptr_t>(data_ptr) - heap_ptr), data_ptr);
 }
 
 } // namespace duckdb

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

@@ -516,9 +516,9 @@ void MergeSorter::MergeData(SortedData &result_data, SortedData &l_data, SortedD
 					entry_size =
 					    l_smaller * Load<uint32_t>(l_heap_ptr_copy) + r_smaller * Load<uint32_t>(r_heap_ptr_copy);
 					D_ASSERT(entry_size >= sizeof(uint32_t));
-					D_ASSERT(l_heap_ptr_copy - l.BaseHeapPtr(l_data) + l_smaller * entry_size <=
+					D_ASSERT(NumericCast<idx_t>(l_heap_ptr_copy - l.BaseHeapPtr(l_data)) + l_smaller * entry_size <=
 					         l_data.heap_blocks[l.block_idx]->byte_offset);
-					D_ASSERT(r_heap_ptr_copy - r.BaseHeapPtr(r_data) + r_smaller * entry_size <=
+					D_ASSERT(NumericCast<idx_t>(r_heap_ptr_copy - r.BaseHeapPtr(r_data)) + r_smaller * entry_size <=
 					         r_data.heap_blocks[r.block_idx]->byte_offset);
 					l_heap_ptr_copy += l_smaller * entry_size;
 					r_heap_ptr_copy += r_smaller * entry_size;

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

@@ -318,7 +318,7 @@ void PartitionLocalSinkState::Sink(DataChunk &input_chunk) {
 			const auto entry_size = payload_layout.GetRowWidth();
 			const auto capacity = MaxValue<idx_t>(STANDARD_VECTOR_SIZE, (Storage::BLOCK_SIZE / entry_size) + 1);
 			rows = make_uniq<RowDataCollection>(gstate.buffer_manager, capacity, entry_size);
-			strings = make_uniq<RowDataCollection>(gstate.buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1, true);
+			strings = make_uniq<RowDataCollection>(gstate.buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1U, true);
 		}
 		const auto row_count = input_chunk.size();
 		const auto row_sel = FlatVector::IncrementalSelectionVector();
@@ -402,8 +402,8 @@ void PartitionLocalSinkState::Combine() {
 PartitionGlobalMergeState::PartitionGlobalMergeState(PartitionGlobalSinkState &sink, GroupDataPtr group_data_p,
                                                      hash_t hash_bin)
     : sink(sink), group_data(std::move(group_data_p)), memory_per_thread(sink.memory_per_thread),
-      num_threads(TaskScheduler::GetScheduler(sink.context).NumberOfThreads()), stage(PartitionSortStage::INIT),
-      total_tasks(0), tasks_assigned(0), tasks_completed(0) {
+      num_threads(NumericCast<idx_t>(TaskScheduler::GetScheduler(sink.context).NumberOfThreads())),
+      stage(PartitionSortStage::INIT), total_tasks(0), tasks_assigned(0), tasks_completed(0) {
 
 	const auto group_idx = sink.hash_groups.size();
 	auto new_group = make_uniq<PartitionGlobalHashGroup>(sink.buffer_manager, sink.partitions, sink.orders,
@@ -424,8 +424,8 @@ PartitionGlobalMergeState::PartitionGlobalMergeState(PartitionGlobalSinkState &s
 
 PartitionGlobalMergeState::PartitionGlobalMergeState(PartitionGlobalSinkState &sink)
     : sink(sink), memory_per_thread(sink.memory_per_thread),
-      num_threads(TaskScheduler::GetScheduler(sink.context).NumberOfThreads()), stage(PartitionSortStage::INIT),
-      total_tasks(0), tasks_assigned(0), tasks_completed(0) {
+      num_threads(NumericCast<idx_t>(TaskScheduler::GetScheduler(sink.context).NumberOfThreads())),
+      stage(PartitionSortStage::INIT), total_tasks(0), tasks_assigned(0), tasks_completed(0) {
 
 	const hash_t hash_bin = 0;
 	const size_t group_idx = 0;
@@ -661,7 +661,7 @@ void PartitionMergeEvent::Schedule() {
 
 	// Schedule tasks equal to the number of threads, which will each merge multiple partitions
 	auto &ts = TaskScheduler::GetScheduler(context);
-	idx_t num_threads = ts.NumberOfThreads();
+	auto num_threads = NumericCast<idx_t>(ts.NumberOfThreads());
 
 	vector<shared_ptr<Task>> merge_tasks;
 	for (idx_t tnum = 0; tnum < num_threads; tnum++) {

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

@@ -244,7 +244,7 @@ void RadixSort(BufferManager &buffer_manager, const data_ptr_t &dataptr, const i
 		duckdb_pdqsort::PDQConstants constants(sort_layout.entry_size, col_offset, sorting_size, *end);
 		duckdb_pdqsort::pdqsort_branchless(begin, begin + count, constants);
 	} else if (count <= SortConstants::INSERTION_SORT_THRESHOLD) {
-		InsertionSort(dataptr, nullptr, count, 0, sort_layout.entry_size, sort_layout.comparison_size, 0, false);
+		InsertionSort(dataptr, nullptr, count, col_offset, sort_layout.entry_size, sorting_size, 0, false);
 	} else if (sorting_size <= SortConstants::MSD_RADIX_SORT_SIZE_THRESHOLD) {
 		RadixSortLSD(buffer_manager, dataptr, count, col_offset, sort_layout.entry_size, sorting_size);
 	} else {

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

@@ -171,13 +171,13 @@ void LocalSortState::Initialize(GlobalSortState &global_sort_state, BufferManage
 		auto blob_row_width = sort_layout->blob_layout.GetRowWidth();
 		blob_sorting_data = make_uniq<RowDataCollection>(
 		    *buffer_manager, RowDataCollection::EntriesPerBlock(blob_row_width), blob_row_width);
-		blob_sorting_heap = make_uniq<RowDataCollection>(*buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1, true);
+		blob_sorting_heap = make_uniq<RowDataCollection>(*buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1U, true);
 	}
 	// Payload data
 	auto payload_row_width = payload_layout->GetRowWidth();
 	payload_data = make_uniq<RowDataCollection>(*buffer_manager, RowDataCollection::EntriesPerBlock(payload_row_width),
 	                                            payload_row_width);
-	payload_heap = make_uniq<RowDataCollection>(*buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1, true);
+	payload_heap = make_uniq<RowDataCollection>(*buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1U, true);
 	// Init done
 	initialized = true;
 }
@@ -323,7 +323,7 @@ void LocalSortState::ReOrder(SortedData &sd, data_ptr_t sorting_ptr, RowDataColl
 		    std::accumulate(heap.blocks.begin(), heap.blocks.end(), (idx_t)0,
 		                    [](idx_t a, const unique_ptr<RowDataBlock> &b) { return a + b->byte_offset; });
 		idx_t heap_block_size = MaxValue(total_byte_offset, (idx_t)Storage::BLOCK_SIZE);
-		auto ordered_heap_block = make_uniq<RowDataBlock>(MemoryTag::ORDER_BY, *buffer_manager, heap_block_size, 1);
+		auto ordered_heap_block = make_uniq<RowDataBlock>(MemoryTag::ORDER_BY, *buffer_manager, heap_block_size, 1U);
 		ordered_heap_block->count = count;
 		ordered_heap_block->byte_offset = total_byte_offset;
 		auto ordered_heap_handle = buffer_manager->Pin(ordered_heap_block->block);

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

@@ -30,7 +30,7 @@ void SortedData::CreateBlock() {
 	data_blocks.push_back(make_uniq<RowDataBlock>(MemoryTag::ORDER_BY, buffer_manager, capacity, layout.GetRowWidth()));
 	if (!layout.AllConstant() && state.external) {
 		heap_blocks.push_back(
-		    make_uniq<RowDataBlock>(MemoryTag::ORDER_BY, buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1));
+		    make_uniq<RowDataBlock>(MemoryTag::ORDER_BY, buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1U));
 		D_ASSERT(data_blocks.size() == heap_blocks.size());
 	}
 }
@@ -291,10 +291,10 @@ PayloadScanner::PayloadScanner(SortedData &sorted_data, GlobalSortState &global_
 	auto &layout = sorted_data.layout;
 
 	// Create collections to put the data into so we can use RowDataCollectionScanner
-	rows = make_uniq<RowDataCollection>(global_sort_state.buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1);
+	rows = make_uniq<RowDataCollection>(global_sort_state.buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1U);
 	rows->count = count;
 
-	heap = make_uniq<RowDataCollection>(global_sort_state.buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1);
+	heap = make_uniq<RowDataCollection>(global_sort_state.buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1U);
 	if (!sorted_data.layout.AllConstant()) {
 		heap->count = count;
 	}
@@ -330,7 +330,7 @@ PayloadScanner::PayloadScanner(GlobalSortState &global_sort_state, idx_t block_i
 	auto &layout = sorted_data.layout;
 
 	// Create collections to put the data into so we can use RowDataCollectionScanner
-	rows = make_uniq<RowDataCollection>(global_sort_state.buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1);
+	rows = make_uniq<RowDataCollection>(global_sort_state.buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1U);
 	if (flush_p) {
 		rows->blocks.emplace_back(std::move(sorted_data.data_blocks[block_idx]));
 	} else {
@@ -338,7 +338,7 @@ PayloadScanner::PayloadScanner(GlobalSortState &global_sort_state, idx_t block_i
 	}
 	rows->count = count;
 
-	heap = make_uniq<RowDataCollection>(global_sort_state.buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1);
+	heap = make_uniq<RowDataCollection>(global_sort_state.buffer_manager, (idx_t)Storage::BLOCK_SIZE, 1U);
 	if (!sorted_data.layout.AllConstant() && sorted_data.swizzled) {
 		if (flush_p) {
 			heap->blocks.emplace_back(std::move(sorted_data.heap_blocks[block_idx]));

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

@@ -15,6 +15,10 @@
 #include <string.h>
 #include <random>
 
+#include "yyjson.hpp"
+
+using namespace duckdb_yyjson; // NOLINT
+
 namespace duckdb {
 
 string StringUtil::GenerateRandomName(idx_t length) {
@@ -203,7 +207,8 @@ string StringUtil::Upper(const string &str) {
 
 string StringUtil::Lower(const string &str) {
 	string copy(str);
-	transform(copy.begin(), copy.end(), copy.begin(), [](unsigned char c) { return StringUtil::CharacterToLower(c); });
+	transform(copy.begin(), copy.end(), copy.begin(),
+	          [](unsigned char c) { return StringUtil::CharacterToLower(static_cast<char>(c)); });
 	return (copy);
 }
 
@@ -215,7 +220,7 @@ bool StringUtil::IsLower(const string &str) {
 uint64_t StringUtil::CIHash(const string &str) {
 	uint32_t hash = 0;
 	for (auto c : str) {
-		hash += StringUtil::CharacterToLower(c);
+		hash += static_cast<uint32_t>(StringUtil::CharacterToLower(static_cast<char>(c)));
 		hash += hash << 10;
 		hash ^= hash >> 6;
 	}
@@ -255,6 +260,16 @@ bool StringUtil::CILessThan(const string &s1, const string &s2) {
 	return (charmap[u1] - charmap[u2]) < 0;
 }
 
+idx_t StringUtil::CIFind(vector<string> &vector, const string &search_string) {
+	for (idx_t i = 0; i < vector.size(); i++) {
+		const auto &string = vector[i];
+		if (CIEquals(string, search_string)) {
+			return i;
+		}
+	}
+	return DConstants::INVALID_INDEX;
+}
+
 vector<string> StringUtil::Split(const string &input, const string &split) {
 	vector<string> splits;
 
@@ -404,181 +419,73 @@ string StringUtil::CandidatesErrorMessage(const vector<string> &strings, const s
 	return StringUtil::CandidatesMessage(closest_strings, message_prefix);
 }
 
-static void SkipSpaces(const string &message, idx_t &pos) {
-	for (; pos < message.size() && StringUtil::CharacterIsSpace(message[pos]); pos++) {
-	}
-}
-
-static bool MatchCharacter(const string &message, idx_t &pos, char c) {
-	if (pos >= message.size()) {
-		return false;
-	}
-	return message[pos] == c;
-}
-
-static string ParseJSONValue(const string &message, idx_t &pos) {
-	string result;
-	if (!MatchCharacter(message, pos, '"')) {
-		// values need to start with a quote
-		D_ASSERT(0);
-		return result;
-	}
-	pos++;
-	for (; pos < message.size(); pos++) {
-		if (message[pos] == '\\') {
-			// escape
-			pos++;
-			if (pos >= message.size()) {
-				// escape at end of string!?
-				D_ASSERT(0);
-				return result;
-			}
-			switch (message[pos]) {
-			case 'r':
-				result += '\r';
-				break;
-			case 'n':
-				result += '\n';
-				break;
-			case 't':
-				result += '\t';
-				break;
-			case 'b':
-				result += '\b';
-				break;
-			case 'f':
-				result += '\f';
-				break;
-			case '0':
-				result += '\0';
-				break;
-			case '\\':
-			case '"':
-			case '/':
-				result += message[pos];
-				break;
-			default:
-				// unsupported escape character
-				// NOTE: we do not support unicode escape sequences here
-				D_ASSERT(0);
-				result += message[pos];
-				break;
-			}
-		} else if (message[pos] == '"') {
-			// end of message
-			pos++;
-			return result;
-		} else {
-			result += message[pos];
-		}
-	}
-	// no end-of-value found
-	D_ASSERT(0);
-	return result;
-}
-
 unordered_map<string, string> StringUtil::ParseJSONMap(const string &json) {
 	unordered_map<string, string> result;
 	if (json.empty()) {
 		return result;
 	}
-	idx_t pos = 0;
-	SkipSpaces(json, pos);
-	if (!MatchCharacter(json, pos, '{')) {
-		D_ASSERT(0);
-		return result;
-	}
-	pos++;
-	while (true) {
-		SkipSpaces(json, pos);
-		if (MatchCharacter(json, pos, '}')) {
-			// end of object
-			break;
+	yyjson_read_flag flags = YYJSON_READ_ALLOW_INVALID_UNICODE;
+	yyjson_doc *doc = yyjson_read(json.c_str(), json.size(), flags);
+	if (!doc) {
+		throw SerializationException("Failed to parse JSON string: %s", json);
+	}
+	yyjson_val *root = yyjson_doc_get_root(doc);
+	if (!root || yyjson_get_type(root) != YYJSON_TYPE_OBJ) {
+		yyjson_doc_free(doc);
+		throw SerializationException("Failed to parse JSON string: %s", json);
+	}
+	yyjson_obj_iter iter;
+	yyjson_obj_iter_init(root, &iter);
+	yyjson_val *key, *value;
+	while ((key = yyjson_obj_iter_next(&iter))) {
+		value = yyjson_obj_iter_get_val(key);
+		if (yyjson_get_type(value) != YYJSON_TYPE_STR) {
+			yyjson_doc_free(doc);
+			throw SerializationException("Failed to parse JSON string: %s", json);
 		}
-		if (!result.empty()) {
-			// objects are comma separated
-			if (!MatchCharacter(json, pos, ',')) {
-				D_ASSERT(0);
-				return result;
-			}
-			pos++;
-		}
-		string key = ParseJSONValue(json, pos);
-		SkipSpaces(json, pos);
-		if (!MatchCharacter(json, pos, ':')) {
-			D_ASSERT(0);
-			return result;
-		}
-		pos++;
-		string value = ParseJSONValue(json, pos);
-		auto entry = result.find(key);
-		if (entry != result.end()) {
-			// entry already exists
-			D_ASSERT(0);
-			continue;
-		}
-		result.insert(make_pair(std::move(key), std::move(value)));
+		auto key_val = yyjson_get_str(key);
+		auto key_len = yyjson_get_len(key);
+		auto value_val = yyjson_get_str(value);
+		auto value_len = yyjson_get_len(value);
+		result.emplace(string(key_val, key_len), string(value_val, value_len));
 	}
+	yyjson_doc_free(doc);
 	return result;
 }
 
-static void WriteJSONValue(const string &value, string &result) {
-	result += '"';
-	for (auto c : value) {
-		// check for characters we need to escape
-		switch (c) {
-		case '\0':
-			result += "\\0";
-			break;
-		case '\\':
-			result += "\\\\";
-			break;
-		case '\b':
-			result += "\\b";
-			break;
-		case '\f':
-			result += "\\f";
-			break;
-		case '\t':
-			result += "\\t";
-			break;
-		case '\r':
-			result += "\\r";
-			break;
-		case '\n':
-			result += "\\n";
-			break;
-		case '"':
-			result += "\\\"";
-			break;
-		default:
-			result += c;
-			break;
-		}
-	}
-	result += '"';
-}
-
-static void WriteJSONPair(const string &key, const string &value, string &result) {
-	WriteJSONValue(key, result);
-	result += ":";
-	WriteJSONValue(value, result);
-}
-
 string StringUtil::ToJSONMap(ExceptionType type, const string &message, const unordered_map<string, string> &map) {
 	D_ASSERT(map.find("exception_type") == map.end());
 	D_ASSERT(map.find("exception_message") == map.end());
-	string result;
-	result += "{";
-	// we always write exception type/message
-	WriteJSONPair("exception_type", Exception::ExceptionTypeToString(type), result);
-	result += ",";
-	WriteJSONPair("exception_message", message, result);
+
+	yyjson_mut_doc *doc = yyjson_mut_doc_new(nullptr);
+	yyjson_mut_val *root = yyjson_mut_obj(doc);
+	yyjson_mut_doc_set_root(doc, root);
+
+	auto except_str = Exception::ExceptionTypeToString(type);
+	yyjson_mut_obj_add_strncpy(doc, root, "exception_type", except_str.c_str(), except_str.size());
+	yyjson_mut_obj_add_strncpy(doc, root, "exception_message", message.c_str(), message.size());
 	for (auto &entry : map) {
-		result += ",";
-		WriteJSONPair(entry.first, entry.second, result);
+		auto key = yyjson_mut_strncpy(doc, entry.first.c_str(), entry.first.size());
+		auto value = yyjson_mut_strncpy(doc, entry.second.c_str(), entry.second.size());
+		yyjson_mut_obj_add(root, key, value);
+	}
+
+	yyjson_write_err err;
+	size_t len;
+	yyjson_write_flag flags = YYJSON_WRITE_ALLOW_INVALID_UNICODE;
+	const char *json = yyjson_mut_write_opts(doc, flags, nullptr, &len, &err);
+	if (!json) {
+		yyjson_mut_doc_free(doc);
+		throw SerializationException("Failed to write JSON string: %s", err.msg);
 	}
-	result += "}";
+	// Create a string from the JSON
+	string result(json, len);
+
+	// Free the JSON and the document
+	free((void *)json);
+	yyjson_mut_doc_free(doc);
+
+	// Return the result
 	return result;
 }
 

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

@@ -179,7 +179,7 @@ void Bit::BitToBlob(string_t bit, string_t &output_blob) {
 	auto output = output_blob.GetDataWriteable();
 	idx_t size = output_blob.GetSize();
 
-	output[0] = GetFirstByte(bit);
+	output[0] = UnsafeNumericCast<char>(GetFirstByte(bit));
 	if (size > 2) {
 		++output;
 		// First byte in bitstring contains amount of padded bits,

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

@@ -47,7 +47,7 @@ void Blob::ToString(string_t blob, char *output) {
 	for (idx_t i = 0; i < len; i++) {
 		if (IsRegularCharacter(data[i])) {
 			// ascii characters are rendered as-is
-			output[str_idx++] = data[i];
+			output[str_idx++] = UnsafeNumericCast<char>(data[i]);
 		} else {
 			auto byte_a = data[i] >> 4;
 			auto byte_b = data[i] & 0x0F;
@@ -244,8 +244,8 @@ uint32_t DecodeBase64Bytes(const string_t &str, const_data_ptr_t input_data, idx
 			    input_data[base_idx + decode_idx], base_idx + decode_idx);
 		}
 	}
-	return (decoded_bytes[0] << 3 * 6) + (decoded_bytes[1] << 2 * 6) + (decoded_bytes[2] << 1 * 6) +
-	       (decoded_bytes[3] << 0 * 6);
+	return UnsafeNumericCast<uint32_t>((decoded_bytes[0] << 3 * 6) + (decoded_bytes[1] << 2 * 6) +
+	                                   (decoded_bytes[2] << 1 * 6) + (decoded_bytes[3] << 0 * 6));
 }
 
 void Blob::FromBase64(string_t str, data_ptr_t output, idx_t output_size) {