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

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

@@ -40,9 +40,9 @@ string_t SubstringEmptyString(Vector &result) {
 }
 
 string_t SubstringSlice(Vector &result, const char *input_data, int64_t offset, int64_t length) {
-	auto result_string = StringVector::EmptyString(result, length);
+	auto result_string = StringVector::EmptyString(result, UnsafeNumericCast<idx_t>(length));
 	auto result_data = result_string.GetDataWriteable();
-	memcpy(result_data, input_data + offset, length);
+	memcpy(result_data, input_data + offset, UnsafeNumericCast<size_t>(length));
 	result_string.Finalize();
 	return result_string;
 }
@@ -88,10 +88,10 @@ string_t SubstringASCII(Vector &result, string_t input, int64_t offset, int64_t
 	AssertInSupportedRange(input_size, offset, length);
 
 	int64_t start, end;
-	if (!SubstringStartEnd(input_size, offset, length, start, end)) {
+	if (!SubstringStartEnd(UnsafeNumericCast<int64_t>(input_size), offset, length, start, end)) {
 		return SubstringEmptyString(result);
 	}
-	return SubstringSlice(result, input_data, start, end - start);
+	return SubstringSlice(result, input_data, start, UnsafeNumericCast<int64_t>(end - start));
 }
 
 string_t SubstringFun::SubstringUnicode(Vector &result, string_t input, int64_t offset, int64_t length) {
@@ -186,7 +186,8 @@ string_t SubstringFun::SubstringUnicode(Vector &result, string_t input, int64_t
 	}
 	D_ASSERT(end_pos >= start_pos);
 	// after we have found these, we can slice the substring
-	return SubstringSlice(result, input_data, start_pos, end_pos - start_pos);
+	return SubstringSlice(result, input_data, UnsafeNumericCast<int64_t>(start_pos),
+	                      UnsafeNumericCast<int64_t>(end_pos - start_pos));
 }
 
 string_t SubstringFun::SubstringGrapheme(Vector &result, string_t input, int64_t offset, int64_t length) {
@@ -198,14 +199,14 @@ string_t SubstringFun::SubstringGrapheme(Vector &result, string_t input, int64_t
 	// we don't know yet if the substring is ascii, but we assume it is (for now)
 	// first get the start and end as if this was an ascii string
 	int64_t start, end;
-	if (!SubstringStartEnd(input_size, offset, length, start, end)) {
+	if (!SubstringStartEnd(UnsafeNumericCast<int64_t>(input_size), offset, length, start, end)) {
 		return SubstringEmptyString(result);
 	}
 
 	// now check if all the characters between 0 and end are ascii characters
 	// note that we scan one further to check for a potential combining diacritics (e.g. i + diacritic is ï)
 	bool is_ascii = true;
-	idx_t ascii_end = MinValue<idx_t>(end + 1, input_size);
+	idx_t ascii_end = MinValue<idx_t>(UnsafeNumericCast<idx_t>(end + 1), input_size);
 	for (idx_t i = 0; i < ascii_end; i++) {
 		if (input_data[i] & 0x80) {
 			// found a non-ascii character: eek
@@ -229,7 +230,7 @@ string_t SubstringFun::SubstringGrapheme(Vector &result, string_t input, int64_t
 			return true;
 		});
 		// now call substring start and end again, but with the number of unicode characters this time
-		SubstringStartEnd(num_characters, offset, length, start, end);
+		SubstringStartEnd(UnsafeNumericCast<int64_t>(num_characters), offset, length, start, end);
 	}
 
 	// now scan the graphemes of the string to find the positions of the start and end characters
@@ -249,7 +250,8 @@ string_t SubstringFun::SubstringGrapheme(Vector &result, string_t input, int64_t
 		return SubstringEmptyString(result);
 	}
 	// after we have found these, we can slice the substring
-	return SubstringSlice(result, input_data, start_pos, end_pos - start_pos);
+	return SubstringSlice(result, input_data, UnsafeNumericCast<int64_t>(start_pos),
+	                      UnsafeNumericCast<int64_t>(end_pos - start_pos));
 }
 
 struct SubstringUnicodeOp {

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

@@ -133,8 +133,8 @@ static unique_ptr<FunctionData> StructExtractBindIndex(ClientContext &context, S
 		throw BinderException("Key index %lld for struct_extract out of range - expected an index between 1 and %llu",
 		                      index, struct_children.size());
 	}
-	bound_function.return_type = struct_children[index - 1].second;
-	return make_uniq<StructExtractBindData>(index - 1);
+	bound_function.return_type = struct_children[NumericCast<idx_t>(index - 1)].second;
+	return make_uniq<StructExtractBindData>(NumericCast<idx_t>(index - 1));
 }
 
 static unique_ptr<BaseStatistics> PropagateStructExtractStats(ClientContext &context, FunctionStatisticsInput &input) {

package/src/duckdb/src/function/scalar_function.cpp

@@ -13,7 +13,8 @@ ScalarFunction::ScalarFunction(string name, vector<LogicalType> arguments, Logic
     : BaseScalarFunction(std::move(name), std::move(arguments), std::move(return_type), side_effects,
                          std::move(varargs), null_handling),
       function(std::move(function)), bind(bind), init_local_state(init_local_state), dependency(dependency),
-      statistics(statistics), bind_lambda(bind_lambda), serialize(nullptr), deserialize(nullptr) {
+      statistics(statistics), bind_lambda(bind_lambda), get_modified_databases(nullptr), serialize(nullptr),
+      deserialize(nullptr) {
 }
 
 ScalarFunction::ScalarFunction(vector<LogicalType> arguments, LogicalType return_type, scalar_function_t function,

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

@@ -10,6 +10,7 @@
 #include "duckdb/function/table_function.hpp"
 #include "duckdb/parser/parsed_data/create_table_function_info.hpp"
 #include "duckdb/function/table/arrow/arrow_duck_schema.hpp"
+#include "duckdb/parser/tableref/table_function_ref.hpp"
 #include "utf8proc_wrapper.hpp"
 
 namespace duckdb {
@@ -117,7 +118,7 @@ static unique_ptr<ArrowType> GetArrowLogicalTypeNoDictionary(ArrowSchema &schema
 		return list_type;
 	} else if (format[0] == '+' && format[1] == 'w') {
 		std::string parameters = format.substr(format.find(':') + 1);
-		idx_t fixed_size = std::stoi(parameters);
+		auto fixed_size = NumericCast<idx_t>(std::stoi(parameters));
 		auto child_type = ArrowTableFunction::GetArrowLogicalType(*schema.children[0]);
 		auto list_type = make_uniq<ArrowType>(LogicalType::ARRAY(child_type->GetDuckType(), fixed_size), fixed_size);
 		list_type->AddChild(std::move(child_type));
@@ -204,7 +205,7 @@ static unique_ptr<ArrowType> GetArrowLogicalTypeNoDictionary(ArrowSchema &schema
 		return make_uniq<ArrowType>(LogicalType::BLOB, ArrowVariableSizeType::SUPER_SIZE);
 	} else if (format[0] == 'w') {
 		std::string parameters = format.substr(format.find(':') + 1);
-		idx_t fixed_size = std::stoi(parameters);
+		auto fixed_size = NumericCast<idx_t>(std::stoi(parameters));
 		return make_uniq<ArrowType>(LogicalType::BLOB, fixed_size);
 	} else if (format[0] == 't' && format[1] == 's') {
 		// Timestamp with Timezone
@@ -257,18 +258,30 @@ unique_ptr<FunctionData> ArrowTableFunction::ArrowScanBind(ClientContext &contex
 	if (input.inputs[0].IsNull() || input.inputs[1].IsNull() || input.inputs[2].IsNull()) {
 		throw BinderException("arrow_scan: pointers cannot be null");
 	}
+	auto &ref = input.ref;
+
+	shared_ptr<DependencyItem> dependency;
+	if (ref.external_dependency) {
+		// This was created during the replacement scan for Python (see python_replacement_scan.cpp)
+		// this object is the owning reference to 'stream_factory_ptr' and has to be kept alive.
+		dependency = ref.external_dependency->GetDependency("replacement_cache");
+		D_ASSERT(dependency);
+	}
 
 	auto stream_factory_ptr = input.inputs[0].GetPointer();
 	auto stream_factory_produce = (stream_factory_produce_t)input.inputs[1].GetPointer();       // NOLINT
 	auto stream_factory_get_schema = (stream_factory_get_schema_t)input.inputs[2].GetPointer(); // NOLINT
 
-	auto res = make_uniq<ArrowScanFunctionData>(stream_factory_produce, stream_factory_ptr);
+	auto res = make_uniq<ArrowScanFunctionData>(stream_factory_produce, stream_factory_ptr, std::move(dependency));
 
 	auto &data = *res;
 	stream_factory_get_schema(reinterpret_cast<ArrowArrayStream *>(stream_factory_ptr), data.schema_root.arrow_schema);
 	PopulateArrowTableType(res->arrow_table, data.schema_root, names, return_types);
 	QueryResult::DeduplicateColumns(names);
 	res->all_types = return_types;
+	if (return_types.empty()) {
+		throw InvalidInputException("Provided table/dataframe must have at least one column");
+	}
 	return std::move(res);
 }
 
@@ -373,7 +386,8 @@ void ArrowTableFunction::ArrowScanFunction(ClientContext &context, TableFunction
 			return;
 		}
 	}
-	int64_t output_size = MinValue<int64_t>(STANDARD_VECTOR_SIZE, state.chunk->arrow_array.length - state.chunk_offset);
+	auto output_size =
+	    MinValue<idx_t>(STANDARD_VECTOR_SIZE, NumericCast<idx_t>(state.chunk->arrow_array.length) - state.chunk_offset);
 	data.lines_read += output_size;
 	if (global_state.CanRemoveFilterColumns()) {
 		state.all_columns.Reset();

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

@@ -40,12 +40,12 @@ idx_t GetEffectiveOffset(ArrowArray &array, int64_t parent_offset, const ArrowSc
 	if (nested_offset != -1) {
 		// The parent of this array is a list
 		// We just ignore the parent offset, it's already applied to the list
-		return array.offset + nested_offset;
+		return UnsafeNumericCast<idx_t>(array.offset + nested_offset);
 	}
 	// Parent offset is set in the case of a struct, it applies to all child arrays
 	// 'chunk_offset' is how much of the chunk we've already scanned, in case the chunk size exceeds
 	// STANDARD_VECTOR_SIZE
-	return array.offset + parent_offset + state.chunk_offset;
+	return UnsafeNumericCast<idx_t>(array.offset + parent_offset) + state.chunk_offset;
 }
 
 template <class T>
@@ -158,7 +158,8 @@ static void ArrowToDuckDBList(Vector &vector, ArrowArray &array, ArrowArrayScanS
 	ListVector::Reserve(vector, list_size);
 	ListVector::SetListSize(vector, list_size);
 	auto &child_vector = ListVector::GetEntry(vector);
-	SetValidityMask(child_vector, *array.children[0], scan_state, list_size, array.offset, start_offset);
+	SetValidityMask(child_vector, *array.children[0], scan_state, list_size, array.offset,
+	                NumericCast<int64_t>(start_offset));
 	auto &list_mask = FlatVector::Validity(vector);
 	if (parent_mask) {
 		//! Since this List is owned by a struct we must guarantee their validity map matches on Null
@@ -183,13 +184,16 @@ static void ArrowToDuckDBList(Vector &vector, ArrowArray &array, ArrowArrayScanS
 	switch (array_physical_type) {
 	case ArrowArrayPhysicalType::DICTIONARY_ENCODED:
 		// TODO: add support for offsets
-		ColumnArrowToDuckDBDictionary(child_vector, child_array, child_state, list_size, child_type, start_offset);
+		ColumnArrowToDuckDBDictionary(child_vector, child_array, child_state, list_size, child_type,
+		                              NumericCast<int64_t>(start_offset));
 		break;
 	case ArrowArrayPhysicalType::RUN_END_ENCODED:
-		ColumnArrowToDuckDBRunEndEncoded(child_vector, child_array, child_state, list_size, child_type, start_offset);
+		ColumnArrowToDuckDBRunEndEncoded(child_vector, child_array, child_state, list_size, child_type,
+		                                 NumericCast<int64_t>(start_offset));
 		break;
 	case ArrowArrayPhysicalType::DEFAULT:
-		ColumnArrowToDuckDB(child_vector, child_array, child_state, list_size, child_type, start_offset);
+		ColumnArrowToDuckDB(child_vector, child_array, child_state, list_size, child_type,
+		                    NumericCast<int64_t>(start_offset));
 		break;
 	default:
 		throw NotImplementedException("ArrowArrayPhysicalType not recognized");
@@ -209,7 +213,8 @@ static void ArrowToDuckDBArray(Vector &vector, ArrowArray &array, ArrowArrayScan
 	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);
+	SetValidityMask(child_vector, *array.children[0], scan_state, child_count, array.offset,
+	                NumericCast<int64_t>(child_offset));
 
 	auto &array_mask = FlatVector::Validity(vector);
 	if (parent_mask) {
@@ -244,9 +249,10 @@ static void ArrowToDuckDBArray(Vector &vector, ArrowArray &array, ArrowArrayScan
 	} else {
 		if (child_array.dictionary) {
 			ColumnArrowToDuckDBDictionary(child_vector, child_array, child_state, child_count, child_type,
-			                              child_offset);
+			                              NumericCast<int64_t>(child_offset));
 		} else {
-			ColumnArrowToDuckDB(child_vector, child_array, child_state, child_count, child_type, child_offset);
+			ColumnArrowToDuckDB(child_vector, child_array, child_state, child_count, child_type,
+			                    NumericCast<int64_t>(child_offset));
 		}
 	}
 }
@@ -311,9 +317,6 @@ static void ArrowToDuckDBMapVerify(Vector &vector, idx_t count) {
 	case MapInvalidReason::NULL_KEY: {
 		throw InvalidInputException("Arrow map contains NULL as map key, which isn't supported by DuckDB map type");
 	}
-	case MapInvalidReason::NULL_KEY_LIST: {
-		throw InvalidInputException("Arrow map contains NULL as key list, which isn't supported by DuckDB map type");
-	}
 	default: {
 		throw InternalException("MapInvalidReason not implemented");
 	}
@@ -339,8 +342,9 @@ static void SetVectorString(Vector &vector, idx_t size, char *cdata, T *offsets)
 static void DirectConversion(Vector &vector, ArrowArray &array, const ArrowScanLocalState &scan_state,
                              int64_t nested_offset, uint64_t parent_offset) {
 	auto internal_type = GetTypeIdSize(vector.GetType().InternalType());
-	auto data_ptr = ArrowBufferData<data_t>(array, 1) +
-	                internal_type * GetEffectiveOffset(array, parent_offset, scan_state, nested_offset);
+	auto data_ptr =
+	    ArrowBufferData<data_t>(array, 1) +
+	    internal_type * GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset);
 	FlatVector::SetData(vector, data_ptr);
 }
 
@@ -595,7 +599,7 @@ static void ColumnArrowToDuckDBRunEndEncoded(Vector &vector, ArrowArray &array,
 	auto &scan_state = array_state.state;
 
 	D_ASSERT(run_ends_array.length == values_array.length);
-	auto compressed_size = run_ends_array.length;
+	auto compressed_size = NumericCast<idx_t>(run_ends_array.length);
 	// Create a vector for the run ends and the values
 	auto &run_end_encoding = array_state.RunEndEncoding();
 	if (!run_end_encoding.run_ends) {
@@ -606,11 +610,12 @@ static void ColumnArrowToDuckDBRunEndEncoded(Vector &vector, ArrowArray &array,
 
 		ColumnArrowToDuckDB(*run_end_encoding.run_ends, run_ends_array, array_state, compressed_size, run_ends_type);
 		auto &values = *run_end_encoding.values;
-		SetValidityMask(values, values_array, scan_state, compressed_size, parent_offset, nested_offset);
+		SetValidityMask(values, values_array, scan_state, compressed_size, NumericCast<int64_t>(parent_offset),
+		                nested_offset);
 		ColumnArrowToDuckDB(values, values_array, array_state, compressed_size, values_type);
 	}
 
-	idx_t scan_offset = GetEffectiveOffset(array, parent_offset, scan_state, nested_offset);
+	idx_t scan_offset = GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset);
 	auto physical_type = run_ends_type.GetDuckType().InternalType();
 	switch (physical_type) {
 	case PhysicalType::INT16:
@@ -641,12 +646,12 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca
 		//! Arrow bit-packs boolean values
 		//! Lets first figure out where we are in the source array
 		auto src_ptr = ArrowBufferData<uint8_t>(array, 1) +
-		               GetEffectiveOffset(array, parent_offset, scan_state, nested_offset) / 8;
+		               GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset) / 8;
 		auto tgt_ptr = (uint8_t *)FlatVector::GetData(vector);
 		int src_pos = 0;
 		idx_t cur_bit = scan_state.chunk_offset % 8;
 		if (nested_offset != -1) {
-			cur_bit = nested_offset % 8;
+			cur_bit = NumericCast<idx_t>(nested_offset % 8);
 		}
 		for (idx_t row = 0; row < size; row++) {
 			if ((src_ptr[src_pos] & (1 << cur_bit)) == 0) {
@@ -686,11 +691,11 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca
 		auto cdata = ArrowBufferData<char>(array, 2);
 		if (size_type == ArrowVariableSizeType::SUPER_SIZE) {
 			auto offsets = ArrowBufferData<uint64_t>(array, 1) +
-			               GetEffectiveOffset(array, parent_offset, scan_state, nested_offset);
+			               GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset);
 			SetVectorString(vector, size, cdata, offsets);
 		} else {
 			auto offsets = ArrowBufferData<uint32_t>(array, 1) +
-			               GetEffectiveOffset(array, parent_offset, scan_state, nested_offset);
+			               GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset);
 			SetVectorString(vector, size, cdata, offsets);
 		}
 		break;
@@ -706,7 +711,7 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca
 		case ArrowDateTimeType::MILLISECONDS: {
 			//! convert date from nanoseconds to days
 			auto src_ptr = ArrowBufferData<uint64_t>(array, 1) +
-			               GetEffectiveOffset(array, parent_offset, scan_state, nested_offset);
+			               GetEffectiveOffset(array, NumericCast<int64_t>(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(
@@ -723,21 +728,24 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca
 		auto precision = arrow_type.GetDateTimeType();
 		switch (precision) {
 		case ArrowDateTimeType::SECONDS: {
-			TimeConversion<int32_t>(vector, array, scan_state, nested_offset, parent_offset, size, 1000000);
+			TimeConversion<int32_t>(vector, array, scan_state, nested_offset, NumericCast<int64_t>(parent_offset), size,
+			                        1000000);
 			break;
 		}
 		case ArrowDateTimeType::MILLISECONDS: {
-			TimeConversion<int32_t>(vector, array, scan_state, nested_offset, parent_offset, size, 1000);
+			TimeConversion<int32_t>(vector, array, scan_state, nested_offset, NumericCast<int64_t>(parent_offset), size,
+			                        1000);
 			break;
 		}
 		case ArrowDateTimeType::MICROSECONDS: {
-			TimeConversion<int64_t>(vector, array, scan_state, nested_offset, parent_offset, size, 1);
+			TimeConversion<int64_t>(vector, array, scan_state, nested_offset, NumericCast<int64_t>(parent_offset), size,
+			                        1);
 			break;
 		}
 		case ArrowDateTimeType::NANOSECONDS: {
 			auto tgt_ptr = FlatVector::GetData<dtime_t>(vector);
 			auto src_ptr = ArrowBufferData<int64_t>(array, 1) +
-			               GetEffectiveOffset(array, parent_offset, scan_state, nested_offset);
+			               GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset);
 			for (idx_t row = 0; row < size; row++) {
 				tgt_ptr[row].micros = src_ptr[row] / 1000;
 			}
@@ -752,11 +760,13 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca
 		auto precision = arrow_type.GetDateTimeType();
 		switch (precision) {
 		case ArrowDateTimeType::SECONDS: {
-			TimestampTZConversion(vector, array, scan_state, nested_offset, parent_offset, size, 1000000);
+			TimestampTZConversion(vector, array, scan_state, nested_offset, NumericCast<int64_t>(parent_offset), size,
+			                      1000000);
 			break;
 		}
 		case ArrowDateTimeType::MILLISECONDS: {
-			TimestampTZConversion(vector, array, scan_state, nested_offset, parent_offset, size, 1000);
+			TimestampTZConversion(vector, array, scan_state, nested_offset, NumericCast<int64_t>(parent_offset), size,
+			                      1000);
 			break;
 		}
 		case ArrowDateTimeType::MICROSECONDS: {
@@ -766,7 +776,7 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca
 		case ArrowDateTimeType::NANOSECONDS: {
 			auto tgt_ptr = FlatVector::GetData<timestamp_t>(vector);
 			auto src_ptr = ArrowBufferData<int64_t>(array, 1) +
-			               GetEffectiveOffset(array, parent_offset, scan_state, nested_offset);
+			               GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset);
 			for (idx_t row = 0; row < size; row++) {
 				tgt_ptr[row].value = src_ptr[row] / 1000;
 			}
@@ -781,22 +791,25 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca
 		auto precision = arrow_type.GetDateTimeType();
 		switch (precision) {
 		case ArrowDateTimeType::SECONDS: {
-			IntervalConversionUs(vector, array, scan_state, nested_offset, parent_offset, size, 1000000);
+			IntervalConversionUs(vector, array, scan_state, nested_offset, NumericCast<int64_t>(parent_offset), size,
+			                     1000000);
 			break;
 		}
 		case ArrowDateTimeType::DAYS:
 		case ArrowDateTimeType::MILLISECONDS: {
-			IntervalConversionUs(vector, array, scan_state, nested_offset, parent_offset, size, 1000);
+			IntervalConversionUs(vector, array, scan_state, nested_offset, NumericCast<int64_t>(parent_offset), size,
+			                     1000);
 			break;
 		}
 		case ArrowDateTimeType::MICROSECONDS: {
-			IntervalConversionUs(vector, array, scan_state, nested_offset, parent_offset, size, 1);
+			IntervalConversionUs(vector, array, scan_state, nested_offset, NumericCast<int64_t>(parent_offset), size,
+			                     1);
 			break;
 		}
 		case ArrowDateTimeType::NANOSECONDS: {
 			auto tgt_ptr = FlatVector::GetData<interval_t>(vector);
 			auto src_ptr = ArrowBufferData<int64_t>(array, 1) +
-			               GetEffectiveOffset(array, parent_offset, scan_state, nested_offset);
+			               GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset);
 			for (idx_t row = 0; row < size; row++) {
 				tgt_ptr[row].micros = src_ptr[row] / 1000;
 				tgt_ptr[row].days = 0;
@@ -805,11 +818,13 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca
 			break;
 		}
 		case ArrowDateTimeType::MONTHS: {
-			IntervalConversionMonths(vector, array, scan_state, nested_offset, parent_offset, size);
+			IntervalConversionMonths(vector, array, scan_state, nested_offset, NumericCast<int64_t>(parent_offset),
+			                         size);
 			break;
 		}
 		case ArrowDateTimeType::MONTH_DAY_NANO: {
-			IntervalConversionMonthDayNanos(vector, array, scan_state, nested_offset, parent_offset, size);
+			IntervalConversionMonthDayNanos(vector, array, scan_state, nested_offset,
+			                                NumericCast<int64_t>(parent_offset), size);
 			break;
 		}
 		default:
@@ -820,8 +835,8 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca
 	case LogicalTypeId::DECIMAL: {
 		auto val_mask = FlatVector::Validity(vector);
 		//! We have to convert from INT128
-		auto src_ptr =
-		    ArrowBufferData<hugeint_t>(array, 1) + GetEffectiveOffset(array, parent_offset, scan_state, nested_offset);
+		auto src_ptr = ArrowBufferData<hugeint_t>(array, 1) +
+		               GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset);
 		switch (vector.GetType().InternalType()) {
 		case PhysicalType::INT16: {
 			auto tgt_ptr = FlatVector::GetData<int16_t>(vector);
@@ -859,7 +874,8 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca
 		case PhysicalType::INT128: {
 			FlatVector::SetData(vector, ArrowBufferData<data_t>(array, 1) +
 			                                GetTypeIdSize(vector.GetType().InternalType()) *
-			                                    GetEffectiveOffset(array, parent_offset, scan_state, nested_offset));
+			                                    GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset),
+			                                                       scan_state, nested_offset));
 			break;
 		}
 		default:
@@ -869,19 +885,23 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca
 		break;
 	}
 	case LogicalTypeId::BLOB: {
-		ArrowToDuckDBBlob(vector, array, scan_state, size, arrow_type, nested_offset, parent_offset);
+		ArrowToDuckDBBlob(vector, array, scan_state, size, arrow_type, nested_offset,
+		                  NumericCast<int64_t>(parent_offset));
 		break;
 	}
 	case LogicalTypeId::LIST: {
-		ArrowToDuckDBList(vector, array, array_state, size, arrow_type, nested_offset, parent_mask, parent_offset);
+		ArrowToDuckDBList(vector, array, array_state, size, arrow_type, nested_offset, parent_mask,
+		                  NumericCast<int64_t>(parent_offset));
 		break;
 	}
 	case LogicalTypeId::ARRAY: {
-		ArrowToDuckDBArray(vector, array, array_state, size, arrow_type, nested_offset, parent_mask, parent_offset);
+		ArrowToDuckDBArray(vector, array, array_state, size, arrow_type, nested_offset, parent_mask,
+		                   NumericCast<int64_t>(parent_offset));
 		break;
 	}
 	case LogicalTypeId::MAP: {
-		ArrowToDuckDBList(vector, array, array_state, size, arrow_type, nested_offset, parent_mask, parent_offset);
+		ArrowToDuckDBList(vector, array, array_state, size, arrow_type, nested_offset, parent_mask,
+		                  NumericCast<int64_t>(parent_offset));
 		ArrowToDuckDBMapVerify(vector, size);
 		break;
 	}
@@ -889,7 +909,7 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca
 		//! Fill the children
 		auto &child_entries = StructVector::GetEntries(vector);
 		auto &struct_validity_mask = FlatVector::Validity(vector);
-		for (int64_t child_idx = 0; child_idx < array.n_children; child_idx++) {
+		for (idx_t child_idx = 0; child_idx < NumericCast<idx_t>(array.n_children); child_idx++) {
 			auto &child_entry = *child_entries[child_idx];
 			auto &child_array = *array.children[child_idx];
 			auto &child_type = arrow_type[child_idx];
@@ -909,15 +929,15 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca
 			switch (array_physical_type) {
 			case ArrowArrayPhysicalType::DICTIONARY_ENCODED:
 				ColumnArrowToDuckDBDictionary(child_entry, child_array, child_state, size, child_type, nested_offset,
-				                              &struct_validity_mask, array.offset);
+				                              &struct_validity_mask, NumericCast<uint64_t>(array.offset));
 				break;
 			case ArrowArrayPhysicalType::RUN_END_ENCODED:
 				ColumnArrowToDuckDBRunEndEncoded(child_entry, child_array, child_state, size, child_type, nested_offset,
-				                                 &struct_validity_mask, array.offset);
+				                                 &struct_validity_mask, NumericCast<uint64_t>(array.offset));
 				break;
 			case ArrowArrayPhysicalType::DEFAULT:
 				ColumnArrowToDuckDB(child_entry, child_array, child_state, size, child_type, nested_offset,
-				                    &struct_validity_mask, array.offset);
+				                    &struct_validity_mask, NumericCast<uint64_t>(array.offset));
 				break;
 			default:
 				throw NotImplementedException("ArrowArrayPhysicalType not recognized");
@@ -933,13 +953,13 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca
 		auto &validity_mask = FlatVector::Validity(vector);
 
 		duckdb::vector<Vector> children;
-		for (int64_t child_idx = 0; child_idx < array.n_children; child_idx++) {
+		for (idx_t child_idx = 0; child_idx < NumericCast<idx_t>(array.n_children); child_idx++) {
 			Vector child(members[child_idx].second, size);
 			auto &child_array = *array.children[child_idx];
 			auto &child_state = array_state.GetChild(child_idx);
 			auto &child_type = arrow_type[child_idx];
 
-			SetValidityMask(child, child_array, scan_state, size, parent_offset, nested_offset);
+			SetValidityMask(child, child_array, scan_state, size, NumericCast<int64_t>(parent_offset), nested_offset);
 			auto array_physical_type = GetArrowArrayPhysicalType(child_type);
 
 			switch (array_physical_type) {
@@ -960,9 +980,9 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca
 		}
 
 		for (idx_t row_idx = 0; row_idx < size; row_idx++) {
-			auto tag = type_ids[row_idx];
+			auto tag = NumericCast<uint8_t>(type_ids[row_idx]);
 
-			auto out_of_range = tag < 0 || tag >= array.n_children;
+			auto out_of_range = tag >= array.n_children;
 			if (out_of_range) {
 				throw InvalidInputException("Arrow union tag out of range: %d", tag);
 			}
@@ -982,7 +1002,7 @@ template <class T>
 static void SetSelectionVectorLoop(SelectionVector &sel, data_ptr_t indices_p, idx_t size) {
 	auto indices = reinterpret_cast<T *>(indices_p);
 	for (idx_t row = 0; row < size; row++) {
-		sel.set_index(row, indices[row]);
+		sel.set_index(row, UnsafeNumericCast<idx_t>(indices[row]));
 	}
 }
 
@@ -994,7 +1014,7 @@ static void SetSelectionVectorLoopWithChecks(SelectionVector &sel, data_ptr_t in
 		if (indices[row] > NumericLimits<uint32_t>::Maximum()) {
 			throw ConversionException("DuckDB only supports indices that fit on an uint32");
 		}
-		sel.set_index(row, indices[row]);
+		sel.set_index(row, NumericCast<idx_t>(indices[row]));
 	}
 }
 
@@ -1004,7 +1024,7 @@ static void SetMaskedSelectionVectorLoop(SelectionVector &sel, data_ptr_t indice
 	auto indices = reinterpret_cast<T *>(indices_p);
 	for (idx_t row = 0; row < size; row++) {
 		if (mask.RowIsValid(row)) {
-			sel.set_index(row, indices[row]);
+			sel.set_index(row, UnsafeNumericCast<idx_t>(indices[row]));
 		} else {
 			//! Need to point out to last element
 			sel.set_index(row, last_element_pos);
@@ -1119,22 +1139,23 @@ static void ColumnArrowToDuckDBDictionary(Vector &vector, ArrowArray &array, Arr
 	const bool has_nulls = CanContainNull(array, parent_mask);
 	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);
+		auto base_vector = make_uniq<Vector>(vector.GetType(), NumericCast<idx_t>(array.dictionary->length));
+		SetValidityMask(*base_vector, *array.dictionary, scan_state, NumericCast<idx_t>(array.dictionary->length), 0, 0,
+		                has_nulls);
 		auto &dictionary_type = arrow_type.GetDictionary();
 		auto arrow_physical_type = GetArrowArrayPhysicalType(dictionary_type);
 		switch (arrow_physical_type) {
 		case ArrowArrayPhysicalType::DICTIONARY_ENCODED:
-			ColumnArrowToDuckDBDictionary(*base_vector, *array.dictionary, array_state, array.dictionary->length,
-			                              dictionary_type);
+			ColumnArrowToDuckDBDictionary(*base_vector, *array.dictionary, array_state,
+			                              NumericCast<idx_t>(array.dictionary->length), dictionary_type);
 			break;
 		case ArrowArrayPhysicalType::RUN_END_ENCODED:
-			ColumnArrowToDuckDBRunEndEncoded(*base_vector, *array.dictionary, array_state, array.dictionary->length,
-			                                 dictionary_type);
+			ColumnArrowToDuckDBRunEndEncoded(*base_vector, *array.dictionary, array_state,
+			                                 NumericCast<idx_t>(array.dictionary->length), dictionary_type);
 			break;
 		case ArrowArrayPhysicalType::DEFAULT:
-			ColumnArrowToDuckDB(*base_vector, *array.dictionary, array_state, array.dictionary->length,
-			                    dictionary_type);
+			ColumnArrowToDuckDB(*base_vector, *array.dictionary, array_state,
+			                    NumericCast<idx_t>(array.dictionary->length), dictionary_type);
 			break;
 		default:
 			throw NotImplementedException("ArrowArrayPhysicalType not recognized");
@@ -1143,14 +1164,14 @@ static void ColumnArrowToDuckDBDictionary(Vector &vector, ArrowArray &array, Arr
 	}
 	auto offset_type = arrow_type.GetDuckType();
 	//! Get Pointer to Indices of Dictionary
-	auto indices =
-	    ArrowBufferData<data_t>(array, 1) +
-	    GetTypeIdSize(offset_type.InternalType()) * GetEffectiveOffset(array, parent_offset, scan_state, nested_offset);
+	auto indices = ArrowBufferData<data_t>(array, 1) +
+	               GetTypeIdSize(offset_type.InternalType()) *
+	                   GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset);
 
 	SelectionVector sel;
 	if (has_nulls) {
 		ValidityMask indices_validity;
-		GetValidityMask(indices_validity, array, scan_state, size, parent_offset);
+		GetValidityMask(indices_validity, array, scan_state, size, NumericCast<int64_t>(parent_offset));
 		if (parent_mask && !parent_mask->AllValid()) {
 			auto &struct_validity_mask = *parent_mask;
 			for (idx_t i = 0; i < size; i++) {
@@ -1159,7 +1180,8 @@ static void ColumnArrowToDuckDBDictionary(Vector &vector, ArrowArray &array, Arr
 				}
 			}
 		}
-		SetSelectionVector(sel, indices, offset_type, size, &indices_validity, array.dictionary->length);
+		SetSelectionVector(sel, indices, offset_type, size, &indices_validity,
+		                   NumericCast<idx_t>(array.dictionary->length));
 	} else {
 		SetSelectionVector(sel, indices, offset_type, size);
 	}