duckdb 0.10.1-dev6.0 → 0.10.1

package/src/duckdb/src/function/scalar/string/like.cpp

@@ -8,12 +8,23 @@
 namespace duckdb {
 
 struct StandardCharacterReader {
+	static void NextCharacter(const char *sdata, idx_t slen, idx_t &sidx) {
+		sidx++;
+		while (sidx < slen && !LengthFun::IsCharacter(sdata[sidx])) {
+			sidx++;
+		}
+	}
+
 	static char Operation(const char *data, idx_t pos) {
 		return data[pos];
 	}
 };
 
 struct ASCIILCaseReader {
+	static void NextCharacter(const char *sdata, idx_t slen, idx_t &sidx) {
+		sidx++;
+	}
+
 	static char Operation(const char *data, idx_t pos) {
 		return (char)LowerFun::ascii_to_lower_map[(uint8_t)data[pos]];
 	}
@@ -36,7 +47,7 @@ bool TemplatedLikeOperator(const char *sdata, idx_t slen, const char *pdata, idx
 			}
 			sidx++;
 		} else if (pchar == UNDERSCORE) {
-			sidx++;
+			READER::NextCharacter(sdata, slen, sidx);
 		} else if (pchar == PERCENTAGE) {
 			pidx++;
 			while (pidx < plen && pdata[pidx] == PERCENTAGE) {
@@ -398,8 +409,8 @@ bool ILikeOperatorFunction(string_t &str, string_t &pattern, char escape = '\0')
 	idx_t pat_llength = LowerFun::LowerLength(pat_data, pat_size);
 	auto pat_ldata = make_unsafe_uniq_array<char>(pat_llength);
 	LowerFun::LowerCase(pat_data, pat_size, pat_ldata.get());
-	string_t str_lcase(str_ldata.get(), str_llength);
-	string_t pat_lcase(pat_ldata.get(), pat_llength);
+	string_t str_lcase(str_ldata.get(), UnsafeNumericCast<uint32_t>(str_llength));
+	string_t pat_lcase(pat_ldata.get(), UnsafeNumericCast<uint32_t>(pat_llength));
 	return LikeOperatorFunction(str_lcase, pat_lcase, escape);
 }
 

package/src/duckdb/src/function/scalar/string/regexp/regexp_extract_all.cpp

@@ -68,7 +68,8 @@ void ExtractSingleTuple(const string_t &string, duckdb_re2::RE2 &pattern, int32_
 	bool throw_on_group_found = (idx_t)group > args.size;
 
 	idx_t startpos = 0;
-	for (idx_t iteration = 0; ExtractAll(input, pattern, &startpos, args.group_buffer, args.size); iteration++) {
+	for (idx_t iteration = 0;
+	     ExtractAll(input, pattern, &startpos, args.group_buffer, UnsafeNumericCast<int>(args.size)); iteration++) {
 		if (!iteration && throw_on_group_found) {
 			throw InvalidInputException("Pattern has %d groups. Cannot access group %d", args.size, group);
 		}
@@ -96,7 +97,8 @@ void ExtractSingleTuple(const string_t &string, duckdb_re2::RE2 &pattern, int32_
 			// the 'match_group' address is guaranteed to be bigger than that of the source
 			D_ASSERT(const_char_ptr_cast(match_group.begin()) >= string.GetData());
 			idx_t offset = match_group.begin() - string.GetData();
-			list_content[child_idx] = string_t(string.GetData() + offset, match_group.size());
+			list_content[child_idx] =
+			    string_t(string.GetData() + offset, UnsafeNumericCast<uint32_t>(match_group.size()));
 		}
 		current_list_size++;
 		if (startpos > input.size()) {

package/src/duckdb/src/function/scalar/string/regexp/ub_duckdb_func_string_regexp.cpp

@@ -0,0 +1,3 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/function/scalar/string/regexp/regexp_util.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/regexp/regexp_extract_all.cpp>

package/src/duckdb/src/function/scalar/string/regexp.cpp

@@ -272,13 +272,14 @@ static void RegexExtractStructFunction(DataChunk &args, ExpressionState &state,
 			ConstantVector::SetNull(result, false);
 			auto idata = ConstantVector::GetData<string_t>(input);
 			auto str = CreateStringPiece(idata[0]);
-			auto match = duckdb_re2::RE2::PartialMatchN(str, lstate.constant_pattern, groups.data(), groups.size());
+			auto match = duckdb_re2::RE2::PartialMatchN(str, lstate.constant_pattern, groups.data(),
+			                                            UnsafeNumericCast<int>(groups.size()));
 			for (size_t col = 0; col < child_entries.size(); ++col) {
 				auto &child_entry = child_entries[col];
 				ConstantVector::SetNull(*child_entry, false);
 				auto &extracted = ws[col];
 				auto cdata = ConstantVector::GetData<string_t>(*child_entry);
-				cdata[0] = string_t(extracted.data(), match ? extracted.size() : 0);
+				cdata[0] = string_t(extracted.data(), UnsafeNumericCast<uint32_t>(match ? extracted.size() : 0));
 			}
 		}
 	} else {
@@ -301,12 +302,13 @@ static void RegexExtractStructFunction(DataChunk &args, ExpressionState &state,
 			const auto idx = iunified.sel->get_index(i);
 			if (ivalidity.RowIsValid(idx)) {
 				auto str = CreateStringPiece(idata[idx]);
-				auto match = duckdb_re2::RE2::PartialMatchN(str, lstate.constant_pattern, groups.data(), groups.size());
+				auto match = duckdb_re2::RE2::PartialMatchN(str, lstate.constant_pattern, groups.data(),
+				                                            UnsafeNumericCast<int>(groups.size()));
 				for (size_t col = 0; col < child_entries.size(); ++col) {
 					auto &child_entry = child_entries[col];
 					auto cdata = FlatVector::GetData<string_t>(*child_entry);
 					auto &extracted = ws[col];
-					cdata[i] = string_t(extracted.data(), match ? extracted.size() : 0);
+					cdata[i] = string_t(extracted.data(), UnsafeNumericCast<uint32_t>(match ? extracted.size() : 0));
 				}
 			} else {
 				FlatVector::SetNull(result, i, true);

package/src/duckdb/src/function/scalar/string/suffix.cpp

@@ -23,7 +23,7 @@ static bool SuffixFunction(const string_t &str, const string_t &suffix) {
 
 	auto suffix_data = suffix.GetData();
 	auto str_data = str.GetData();
-	int32_t suf_idx = suffix_size - 1;
+	auto suf_idx = UnsafeNumericCast<int32_t>(suffix_size) - 1;
 	idx_t str_idx = str_size - 1;
 	for (; suf_idx >= 0; --suf_idx, --str_idx) {
 		if (suffix_data[suf_idx] != str_data[str_idx]) {

package/src/duckdb/src/function/scalar/string/ub_duckdb_func_string.cpp

@@ -0,0 +1,31 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/function/scalar/string/ascii.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/bar.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/chr.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/reverse.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/caseconvert.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/concat.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/length.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/like.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/md5.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/nfc_normalize.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/printf.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/regexp.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/substring.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/instr.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/pad.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/prefix.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/repeat.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/replace.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/strip_accents.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/suffix.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/translate.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/trim.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/left_right.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/contains.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/starts_with.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/string_split.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/mismatches.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/levenshtein.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/jaccard.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/jaro_winkler.cpp>

package/src/duckdb/src/function/scalar/string/ub_duckdb_func_string_main.cpp

@@ -0,0 +1,12 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/function/scalar/string/caseconvert.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/concat.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/length.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/like.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/nfc_normalize.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/regexp.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/substring.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/prefix.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/strip_accents.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/suffix.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string/contains.cpp>

package/src/duckdb/src/function/scalar/struct/ub_duckdb_func_struct.cpp

@@ -0,0 +1,4 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/function/scalar/struct/struct_extract.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/struct/struct_pack.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/struct/struct_insert.cpp>

package/src/duckdb/src/function/scalar/struct/ub_duckdb_func_struct_main.cpp

@@ -0,0 +1,2 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/function/scalar/struct/struct_extract.cpp>

package/src/duckdb/src/function/scalar/system/ub_duckdb_func_system.cpp

@@ -0,0 +1,2 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/function/scalar/system/aggregate_export.cpp>

package/src/duckdb/src/function/scalar/ub_duckdb_func_scalar.cpp

@@ -0,0 +1,9 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/function/scalar/compressed_materialization_functions.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/generic_functions.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/string_functions.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/strftime_format.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/nested_functions.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/operators.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/pragma_functions.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/sequence_functions.cpp>

package/src/duckdb/src/function/scalar/union/ub_duckdb_func_union.cpp

@@ -0,0 +1,4 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/function/scalar/union/union_extract.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/union/union_tag.cpp>
+#include </Users/carlo/duckdb/src/function/scalar/union/union_value.cpp>

package/src/duckdb/src/function/table/arrow/arrow_array_scan_state.cpp

@@ -1,8 +1,11 @@
 #include "duckdb/function/table/arrow.hpp"
+#include "duckdb/common/printer.hpp"
+#include "duckdb/common/types/arrow_aux_data.hpp"
 
 namespace duckdb {
 
 ArrowArrayScanState::ArrowArrayScanState(ArrowScanLocalState &state) : state(state) {
+	arrow_dictionary = nullptr;
 }
 
 ArrowArrayScanState &ArrowArrayScanState::GetChild(idx_t child_idx) {
@@ -10,20 +13,43 @@ ArrowArrayScanState &ArrowArrayScanState::GetChild(idx_t child_idx) {
 	if (it == children.end()) {
 		auto child_p = make_uniq<ArrowArrayScanState>(state);
 		auto &child = *child_p;
+		child.owned_data = owned_data;
 		children.emplace(std::make_pair(child_idx, std::move(child_p)));
 		return child;
 	}
+	if (!it->second->owned_data) {
+		// Propagate down the ownership, for dictionaries in children
+		D_ASSERT(owned_data);
+		it->second->owned_data = owned_data;
+	}
 	return *it->second;
 }
 
-void ArrowArrayScanState::AddDictionary(unique_ptr<Vector> dictionary_p) {
-	this->dictionary = std::move(dictionary_p);
+void ArrowArrayScanState::AddDictionary(unique_ptr<Vector> dictionary_p, ArrowArray *arrow_dict) {
+	dictionary = std::move(dictionary_p);
+	D_ASSERT(owned_data);
+	D_ASSERT(arrow_dict);
+	arrow_dictionary = arrow_dict;
+	// Make sure the data referenced by the dictionary stays alive
+	dictionary->GetBuffer()->SetAuxiliaryData(make_uniq<ArrowAuxiliaryData>(owned_data));
 }
 
 bool ArrowArrayScanState::HasDictionary() const {
 	return dictionary != nullptr;
 }
 
+bool ArrowArrayScanState::CacheOutdated(ArrowArray *dictionary) const {
+	if (!dictionary) {
+		// Not cached
+		return true;
+	}
+	if (dictionary == arrow_dictionary.get()) {
+		// Already cached, not outdated
+		return false;
+	}
+	return true;
+}
+
 Vector &ArrowArrayScanState::GetDictionary() {
 	D_ASSERT(HasDictionary());
 	return *dictionary;

package/src/duckdb/src/function/table/arrow/ub_duckdb_arrow_conversion.cpp

@@ -0,0 +1,2 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/function/table/arrow/arrow_duck_schema.cpp>

package/src/duckdb/src/function/table/arrow.cpp

@@ -41,13 +41,30 @@ static unique_ptr<ArrowType> GetArrowLogicalTypeNoDictionary(ArrowSchema &schema
 	} else if (format == "g") {
 		return make_uniq<ArrowType>(LogicalType::DOUBLE);
 	} else if (format[0] == 'd') { //! this can be either decimal128 or decimal 256 (e.g., d:38,0)
-		std::string parameters = format.substr(format.find(':'));
-		uint8_t width = std::stoi(parameters.substr(1, parameters.find(',')));
-		uint8_t scale = std::stoi(parameters.substr(parameters.find(',') + 1));
-		if (width > 38) {
+		auto extra_info = StringUtil::Split(format, ':');
+		if (extra_info.size() != 2) {
+			throw InvalidInputException(
+			    "Decimal format of Arrow object is incomplete, it is missing the scale and width. Current format: %s",
+			    format);
+		}
+		auto parameters = StringUtil::Split(extra_info[1], ",");
+		// Parameters must always be 2 or 3 values (i.e., width, scale and an optional bit-width)
+		if (parameters.size() != 2 && parameters.size() != 3) {
+			throw InvalidInputException(
+			    "Decimal format of Arrow object is incomplete, it is missing the scale or width. Current format: %s",
+			    format);
+		}
+		uint64_t width = std::stoull(parameters[0]);
+		uint64_t scale = std::stoull(parameters[1]);
+		uint64_t bitwidth = 128;
+		if (parameters.size() == 3) {
+			// We have a bit-width defined
+			bitwidth = std::stoull(parameters[2]);
+		}
+		if (width > 38 || bitwidth > 128) {
 			throw NotImplementedException("Unsupported Internal Arrow Type for Decimal %s", format);
 		}
-		return make_uniq<ArrowType>(LogicalType::DECIMAL(width, scale));
+		return make_uniq<ArrowType>(LogicalType::DECIMAL(NumericCast<uint8_t>(width), NumericCast<uint8_t>(scale)));
 	} else if (format == "u") {
 		return make_uniq<ArrowType>(LogicalType::VARCHAR, ArrowVariableSizeType::NORMAL);
 	} else if (format == "U") {
@@ -102,7 +119,7 @@ static unique_ptr<ArrowType> GetArrowLogicalTypeNoDictionary(ArrowSchema &schema
 		std::string parameters = format.substr(format.find(':') + 1);
 		idx_t fixed_size = std::stoi(parameters);
 		auto child_type = ArrowTableFunction::GetArrowLogicalType(*schema.children[0]);
-		auto list_type = make_uniq<ArrowType>(LogicalType::LIST(child_type->GetDuckType()), fixed_size);
+		auto list_type = make_uniq<ArrowType>(LogicalType::ARRAY(child_type->GetDuckType(), fixed_size), fixed_size);
 		list_type->AddChild(std::move(child_type));
 		return list_type;
 	} else if (format == "+s") {

package/src/duckdb/src/function/table/arrow_conversion.cpp

@@ -29,7 +29,7 @@ static void ShiftRight(unsigned char *ar, int size, int shift) {
 	while (shift--) {
 		for (int i = size - 1; i >= 0; --i) {
 			int next = (ar[i] & 1) ? 0x80 : 0;
-			ar[i] = carry | (ar[i] >> 1);
+			ar[i] = UnsafeNumericCast<unsigned char>(carry | (ar[i] >> 1));
 			carry = next;
 		}
 	}
@@ -73,7 +73,7 @@ static void GetValidityMask(ValidityMask &mask, ArrowArray &array, const ArrowSc
 			//! need to re-align nullmask
 			vector<uint8_t> temp_nullmask(n_bitmask_bytes + 1);
 			memcpy(temp_nullmask.data(), ArrowBufferData<uint8_t>(array, 0) + bit_offset / 8, n_bitmask_bytes + 1);
-			ShiftRight(temp_nullmask.data(), n_bitmask_bytes + 1,
+			ShiftRight(temp_nullmask.data(), NumericCast<int>(n_bitmask_bytes + 1),
 			           bit_offset % 8); //! why this has to be a right shift is a mystery to me
 			memcpy((void *)mask.GetData(), data_ptr_cast(temp_nullmask.data()), n_bitmask_bytes);
 		}
@@ -129,20 +129,7 @@ static void ArrowToDuckDBList(Vector &vector, ArrowArray &array, ArrowArrayScanS
 	SetValidityMask(vector, array, scan_state, size, parent_offset, nested_offset);
 	idx_t start_offset = 0;
 	idx_t cur_offset = 0;
-	if (size_type == ArrowVariableSizeType::FIXED_SIZE) {
-		auto fixed_size = arrow_type.FixedSize();
-		//! Have to check validity mask before setting this up
-		idx_t offset = GetEffectiveOffset(array, parent_offset, scan_state, nested_offset) * fixed_size;
-		start_offset = offset;
-		auto list_data = FlatVector::GetData<list_entry_t>(vector);
-		for (idx_t i = 0; i < size; i++) {
-			auto &le = list_data[i];
-			le.offset = cur_offset;
-			le.length = fixed_size;
-			cur_offset += fixed_size;
-		}
-		list_size = start_offset + cur_offset;
-	} else if (size_type == ArrowVariableSizeType::NORMAL) {
+	if (size_type == ArrowVariableSizeType::NORMAL) {
 		auto offsets =
 		    ArrowBufferData<uint32_t>(array, 1) + GetEffectiveOffset(array, parent_offset, scan_state, nested_offset);
 		start_offset = offsets[0];
@@ -209,6 +196,61 @@ static void ArrowToDuckDBList(Vector &vector, ArrowArray &array, ArrowArrayScanS
 	}
 }
 
+static void ArrowToDuckDBArray(Vector &vector, ArrowArray &array, ArrowArrayScanState &array_state, idx_t size,
+                               const ArrowType &arrow_type, int64_t nested_offset, ValidityMask *parent_mask,
+                               int64_t parent_offset) {
+
+	D_ASSERT(arrow_type.GetSizeType() == ArrowVariableSizeType::FIXED_SIZE);
+	auto &scan_state = array_state.state;
+	auto array_size = arrow_type.FixedSize();
+	auto child_count = array_size * size;
+	auto child_offset = GetEffectiveOffset(array, parent_offset, scan_state, nested_offset) * array_size;
+
+	SetValidityMask(vector, array, scan_state, size, parent_offset, nested_offset);
+
+	auto &child_vector = ArrayVector::GetEntry(vector);
+	SetValidityMask(child_vector, *array.children[0], scan_state, child_count, array.offset, child_offset);
+
+	auto &array_mask = FlatVector::Validity(vector);
+	if (parent_mask) {
+		//! Since this List is owned by a struct we must guarantee their validity map matches on Null
+		if (!parent_mask->AllValid()) {
+			for (idx_t i = 0; i < size; i++) {
+				if (!parent_mask->RowIsValid(i)) {
+					array_mask.SetInvalid(i);
+				}
+			}
+		}
+	}
+
+	// Broadcast the validity mask to the child vector
+	if (!array_mask.AllValid()) {
+		auto &child_validity_mask = FlatVector::Validity(child_vector);
+		for (idx_t i = 0; i < size; i++) {
+			if (!array_mask.RowIsValid(i)) {
+				for (idx_t j = 0; j < array_size; j++) {
+					child_validity_mask.SetInvalid(i * array_size + j);
+				}
+			}
+		}
+	}
+
+	auto &child_state = array_state.GetChild(0);
+	auto &child_array = *array.children[0];
+	auto &child_type = arrow_type[0];
+	if (child_count == 0 && child_offset == 0) {
+		D_ASSERT(!child_array.dictionary);
+		ColumnArrowToDuckDB(child_vector, child_array, child_state, child_count, child_type, -1);
+	} else {
+		if (child_array.dictionary) {
+			ColumnArrowToDuckDBDictionary(child_vector, child_array, child_state, child_count, child_type,
+			                              child_offset);
+		} else {
+			ColumnArrowToDuckDB(child_vector, child_array, child_state, child_count, child_type, child_offset);
+		}
+	}
+}
+
 static void ArrowToDuckDBBlob(Vector &vector, ArrowArray &array, const ArrowScanLocalState &scan_state, idx_t size,
                               const ArrowType &arrow_type, int64_t nested_offset, int64_t parent_offset) {
 	auto size_type = arrow_type.GetSizeType();
@@ -290,7 +332,7 @@ static void SetVectorString(Vector &vector, idx_t size, char *cdata, T *offsets)
 		if (str_len > NumericLimits<uint32_t>::Maximum()) { // LCOV_EXCL_START
 			throw ConversionException("DuckDB does not support Strings over 4GB");
 		} // LCOV_EXCL_STOP
-		strings[row_idx] = string_t(cptr, str_len);
+		strings[row_idx] = string_t(cptr, UnsafeNumericCast<uint32_t>(str_len));
 	}
 }
 
@@ -588,9 +630,6 @@ static void ColumnArrowToDuckDBRunEndEncoded(Vector &vector, ArrowArray &array,
 static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArrayScanState &array_state, idx_t size,
                                 const ArrowType &arrow_type, int64_t nested_offset, ValidityMask *parent_mask,
                                 uint64_t parent_offset) {
-	if (parent_offset != 0) {
-		(void)array_state;
-	}
 	auto &scan_state = array_state.state;
 	D_ASSERT(!array.dictionary);
 
@@ -670,7 +709,8 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca
 			               GetEffectiveOffset(array, parent_offset, scan_state, nested_offset);
 			auto tgt_ptr = FlatVector::GetData<date_t>(vector);
 			for (idx_t row = 0; row < size; row++) {
-				tgt_ptr[row] = date_t(int64_t(src_ptr[row]) / static_cast<int64_t>(1000 * 60 * 60 * 24));
+				tgt_ptr[row] = date_t(
+				    UnsafeNumericCast<int32_t>(int64_t(src_ptr[row]) / static_cast<int64_t>(1000 * 60 * 60 * 24)));
 			}
 			break;
 		}
@@ -836,6 +876,10 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca
 		ArrowToDuckDBList(vector, array, array_state, size, arrow_type, nested_offset, parent_mask, parent_offset);
 		break;
 	}
+	case LogicalTypeId::ARRAY: {
+		ArrowToDuckDBArray(vector, array, array_state, size, arrow_type, nested_offset, parent_mask, parent_offset);
+		break;
+	}
 	case LogicalTypeId::MAP: {
 		ArrowToDuckDBList(vector, array, array_state, size, arrow_type, nested_offset, parent_mask, parent_offset);
 		ArrowToDuckDBMapVerify(vector, size);
@@ -1070,10 +1114,10 @@ static bool CanContainNull(ArrowArray &array, ValidityMask *parent_mask) {
 static void ColumnArrowToDuckDBDictionary(Vector &vector, ArrowArray &array, ArrowArrayScanState &array_state,
                                           idx_t size, const ArrowType &arrow_type, int64_t nested_offset,
                                           ValidityMask *parent_mask, uint64_t parent_offset) {
+	D_ASSERT(arrow_type.HasDictionary());
 	auto &scan_state = array_state.state;
-
 	const bool has_nulls = CanContainNull(array, parent_mask);
-	if (!array_state.HasDictionary()) {
+	if (array_state.CacheOutdated(array.dictionary)) {
 		//! We need to set the dictionary data for this column
 		auto base_vector = make_uniq<Vector>(vector.GetType(), array.dictionary->length);
 		SetValidityMask(*base_vector, *array.dictionary, scan_state, array.dictionary->length, 0, 0, has_nulls);
@@ -1095,7 +1139,7 @@ static void ColumnArrowToDuckDBDictionary(Vector &vector, ArrowArray &array, Arr
 		default:
 			throw NotImplementedException("ArrowArrayPhysicalType not recognized");
 		};
-		array_state.AddDictionary(std::move(base_vector));
+		array_state.AddDictionary(std::move(base_vector), array.dictionary);
 	}
 	auto offset_type = arrow_type.GetDuckType();
 	//! Get Pointer to Indices of Dictionary
@@ -1120,6 +1164,7 @@ static void ColumnArrowToDuckDBDictionary(Vector &vector, ArrowArray &array, Arr
 		SetSelectionVector(sel, indices, offset_type, size);
 	}
 	vector.Slice(array_state.GetDictionary(), sel, size);
+	vector.Verify(size);
 }
 
 void ArrowTableFunction::ArrowToDuckDB(ArrowScanLocalState &scan_state, const arrow_column_map_t &arrow_convert_data,
@@ -1144,20 +1189,17 @@ void ArrowTableFunction::ArrowToDuckDB(ArrowScanLocalState &scan_state, const ar
 		if (array.length != scan_state.chunk->arrow_array.length) {
 			throw InvalidInputException("arrow_scan: array length mismatch");
 		}
-		// Make sure this Vector keeps the Arrow chunk alive in case we can zero-copy the data
-		if (scan_state.arrow_owned_data.find(idx) == scan_state.arrow_owned_data.end()) {
-			auto arrow_data = make_shared<ArrowArrayWrapper>();
-			arrow_data->arrow_array = scan_state.chunk->arrow_array;
-			scan_state.chunk->arrow_array.release = nullptr;
-			scan_state.arrow_owned_data[idx] = arrow_data;
-		}
-
-		output.data[idx].GetBuffer()->SetAuxiliaryData(make_uniq<ArrowAuxiliaryData>(scan_state.arrow_owned_data[idx]));
 
 		D_ASSERT(arrow_convert_data.find(col_idx) != arrow_convert_data.end());
 		auto &arrow_type = *arrow_convert_data.at(col_idx);
 		auto &array_state = scan_state.GetState(col_idx);
 
+		// Make sure this Vector keeps the Arrow chunk alive in case we can zero-copy the data
+		if (!array_state.owned_data) {
+			array_state.owned_data = scan_state.chunk;
+		}
+		output.data[idx].GetBuffer()->SetAuxiliaryData(make_uniq<ArrowAuxiliaryData>(array_state.owned_data));
+
 		auto array_physical_type = GetArrowArrayPhysicalType(arrow_type);
 
 		switch (array_physical_type) {

package/src/duckdb/src/function/table/copy_csv.cpp

@@ -7,12 +7,11 @@
 #include "duckdb/common/types/column/column_data_collection.hpp"
 #include "duckdb/common/types/string_type.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp"
+#include "duckdb/execution/operator/csv_scanner/csv_sniffer.hpp"
 #include "duckdb/function/copy_function.hpp"
 #include "duckdb/function/scalar/string_functions.hpp"
 #include "duckdb/function/table/read_csv.hpp"
 #include "duckdb/parser/parsed_data/copy_info.hpp"
-
 #include <limits>
 
 namespace duckdb {
@@ -85,6 +84,12 @@ void BaseCSVData::Finalize() {
 	}
 }
 
+string TransformNewLine(string new_line) {
+	new_line = StringUtil::Replace(new_line, "\\r", "\r");
+	return StringUtil::Replace(new_line, "\\n", "\n");
+	;
+}
+
 static unique_ptr<FunctionData> WriteCSVBind(ClientContext &context, CopyFunctionBindInput &input,
                                              const vector<string> &names, const vector<LogicalType> &sql_types) {
 	auto bind_data = make_uniq<WriteCSVData>(input.info.file_path, sql_types, names);
@@ -110,7 +115,7 @@ static unique_ptr<FunctionData> WriteCSVBind(ClientContext &context, CopyFunctio
 	bind_data->requires_quotes[bind_data->options.dialect_options.state_machine_options.quote.GetValue()] = true;
 
 	if (!bind_data->options.write_newline.empty()) {
-		bind_data->newline = bind_data->options.write_newline;
+		bind_data->newline = TransformNewLine(bind_data->options.write_newline);
 	}
 	return std::move(bind_data);
 }

package/src/duckdb/src/function/table/range.cpp

@@ -157,6 +157,11 @@ static unique_ptr<FunctionData> RangeDateTimeBind(ClientContext &context, TableF
 	auto result = make_uniq<RangeDateTimeBindData>();
 	auto &inputs = input.inputs;
 	D_ASSERT(inputs.size() == 3);
+	for (idx_t i = 0; i < inputs.size(); ++i) {
+		if (inputs[i].IsNull()) {
+			throw BinderException("RANGE with NULL argument is not supported");
+		}
+	}
 	result->start = inputs[0].GetValue<timestamp_t>();
 	result->end = inputs[1].GetValue<timestamp_t>();
 	result->increment = inputs[2].GetValue<interval_t>();

package/src/duckdb/src/function/table/read_csv.cpp

@@ -6,9 +6,9 @@
 #include "duckdb/common/serializer/serializer.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/union_by_name.hpp"
-#include "duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp"
-#include "duckdb/execution/operator/csv_scanner/table_function/global_csv_state.hpp"
-#include "duckdb/execution/operator/csv_scanner/util/csv_error.hpp"
+#include "duckdb/execution/operator/csv_scanner/global_csv_state.hpp"
+#include "duckdb/execution/operator/csv_scanner/csv_error.hpp"
+#include "duckdb/execution/operator/csv_scanner/csv_sniffer.hpp"
 #include "duckdb/execution/operator/persistent/csv_rejects_table.hpp"
 #include "duckdb/function/function_set.hpp"
 #include "duckdb/main/client_context.hpp"
@@ -20,10 +20,10 @@
 #include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/parser/tableref/table_function_ref.hpp"
 #include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/execution/operator/csv_scanner/table_function/csv_file_scanner.hpp"
-#include "duckdb/execution/operator/csv_scanner/scanner/base_scanner.hpp"
+#include "duckdb/execution/operator/csv_scanner/csv_file_scanner.hpp"
+#include "duckdb/execution/operator/csv_scanner/base_scanner.hpp"
 
-#include "duckdb/execution/operator/csv_scanner/scanner/string_value_scanner.hpp"
+#include "duckdb/execution/operator/csv_scanner/string_value_scanner.hpp"
 
 #include <limits>
 
@@ -211,8 +211,6 @@ static void ReadCSVFunction(ClientContext &context, TableFunctionInput &data_p,
 			break;
 		}
 		if (csv_local_state.csv_reader->FinishedIterator()) {
-			csv_local_state.csv_reader->csv_file_scan->error_handler->Insert(
-			    csv_local_state.csv_reader->GetBoundaryIndex(), csv_local_state.csv_reader->GetLinesRead());
 			csv_local_state.csv_reader = csv_global_state.Next();
 			if (!csv_local_state.csv_reader) {
 				csv_global_state.DecrementThread();
@@ -270,6 +268,9 @@ void ReadCSVTableFunction::ReadCSVAddNamedParameters(TableFunction &table_functi
 
 double CSVReaderProgress(ClientContext &context, const FunctionData *bind_data_p,
                          const GlobalTableFunctionState *global_state) {
+	if (!global_state) {
+		return 0;
+	}
 	auto &bind_data = bind_data_p->Cast<ReadCSVData>();
 	auto &data = global_state->Cast<CSVGlobalState>();
 	return data.GetProgress(bind_data);

package/src/duckdb/src/function/table/read_file.cpp

@@ -74,7 +74,7 @@ struct ReadFileGlobalState : public GlobalTableFunctionState {
 	ReadFileGlobalState() : current_file_idx(0) {
 	}
 
-	idx_t current_file_idx;
+	atomic<idx_t> current_file_idx;
 	vector<string> files;
 	vector<idx_t> column_ids;
 	bool requires_file_open = false;

package/src/duckdb/src/function/table/sniff_csv.cpp

@@ -1,12 +1,12 @@
 #include "duckdb/function/built_in_functions.hpp"
-#include "duckdb/execution/operator/csv_scanner/options/csv_reader_options.hpp"
+#include "duckdb/execution/operator/csv_scanner/csv_reader_options.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp"
-#include "duckdb/execution/operator/csv_scanner/buffer_manager/csv_buffer_manager.hpp"
+#include "duckdb/execution/operator/csv_scanner/csv_sniffer.hpp"
+#include "duckdb/execution/operator/csv_scanner/csv_buffer_manager.hpp"
 #include "duckdb/function/table_function.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/function/table/range.hpp"
-#include "duckdb/execution/operator/csv_scanner/buffer_manager/csv_file_handle.hpp"
+#include "duckdb/execution/operator/csv_scanner/csv_file_handle.hpp"
 #include "duckdb/function/table/read_csv.hpp"
 
 namespace duckdb {
@@ -142,7 +142,7 @@ static void CSVSniffFunction(ClientContext &context, TableFunctionInput &data_p,
 	    NewLineIdentifierToString(sniffer_options.dialect_options.state_machine_options.new_line.GetValue());
 	output.SetValue(3, 0, new_line_identifier);
 	// 5. Skip Rows
-	output.SetValue(4, 0, Value::UINTEGER(sniffer_options.dialect_options.skip_rows.GetValue()));
+	output.SetValue(4, 0, Value::UINTEGER(NumericCast<uint32_t>(sniffer_options.dialect_options.skip_rows.GetValue())));
 	// 6. Has Header
 	auto has_header = Value::BOOLEAN(sniffer_options.dialect_options.header.GetValue()).ToString();
 	output.SetValue(5, 0, has_header);