duckdb 1.3.2 → 1.3.3-dev4.0

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

@@ -13,22 +13,6 @@
 
 namespace duckdb {
 
-namespace {
-
-enum class ArrowArrayPhysicalType : uint8_t { DICTIONARY_ENCODED, RUN_END_ENCODED, DEFAULT };
-
-ArrowArrayPhysicalType GetArrowArrayPhysicalType(const ArrowType &type) {
-	if (type.HasDictionary()) {
-		return ArrowArrayPhysicalType::DICTIONARY_ENCODED;
-	}
-	if (type.RunEndEncoded()) {
-		return ArrowArrayPhysicalType::RUN_END_ENCODED;
-	}
-	return ArrowArrayPhysicalType::DEFAULT;
-}
-
-} // namespace
-
 #if STANDARD_VECTOR_SIZE > 64
 static void ShiftRight(unsigned char *ar, int size, int shift) {
 	int carry = 0;
@@ -42,7 +26,7 @@ static void ShiftRight(unsigned char *ar, int size, int shift) {
 }
 #endif
 
-idx_t GetEffectiveOffset(const ArrowArray &array, int64_t parent_offset, const ArrowScanLocalState &state,
+idx_t GetEffectiveOffset(const ArrowArray &array, int64_t parent_offset, idx_t chunk_offset,
                          int64_t nested_offset = -1) {
 	if (nested_offset != -1) {
 		// The parent of this array is a list
@@ -52,7 +36,7 @@ idx_t GetEffectiveOffset(const ArrowArray &array, int64_t parent_offset, const A
 	// 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 UnsafeNumericCast<idx_t>(array.offset + parent_offset) + state.chunk_offset;
+	return UnsafeNumericCast<idx_t>(array.offset + parent_offset) + chunk_offset;
 }
 
 template <class T>
@@ -60,7 +44,7 @@ T *ArrowBufferData(ArrowArray &array, idx_t buffer_idx) {
 	return (T *)array.buffers[buffer_idx]; // NOLINT
 }
 
-static void GetValidityMask(ValidityMask &mask, ArrowArray &array, const ArrowScanLocalState &scan_state, idx_t size,
+static void GetValidityMask(ValidityMask &mask, ArrowArray &array, idx_t chunk_offset, idx_t size,
                             int64_t parent_offset, int64_t nested_offset = -1, bool add_null = false) {
 	// In certains we don't need to or cannot copy arrow's validity mask to duckdb.
 	//
@@ -69,7 +53,7 @@ static void GetValidityMask(ValidityMask &mask, ArrowArray &array, const ArrowSc
 	// 2. n_buffers > 0, meaning the array's arrow type is not `null`
 	// 3. the validity buffer (the first buffer) is not a nullptr
 	if (array.null_count != 0 && array.n_buffers > 0 && array.buffers[0]) {
-		auto bit_offset = GetEffectiveOffset(array, parent_offset, scan_state, nested_offset);
+		auto bit_offset = GetEffectiveOffset(array, parent_offset, chunk_offset, nested_offset);
 		mask.EnsureWritable();
 #if STANDARD_VECTOR_SIZE > 64
 		auto n_bitmask_bytes = (size + 8 - 1) / 8;
@@ -107,26 +91,13 @@ static void GetValidityMask(ValidityMask &mask, ArrowArray &array, const ArrowSc
 	}
 }
 
-static void SetValidityMask(Vector &vector, ArrowArray &array, const ArrowScanLocalState &scan_state, idx_t size,
-                            int64_t parent_offset, int64_t nested_offset, bool add_null = false) {
+void ArrowToDuckDBConversion::SetValidityMask(Vector &vector, ArrowArray &array, idx_t chunk_offset, idx_t size,
+                                              int64_t parent_offset, int64_t nested_offset, bool add_null) {
 	D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR);
 	auto &mask = FlatVector::Validity(vector);
-	GetValidityMask(mask, array, scan_state, size, parent_offset, nested_offset, add_null);
+	GetValidityMask(mask, array, chunk_offset, size, parent_offset, nested_offset, add_null);
 }
 
-static void ColumnArrowToDuckDBRunEndEncoded(Vector &vector, const ArrowArray &array, ArrowArrayScanState &array_state,
-                                             idx_t size, const ArrowType &arrow_type, int64_t nested_offset = -1,
-                                             ValidityMask *parent_mask = nullptr, uint64_t parent_offset = 0);
-
-static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArrayScanState &array_state, idx_t size,
-                                const ArrowType &arrow_type, int64_t nested_offset = -1,
-                                ValidityMask *parent_mask = nullptr, uint64_t parent_offset = 0,
-                                bool ignore_extensions = false);
-
-static void ColumnArrowToDuckDBDictionary(Vector &vector, ArrowArray &array, ArrowArrayScanState &array_state,
-                                          idx_t size, const ArrowType &arrow_type, int64_t nested_offset = -1,
-                                          const ValidityMask *parent_mask = nullptr, uint64_t parent_offset = 0);
-
 namespace {
 
 struct ArrowListOffsetData {
@@ -223,15 +194,13 @@ static ArrowListOffsetData ConvertArrowListOffsets(Vector &vector, ArrowArray &a
 	}
 }
 
-static void ArrowToDuckDBList(Vector &vector, ArrowArray &array, ArrowArrayScanState &array_state, idx_t size,
-                              const ArrowType &arrow_type, int64_t nested_offset, const ValidityMask *parent_mask,
-                              int64_t parent_offset) {
-	auto &scan_state = array_state.state;
-
+static void ArrowToDuckDBList(Vector &vector, ArrowArray &array, idx_t chunk_offset, ArrowArrayScanState &array_state,
+                              idx_t size, const ArrowType &arrow_type, int64_t nested_offset,
+                              const ValidityMask *parent_mask, int64_t parent_offset) {
 	auto &list_info = arrow_type.GetTypeInfo<ArrowListInfo>();
-	SetValidityMask(vector, array, scan_state, size, parent_offset, nested_offset);
+	ArrowToDuckDBConversion::SetValidityMask(vector, array, chunk_offset, size, parent_offset, nested_offset);
 
-	auto effective_offset = GetEffectiveOffset(array, parent_offset, scan_state, nested_offset);
+	auto effective_offset = GetEffectiveOffset(array, parent_offset, chunk_offset, nested_offset);
 	auto list_data = ConvertArrowListOffsets(vector, array, size, arrow_type, effective_offset);
 	auto &start_offset = list_data.start_offset;
 	auto &list_size = list_data.list_size;
@@ -239,8 +208,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,
-	                NumericCast<int64_t>(start_offset));
+	ArrowToDuckDBConversion::SetValidityMask(child_vector, *array.children[0], chunk_offset, 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
@@ -258,45 +227,47 @@ static void ArrowToDuckDBList(Vector &vector, ArrowArray &array, ArrowArrayScanS
 
 	if (list_size == 0 && start_offset == 0) {
 		D_ASSERT(!child_array.dictionary);
-		ColumnArrowToDuckDB(child_vector, child_array, child_state, list_size, child_type, -1);
+		ArrowToDuckDBConversion::ColumnArrowToDuckDB(child_vector, child_array, chunk_offset, child_state, list_size,
+		                                             child_type, -1);
 		return;
 	}
 
-	auto array_physical_type = GetArrowArrayPhysicalType(child_type);
+	auto array_physical_type = child_type.GetPhysicalType();
 	switch (array_physical_type) {
 	case ArrowArrayPhysicalType::DICTIONARY_ENCODED:
 		// TODO: add support for offsets
-		ColumnArrowToDuckDBDictionary(child_vector, child_array, child_state, list_size, child_type,
-		                              NumericCast<int64_t>(start_offset));
+		ArrowToDuckDBConversion::ColumnArrowToDuckDBDictionary(child_vector, child_array, chunk_offset, 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,
-		                                 NumericCast<int64_t>(start_offset));
+		ArrowToDuckDBConversion::ColumnArrowToDuckDBRunEndEncoded(child_vector, child_array, chunk_offset, 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,
-		                    NumericCast<int64_t>(start_offset));
+		ArrowToDuckDBConversion::ColumnArrowToDuckDB(child_vector, child_array, chunk_offset, child_state, list_size,
+		                                             child_type, NumericCast<int64_t>(start_offset));
 		break;
 	default:
 		throw NotImplementedException("ArrowArrayPhysicalType not recognized");
 	}
 }
 
-static void ArrowToDuckDBArray(Vector &vector, ArrowArray &array, ArrowArrayScanState &array_state, idx_t size,
-                               const ArrowType &arrow_type, int64_t nested_offset, const ValidityMask *parent_mask,
-                               int64_t parent_offset) {
+static void ArrowToDuckDBArray(Vector &vector, ArrowArray &array, idx_t chunk_offset, ArrowArrayScanState &array_state,
+                               idx_t size, const ArrowType &arrow_type, int64_t nested_offset,
+                               const ValidityMask *parent_mask, int64_t parent_offset) {
 
 	auto &array_info = arrow_type.GetTypeInfo<ArrowArrayInfo>();
-	auto &scan_state = array_state.state;
 	auto array_size = array_info.FixedSize();
 	auto child_count = array_size * size;
-	auto child_offset = GetEffectiveOffset(array, parent_offset, scan_state, nested_offset) * array_size;
+	auto child_offset = GetEffectiveOffset(array, parent_offset, chunk_offset, nested_offset) * array_size;
 
-	SetValidityMask(vector, array, scan_state, size, parent_offset, nested_offset);
+	ArrowToDuckDBConversion::SetValidityMask(vector, array, chunk_offset, size, parent_offset, nested_offset);
 
 	auto &child_vector = ArrayVector::GetEntry(vector);
-	SetValidityMask(child_vector, *array.children[0], scan_state, child_count, array.offset,
-	                NumericCast<int64_t>(child_offset));
+	ArrowToDuckDBConversion::SetValidityMask(child_vector, *array.children[0], chunk_offset, child_count, array.offset,
+	                                         NumericCast<int64_t>(child_offset));
 
 	auto &array_mask = FlatVector::Validity(vector);
 	if (parent_mask) {
@@ -327,68 +298,16 @@ static void ArrowToDuckDBArray(Vector &vector, ArrowArray &array, ArrowArrayScan
 	auto &child_type = array_info.GetChild();
 	if (child_count == 0 && child_offset == 0) {
 		D_ASSERT(!child_array.dictionary);
-		ColumnArrowToDuckDB(child_vector, child_array, child_state, child_count, child_type, -1);
+		ArrowToDuckDBConversion::ColumnArrowToDuckDB(child_vector, child_array, chunk_offset, child_state, child_count,
+		                                             child_type, -1);
 	} else {
 		if (child_array.dictionary) {
-			ColumnArrowToDuckDBDictionary(child_vector, child_array, child_state, child_count, child_type,
-			                              NumericCast<int64_t>(child_offset));
+			ArrowToDuckDBConversion::ColumnArrowToDuckDBDictionary(child_vector, child_array, chunk_offset, child_state,
+			                                                       child_count, child_type,
+			                                                       NumericCast<int64_t>(child_offset));
 		} else {
-			ColumnArrowToDuckDB(child_vector, child_array, child_state, child_count, child_type,
-			                    NumericCast<int64_t>(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) {
-	SetValidityMask(vector, array, scan_state, size, parent_offset, nested_offset);
-	auto &string_info = arrow_type.GetTypeInfo<ArrowStringInfo>();
-	auto size_type = string_info.GetSizeType();
-	if (size_type == ArrowVariableSizeType::FIXED_SIZE) {
-		auto fixed_size = string_info.FixedSize();
-		//! Have to check validity mask before setting this up
-		idx_t offset = GetEffectiveOffset(array, parent_offset, scan_state, nested_offset) * fixed_size;
-		auto cdata = ArrowBufferData<char>(array, 1);
-		auto blob_len = fixed_size;
-		auto result = FlatVector::GetData<string_t>(vector);
-		for (idx_t row_idx = 0; row_idx < size; row_idx++) {
-			if (FlatVector::IsNull(vector, row_idx)) {
-				offset += blob_len;
-				continue;
-			}
-			auto bptr = cdata + offset;
-			result[row_idx] = StringVector::AddStringOrBlob(vector, bptr, blob_len);
-			offset += blob_len;
-		}
-	} else if (size_type == ArrowVariableSizeType::NORMAL) {
-		auto offsets =
-		    ArrowBufferData<uint32_t>(array, 1) + GetEffectiveOffset(array, parent_offset, scan_state, nested_offset);
-		auto cdata = ArrowBufferData<char>(array, 2);
-		auto result = FlatVector::GetData<string_t>(vector);
-		for (idx_t row_idx = 0; row_idx < size; row_idx++) {
-			if (FlatVector::IsNull(vector, row_idx)) {
-				continue;
-			}
-			auto bptr = cdata + offsets[row_idx];
-			auto blob_len = offsets[row_idx + 1] - offsets[row_idx];
-			result[row_idx] = StringVector::AddStringOrBlob(vector, bptr, blob_len);
-		}
-	} else {
-		//! Check if last offset is higher than max uint32
-		if (ArrowBufferData<uint64_t>(array, 1)[array.length] > NumericLimits<uint32_t>::Maximum()) { // LCOV_EXCL_START
-			throw ConversionException("DuckDB does not support Blobs over 4GB");
-		} // LCOV_EXCL_STOP
-		auto offsets =
-		    ArrowBufferData<uint64_t>(array, 1) + GetEffectiveOffset(array, parent_offset, scan_state, nested_offset);
-		auto cdata = ArrowBufferData<char>(array, 2);
-		auto result = FlatVector::GetData<string_t>(vector);
-		for (idx_t row_idx = 0; row_idx < size; row_idx++) {
-			if (FlatVector::IsNull(vector, row_idx)) {
-				continue;
-			}
-			auto bptr = cdata + offsets[row_idx];
-			auto blob_len = offsets[row_idx + 1] - offsets[row_idx];
-			result[row_idx] = StringVector::AddStringOrBlob(vector, bptr, blob_len);
+			ArrowToDuckDBConversion::ColumnArrowToDuckDB(child_vector, child_array, chunk_offset, child_state,
+			                                             child_count, child_type, NumericCast<int64_t>(child_offset));
 		}
 	}
 }
@@ -455,22 +374,22 @@ static void SetVectorStringView(Vector &vector, idx_t size, ArrowArray &array, i
 	}
 }
 
-static void DirectConversion(Vector &vector, ArrowArray &array, const ArrowScanLocalState &scan_state,
-                             int64_t nested_offset, uint64_t parent_offset) {
+static void DirectConversion(Vector &vector, ArrowArray &array, idx_t chunk_offset, 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, NumericCast<int64_t>(parent_offset), scan_state, nested_offset);
+	    internal_type * GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), chunk_offset, nested_offset);
 	FlatVector::SetData(vector, data_ptr);
 }
 
 template <class T>
-static void TimeConversion(Vector &vector, ArrowArray &array, const ArrowScanLocalState &scan_state,
-                           int64_t nested_offset, int64_t parent_offset, idx_t size, int64_t conversion) {
+static void TimeConversion(Vector &vector, ArrowArray &array, idx_t chunk_offset, int64_t nested_offset,
+                           int64_t parent_offset, idx_t size, int64_t conversion) {
 	auto tgt_ptr = FlatVector::GetData<dtime_t>(vector);
 	auto &validity_mask = FlatVector::Validity(vector);
-	auto src_ptr =
-	    static_cast<const T *>(array.buffers[1]) + GetEffectiveOffset(array, parent_offset, scan_state, nested_offset);
+	auto src_ptr = static_cast<const T *>(array.buffers[1]) +
+	               GetEffectiveOffset(array, parent_offset, chunk_offset, nested_offset);
 	for (idx_t row = 0; row < size; row++) {
 		if (!validity_mask.RowIsValid(row)) {
 			continue;
@@ -481,12 +400,12 @@ static void TimeConversion(Vector &vector, ArrowArray &array, const ArrowScanLoc
 	}
 }
 
-static void UUIDConversion(Vector &vector, const ArrowArray &array, const ArrowScanLocalState &scan_state,
-                           int64_t nested_offset, int64_t parent_offset, idx_t size) {
+static void UUIDConversion(Vector &vector, const ArrowArray &array, idx_t chunk_offset, int64_t nested_offset,
+                           int64_t parent_offset, idx_t size) {
 	auto tgt_ptr = FlatVector::GetData<hugeint_t>(vector);
 	auto &validity_mask = FlatVector::Validity(vector);
 	auto src_ptr = static_cast<const hugeint_t *>(array.buffers[1]) +
-	               GetEffectiveOffset(array, parent_offset, scan_state, nested_offset);
+	               GetEffectiveOffset(array, parent_offset, chunk_offset, nested_offset);
 	for (idx_t row = 0; row < size; row++) {
 		if (!validity_mask.RowIsValid(row)) {
 			continue;
@@ -498,12 +417,12 @@ static void UUIDConversion(Vector &vector, const ArrowArray &array, const ArrowS
 	}
 }
 
-static void TimestampTZConversion(Vector &vector, ArrowArray &array, const ArrowScanLocalState &scan_state,
-                                  int64_t nested_offset, int64_t parent_offset, idx_t size, int64_t conversion) {
+static void TimestampTZConversion(Vector &vector, ArrowArray &array, idx_t chunk_offset, int64_t nested_offset,
+                                  int64_t parent_offset, idx_t size, int64_t conversion) {
 	auto tgt_ptr = FlatVector::GetData<timestamp_t>(vector);
 	auto &validity_mask = FlatVector::Validity(vector);
 	auto src_ptr =
-	    ArrowBufferData<int64_t>(array, 1) + GetEffectiveOffset(array, parent_offset, scan_state, nested_offset);
+	    ArrowBufferData<int64_t>(array, 1) + GetEffectiveOffset(array, parent_offset, chunk_offset, nested_offset);
 	for (idx_t row = 0; row < size; row++) {
 		if (!validity_mask.RowIsValid(row)) {
 			continue;
@@ -514,11 +433,11 @@ static void TimestampTZConversion(Vector &vector, ArrowArray &array, const Arrow
 	}
 }
 
-static void IntervalConversionUs(Vector &vector, ArrowArray &array, const ArrowScanLocalState &scan_state,
-                                 int64_t nested_offset, int64_t parent_offset, idx_t size, int64_t conversion) {
+static void IntervalConversionUs(Vector &vector, ArrowArray &array, idx_t chunk_offset, int64_t nested_offset,
+                                 int64_t parent_offset, idx_t size, int64_t conversion) {
 	auto tgt_ptr = FlatVector::GetData<interval_t>(vector);
 	auto src_ptr =
-	    ArrowBufferData<int64_t>(array, 1) + GetEffectiveOffset(array, parent_offset, scan_state, nested_offset);
+	    ArrowBufferData<int64_t>(array, 1) + GetEffectiveOffset(array, parent_offset, chunk_offset, nested_offset);
 	for (idx_t row = 0; row < size; row++) {
 		tgt_ptr[row].days = 0;
 		tgt_ptr[row].months = 0;
@@ -528,11 +447,11 @@ static void IntervalConversionUs(Vector &vector, ArrowArray &array, const ArrowS
 	}
 }
 
-static void IntervalConversionMonths(Vector &vector, ArrowArray &array, const ArrowScanLocalState &scan_state,
-                                     int64_t nested_offset, int64_t parent_offset, idx_t size) {
+static void IntervalConversionMonths(Vector &vector, ArrowArray &array, idx_t chunk_offset, int64_t nested_offset,
+                                     int64_t parent_offset, idx_t size) {
 	auto tgt_ptr = FlatVector::GetData<interval_t>(vector);
 	auto src_ptr =
-	    ArrowBufferData<int32_t>(array, 1) + GetEffectiveOffset(array, parent_offset, scan_state, nested_offset);
+	    ArrowBufferData<int32_t>(array, 1) + GetEffectiveOffset(array, parent_offset, chunk_offset, nested_offset);
 	for (idx_t row = 0; row < size; row++) {
 		tgt_ptr[row].days = 0;
 		tgt_ptr[row].micros = 0;
@@ -540,11 +459,11 @@ static void IntervalConversionMonths(Vector &vector, ArrowArray &array, const Ar
 	}
 }
 
-static void IntervalConversionMonthDayNanos(Vector &vector, ArrowArray &array, const ArrowScanLocalState &scan_state,
+static void IntervalConversionMonthDayNanos(Vector &vector, ArrowArray &array, idx_t chunk_offset,
                                             int64_t nested_offset, int64_t parent_offset, idx_t size) {
 	auto tgt_ptr = FlatVector::GetData<interval_t>(vector);
-	auto src_ptr =
-	    ArrowBufferData<ArrowInterval>(array, 1) + GetEffectiveOffset(array, parent_offset, scan_state, nested_offset);
+	auto src_ptr = ArrowBufferData<ArrowInterval>(array, 1) +
+	               GetEffectiveOffset(array, parent_offset, chunk_offset, nested_offset);
 	for (idx_t row = 0; row < size; row++) {
 		tgt_ptr[row].days = src_ptr[row].days;
 		tgt_ptr[row].micros = src_ptr[row].nanoseconds / Interval::NANOS_PER_MICRO;
@@ -718,9 +637,11 @@ static void FlattenRunEndsSwitch(Vector &result, ArrowRunEndEncodingState &run_e
 	}
 }
 
-static void ColumnArrowToDuckDBRunEndEncoded(Vector &vector, const ArrowArray &array, ArrowArrayScanState &array_state,
-                                             idx_t size, const ArrowType &arrow_type, int64_t nested_offset,
-                                             ValidityMask *parent_mask, uint64_t parent_offset) {
+void ArrowToDuckDBConversion::ColumnArrowToDuckDBRunEndEncoded(Vector &vector, const ArrowArray &array,
+                                                               idx_t chunk_offset, ArrowArrayScanState &array_state,
+                                                               idx_t size, const ArrowType &arrow_type,
+                                                               int64_t nested_offset, ValidityMask *parent_mask,
+                                                               uint64_t parent_offset) {
 	// Scan the 'run_ends' array
 	D_ASSERT(array.n_children == 2);
 	auto &run_ends_array = *array.children[0];
@@ -731,7 +652,6 @@ static void ColumnArrowToDuckDBRunEndEncoded(Vector &vector, const ArrowArray &a
 	auto &values_type = struct_info.GetChild(1);
 	D_ASSERT(vector.GetType() == values_type.GetDuckType());
 
-	auto &scan_state = array_state.state;
 	if (vector.GetBuffer()) {
 		vector.GetBuffer()->SetAuxiliaryData(make_uniq<ArrowAuxiliaryData>(array_state.owned_data));
 	}
@@ -746,14 +666,16 @@ static void ColumnArrowToDuckDBRunEndEncoded(Vector &vector, const ArrowArray &a
 		run_end_encoding.run_ends = make_uniq<Vector>(run_ends_type.GetDuckType(), compressed_size);
 		run_end_encoding.values = make_uniq<Vector>(values_type.GetDuckType(), compressed_size);
 
-		ColumnArrowToDuckDB(*run_end_encoding.run_ends, run_ends_array, array_state, compressed_size, run_ends_type);
+		ArrowToDuckDBConversion::ColumnArrowToDuckDB(*run_end_encoding.run_ends, run_ends_array, chunk_offset,
+		                                             array_state, compressed_size, run_ends_type);
 		auto &values = *run_end_encoding.values;
-		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);
+		ArrowToDuckDBConversion::SetValidityMask(values, values_array, chunk_offset, compressed_size,
+		                                         NumericCast<int64_t>(parent_offset), nested_offset);
+		ArrowToDuckDBConversion::ColumnArrowToDuckDB(values, values_array, chunk_offset, array_state, compressed_size,
+		                                             values_type);
 	}
 
-	idx_t scan_offset = GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset);
+	idx_t scan_offset = GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), chunk_offset, nested_offset);
 	auto physical_type = run_ends_type.GetDuckType().InternalType();
 	switch (physical_type) {
 	case PhysicalType::INT16:
@@ -771,7 +693,7 @@ static void ColumnArrowToDuckDBRunEndEncoded(Vector &vector, const ArrowArray &a
 }
 template <class SRC>
 void ConvertDecimal(SRC src_ptr, Vector &vector, ArrowArray &array, idx_t size, int64_t nested_offset,
-                    uint64_t parent_offset, ArrowScanLocalState &scan_state, ValidityMask &val_mask,
+                    uint64_t parent_offset, idx_t chunk_offset, ValidityMask &val_mask,
                     DecimalBitWidth arrow_bit_width) {
 
 	switch (vector.GetType().InternalType()) {
@@ -791,7 +713,7 @@ void ConvertDecimal(SRC src_ptr, Vector &vector, ArrowArray &array, idx_t size,
 			FlatVector::SetData(vector, ArrowBufferData<data_t>(array, 1) +
 			                                GetTypeIdSize(vector.GetType().InternalType()) *
 			                                    GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset),
-			                                                       scan_state, nested_offset));
+			                                                       chunk_offset, nested_offset));
 		} else {
 			auto tgt_ptr = FlatVector::GetData<int32_t>(vector);
 			for (idx_t row = 0; row < size; row++) {
@@ -809,7 +731,7 @@ void ConvertDecimal(SRC src_ptr, Vector &vector, ArrowArray &array, idx_t size,
 			FlatVector::SetData(vector, ArrowBufferData<data_t>(array, 1) +
 			                                GetTypeIdSize(vector.GetType().InternalType()) *
 			                                    GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset),
-			                                                       scan_state, nested_offset));
+			                                                       chunk_offset, nested_offset));
 		} else {
 			auto tgt_ptr = FlatVector::GetData<int64_t>(vector);
 			for (idx_t row = 0; row < size; row++) {
@@ -827,7 +749,7 @@ void ConvertDecimal(SRC src_ptr, Vector &vector, ArrowArray &array, idx_t size,
 			FlatVector::SetData(vector, ArrowBufferData<data_t>(array, 1) +
 			                                GetTypeIdSize(vector.GetType().InternalType()) *
 			                                    GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset),
-			                                                       scan_state, nested_offset));
+			                                                       chunk_offset, nested_offset));
 		} else {
 			auto tgt_ptr = FlatVector::GetData<hugeint_t>(vector);
 			for (idx_t row = 0; row < size; row++) {
@@ -847,17 +769,18 @@ void ConvertDecimal(SRC src_ptr, Vector &vector, ArrowArray &array, idx_t size,
 	}
 }
 
-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, bool ignore_extensions) {
-	auto &scan_state = array_state.state;
+void ArrowToDuckDBConversion::ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, idx_t chunk_offset,
+                                                  ArrowArrayScanState &array_state, idx_t size,
+                                                  const ArrowType &arrow_type, int64_t nested_offset,
+                                                  ValidityMask *parent_mask, uint64_t parent_offset,
+                                                  bool ignore_extensions) {
 	D_ASSERT(!array.dictionary);
 	if (!ignore_extensions && arrow_type.HasExtension()) {
 		if (arrow_type.extension_data->arrow_to_duckdb) {
 			// Convert the storage and then call the cast function
 			Vector input_data(arrow_type.extension_data->GetInternalType());
-			ColumnArrowToDuckDB(input_data, array, array_state, size, arrow_type, nested_offset, parent_mask,
-			                    parent_offset, /*ignore_extensions*/ true);
+			ColumnArrowToDuckDB(input_data, array, chunk_offset, array_state, size, arrow_type, nested_offset,
+			                    parent_mask, parent_offset, /*ignore_extensions*/ true);
 			arrow_type.extension_data->arrow_to_duckdb(array_state.context, input_data, vector, size);
 			return;
 		}
@@ -874,7 +797,7 @@ 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 effective_offset =
-		    GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset);
+		    GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), chunk_offset, nested_offset);
 		auto src_ptr = ArrowBufferData<uint8_t>(array, 1) + effective_offset / 8;
 		auto tgt_ptr = (uint8_t *)FlatVector::GetData(vector);
 		int src_pos = 0;
@@ -910,12 +833,15 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca
 	case LogicalTypeId::TIMESTAMP_MS:
 	case LogicalTypeId::TIMESTAMP_NS:
 	case LogicalTypeId::TIME_TZ: {
-		DirectConversion(vector, array, scan_state, nested_offset, parent_offset);
+		DirectConversion(vector, array, chunk_offset, nested_offset, parent_offset);
 		break;
 	}
 	case LogicalTypeId::UUID:
-		UUIDConversion(vector, array, scan_state, nested_offset, NumericCast<int64_t>(parent_offset), size);
+		UUIDConversion(vector, array, chunk_offset, nested_offset, NumericCast<int64_t>(parent_offset), size);
 		break;
+	case LogicalTypeId::BLOB:
+	case LogicalTypeId::BIT:
+	case LogicalTypeId::BIGNUM:
 	case LogicalTypeId::VARCHAR: {
 		auto &string_info = arrow_type.GetTypeInfo<ArrowStringInfo>();
 		auto size_type = string_info.GetSizeType();
@@ -923,24 +849,42 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca
 		case ArrowVariableSizeType::SUPER_SIZE: {
 			auto cdata = ArrowBufferData<char>(array, 2);
 			auto offsets = ArrowBufferData<uint64_t>(array, 1) +
-			               GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset);
+			               GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), chunk_offset, nested_offset);
 			SetVectorString(vector, size, cdata, offsets);
 			break;
 		}
-		case ArrowVariableSizeType::NORMAL:
-		case ArrowVariableSizeType::FIXED_SIZE: {
+		case ArrowVariableSizeType::NORMAL: {
 			auto cdata = ArrowBufferData<char>(array, 2);
 			auto offsets = ArrowBufferData<uint32_t>(array, 1) +
-			               GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset);
+			               GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), chunk_offset, nested_offset);
 			SetVectorString(vector, size, cdata, offsets);
 			break;
 		}
 		case ArrowVariableSizeType::VIEW: {
 			SetVectorStringView(
 			    vector, size, array,
-			    GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset));
+			    GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), chunk_offset, nested_offset));
 			break;
 		}
+		case ArrowVariableSizeType::FIXED_SIZE: {
+			SetValidityMask(vector, array, chunk_offset, size, NumericCast<int64_t>(parent_offset), nested_offset);
+			auto fixed_size = string_info.FixedSize();
+			// Have to check validity mask before setting this up
+			idx_t offset = GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), chunk_offset, nested_offset) *
+			               fixed_size;
+			auto cdata = ArrowBufferData<char>(array, 1);
+			auto blob_len = fixed_size;
+			auto result = FlatVector::GetData<string_t>(vector);
+			for (idx_t row_idx = 0; row_idx < size; row_idx++) {
+				if (FlatVector::IsNull(vector, row_idx)) {
+					offset += blob_len;
+					continue;
+				}
+				auto bptr = cdata + offset;
+				result[row_idx] = StringVector::AddStringOrBlob(vector, bptr, blob_len);
+				offset += blob_len;
+			}
+		}
 		}
 		break;
 	}
@@ -949,13 +893,13 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca
 		auto precision = datetime_info.GetDateTimeType();
 		switch (precision) {
 		case ArrowDateTimeType::DAYS: {
-			DirectConversion(vector, array, scan_state, nested_offset, parent_offset);
+			DirectConversion(vector, array, chunk_offset, nested_offset, parent_offset);
 			break;
 		}
 		case ArrowDateTimeType::MILLISECONDS: {
 			//! convert date from nanoseconds to days
 			auto src_ptr = ArrowBufferData<uint64_t>(array, 1) +
-			               GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset);
+			               GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), chunk_offset, nested_offset);
 			auto tgt_ptr = FlatVector::GetData<date_t>(vector);
 			for (idx_t row = 0; row < size; row++) {
 				tgt_ptr[row] = date_t(UnsafeNumericCast<int32_t>(static_cast<int64_t>(src_ptr[row]) /
@@ -973,24 +917,24 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca
 		auto precision = datetime_info.GetDateTimeType();
 		switch (precision) {
 		case ArrowDateTimeType::SECONDS: {
-			TimeConversion<int32_t>(vector, array, scan_state, nested_offset, NumericCast<int64_t>(parent_offset), size,
-			                        1000000);
+			TimeConversion<int32_t>(vector, array, chunk_offset, nested_offset, NumericCast<int64_t>(parent_offset),
+			                        size, 1000000);
 			break;
 		}
 		case ArrowDateTimeType::MILLISECONDS: {
-			TimeConversion<int32_t>(vector, array, scan_state, nested_offset, NumericCast<int64_t>(parent_offset), size,
-			                        1000);
+			TimeConversion<int32_t>(vector, array, chunk_offset, nested_offset, NumericCast<int64_t>(parent_offset),
+			                        size, 1000);
 			break;
 		}
 		case ArrowDateTimeType::MICROSECONDS: {
-			TimeConversion<int64_t>(vector, array, scan_state, nested_offset, NumericCast<int64_t>(parent_offset), size,
-			                        1);
+			TimeConversion<int64_t>(vector, array, chunk_offset, 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, NumericCast<int64_t>(parent_offset), scan_state, nested_offset);
+			               GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), chunk_offset, nested_offset);
 			for (idx_t row = 0; row < size; row++) {
 				tgt_ptr[row].micros = src_ptr[row] / 1000;
 			}
@@ -1006,23 +950,23 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca
 		auto precision = datetime_info.GetDateTimeType();
 		switch (precision) {
 		case ArrowDateTimeType::SECONDS: {
-			TimestampTZConversion(vector, array, scan_state, nested_offset, NumericCast<int64_t>(parent_offset), size,
+			TimestampTZConversion(vector, array, chunk_offset, nested_offset, NumericCast<int64_t>(parent_offset), size,
 			                      1000000);
 			break;
 		}
 		case ArrowDateTimeType::MILLISECONDS: {
-			TimestampTZConversion(vector, array, scan_state, nested_offset, NumericCast<int64_t>(parent_offset), size,
+			TimestampTZConversion(vector, array, chunk_offset, nested_offset, NumericCast<int64_t>(parent_offset), size,
 			                      1000);
 			break;
 		}
 		case ArrowDateTimeType::MICROSECONDS: {
-			DirectConversion(vector, array, scan_state, nested_offset, parent_offset);
+			DirectConversion(vector, array, chunk_offset, nested_offset, parent_offset);
 			break;
 		}
 		case ArrowDateTimeType::NANOSECONDS: {
 			auto tgt_ptr = FlatVector::GetData<timestamp_t>(vector);
 			auto src_ptr = ArrowBufferData<int64_t>(array, 1) +
-			               GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset);
+			               GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), chunk_offset, nested_offset);
 			for (idx_t row = 0; row < size; row++) {
 				tgt_ptr[row].value = src_ptr[row] / 1000;
 			}
@@ -1038,25 +982,25 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca
 		auto precision = datetime_info.GetDateTimeType();
 		switch (precision) {
 		case ArrowDateTimeType::SECONDS: {
-			IntervalConversionUs(vector, array, scan_state, nested_offset, NumericCast<int64_t>(parent_offset), size,
+			IntervalConversionUs(vector, array, chunk_offset, nested_offset, NumericCast<int64_t>(parent_offset), size,
 			                     1000000);
 			break;
 		}
 		case ArrowDateTimeType::DAYS:
 		case ArrowDateTimeType::MILLISECONDS: {
-			IntervalConversionUs(vector, array, scan_state, nested_offset, NumericCast<int64_t>(parent_offset), size,
+			IntervalConversionUs(vector, array, chunk_offset, nested_offset, NumericCast<int64_t>(parent_offset), size,
 			                     1000);
 			break;
 		}
 		case ArrowDateTimeType::MICROSECONDS: {
-			IntervalConversionUs(vector, array, scan_state, nested_offset, NumericCast<int64_t>(parent_offset), size,
+			IntervalConversionUs(vector, array, chunk_offset, 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, NumericCast<int64_t>(parent_offset), scan_state, nested_offset);
+			               GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), chunk_offset, nested_offset);
 			for (idx_t row = 0; row < size; row++) {
 				tgt_ptr[row].micros = src_ptr[row] / 1000;
 				tgt_ptr[row].days = 0;
@@ -1065,12 +1009,12 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca
 			break;
 		}
 		case ArrowDateTimeType::MONTHS: {
-			IntervalConversionMonths(vector, array, scan_state, nested_offset, NumericCast<int64_t>(parent_offset),
+			IntervalConversionMonths(vector, array, chunk_offset, nested_offset, NumericCast<int64_t>(parent_offset),
 			                         size);
 			break;
 		}
 		case ArrowDateTimeType::MONTH_DAY_NANO: {
-			IntervalConversionMonthDayNanos(vector, array, scan_state, nested_offset,
+			IntervalConversionMonthDayNanos(vector, array, chunk_offset, nested_offset,
 			                                NumericCast<int64_t>(parent_offset), size);
 			break;
 		}
@@ -1087,22 +1031,25 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca
 		switch (bit_width) {
 		case DecimalBitWidth::DECIMAL_32: {
 			auto src_ptr = ArrowBufferData<int32_t>(array, 1) +
-			               GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset);
-			ConvertDecimal(src_ptr, vector, array, size, nested_offset, parent_offset, scan_state, val_mask, bit_width);
+			               GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), chunk_offset, nested_offset);
+			ConvertDecimal(src_ptr, vector, array, size, nested_offset, parent_offset, chunk_offset, val_mask,
+			               bit_width);
 			break;
 		}
 
 		case DecimalBitWidth::DECIMAL_64: {
 			auto src_ptr = ArrowBufferData<int64_t>(array, 1) +
-			               GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset);
-			ConvertDecimal(src_ptr, vector, array, size, nested_offset, parent_offset, scan_state, val_mask, bit_width);
+			               GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), chunk_offset, nested_offset);
+			ConvertDecimal(src_ptr, vector, array, size, nested_offset, parent_offset, chunk_offset, val_mask,
+			               bit_width);
 			break;
 		}
 
 		case DecimalBitWidth::DECIMAL_128: {
 			auto src_ptr = ArrowBufferData<hugeint_t>(array, 1) +
-			               GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset);
-			ConvertDecimal(src_ptr, vector, array, size, nested_offset, parent_offset, scan_state, val_mask, bit_width);
+			               GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), chunk_offset, nested_offset);
+			ConvertDecimal(src_ptr, vector, array, size, nested_offset, parent_offset, chunk_offset, val_mask,
+			               bit_width);
 			break;
 		}
 		default:
@@ -1110,25 +1057,18 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca
 		}
 		break;
 	}
-	case LogicalTypeId::BLOB:
-	case LogicalTypeId::BIT:
-	case LogicalTypeId::VARINT: {
-		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,
+		ArrowToDuckDBList(vector, array, chunk_offset, 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,
+		ArrowToDuckDBArray(vector, array, chunk_offset, 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,
+		ArrowToDuckDBList(vector, array, chunk_offset, array_state, size, arrow_type, nested_offset, parent_mask,
 		                  NumericCast<int64_t>(parent_offset));
 		ArrowToDuckDBMapVerify(vector, size);
 		break;
@@ -1144,7 +1084,8 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca
 			auto &child_type = struct_info.GetChild(child_idx);
 			auto &child_state = array_state.GetChild(child_idx);
 
-			SetValidityMask(child_entry, child_array, scan_state, size, array.offset, nested_offset);
+			ArrowToDuckDBConversion::SetValidityMask(child_entry, child_array, chunk_offset, size, array.offset,
+			                                         nested_offset);
 			if (!struct_validity_mask.AllValid()) {
 				auto &child_validity_mark = FlatVector::Validity(child_entry);
 				for (idx_t i = 0; i < size; i++) {
@@ -1154,19 +1095,21 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca
 				}
 			}
 
-			auto array_physical_type = GetArrowArrayPhysicalType(child_type);
+			auto array_physical_type = child_type.GetPhysicalType();
 			switch (array_physical_type) {
 			case ArrowArrayPhysicalType::DICTIONARY_ENCODED:
-				ColumnArrowToDuckDBDictionary(child_entry, child_array, child_state, size, child_type, nested_offset,
-				                              &struct_validity_mask, NumericCast<uint64_t>(array.offset));
+				ArrowToDuckDBConversion::ColumnArrowToDuckDBDictionary(
+				    child_entry, child_array, chunk_offset, child_state, size, child_type, nested_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, NumericCast<uint64_t>(array.offset));
+				ColumnArrowToDuckDBRunEndEncoded(child_entry, child_array, chunk_offset, child_state, size, child_type,
+				                                 nested_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, NumericCast<uint64_t>(array.offset), false);
+				ColumnArrowToDuckDB(child_entry, child_array, chunk_offset, child_state, size, child_type,
+				                    nested_offset, &struct_validity_mask, NumericCast<uint64_t>(array.offset), false);
 				break;
 			default:
 				throw NotImplementedException("ArrowArrayPhysicalType not recognized");
@@ -1188,19 +1131,22 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca
 			auto &child_state = array_state.GetChild(child_idx);
 			auto &child_type = union_info.GetChild(child_idx);
 
-			SetValidityMask(child, child_array, scan_state, size, NumericCast<int64_t>(parent_offset), nested_offset);
-			auto array_physical_type = GetArrowArrayPhysicalType(child_type);
+			ArrowToDuckDBConversion::SetValidityMask(child, child_array, chunk_offset, size,
+			                                         NumericCast<int64_t>(parent_offset), nested_offset);
+			auto array_physical_type = child_type.GetPhysicalType();
 
 			switch (array_physical_type) {
 			case ArrowArrayPhysicalType::DICTIONARY_ENCODED:
-				ColumnArrowToDuckDBDictionary(child, child_array, child_state, size, child_type);
+				ArrowToDuckDBConversion::ColumnArrowToDuckDBDictionary(child, child_array, chunk_offset, child_state,
+				                                                       size, child_type);
 				break;
 			case ArrowArrayPhysicalType::RUN_END_ENCODED:
-				ColumnArrowToDuckDBRunEndEncoded(child, child_array, child_state, size, child_type);
+				ArrowToDuckDBConversion::ColumnArrowToDuckDBRunEndEncoded(child, child_array, chunk_offset, child_state,
+				                                                          size, child_type);
 				break;
 			case ArrowArrayPhysicalType::DEFAULT:
-				ColumnArrowToDuckDB(child, child_array, child_state, size, child_type, nested_offset, &validity_mask,
-				                    false);
+				ArrowToDuckDBConversion::ColumnArrowToDuckDB(child, child_array, chunk_offset, child_state, size,
+				                                             child_type, nested_offset, &validity_mask, false);
 				break;
 			default:
 				throw NotImplementedException("ArrowArrayPhysicalType not recognized");
@@ -1361,33 +1307,34 @@ static bool CanContainNull(const ArrowArray &array, const ValidityMask *parent_m
 	return !parent_mask->AllValid();
 }
 
-static void ColumnArrowToDuckDBDictionary(Vector &vector, ArrowArray &array, ArrowArrayScanState &array_state,
-                                          idx_t size, const ArrowType &arrow_type, int64_t nested_offset,
-                                          const ValidityMask *parent_mask, uint64_t parent_offset) {
+void ArrowToDuckDBConversion::ColumnArrowToDuckDBDictionary(Vector &vector, ArrowArray &array, idx_t chunk_offset,
+                                                            ArrowArrayScanState &array_state, idx_t size,
+                                                            const ArrowType &arrow_type, int64_t nested_offset,
+                                                            const ValidityMask *parent_mask, uint64_t parent_offset) {
 	if (vector.GetBuffer()) {
 		vector.GetBuffer()->SetAuxiliaryData(make_uniq<ArrowAuxiliaryData>(array_state.owned_data));
 	}
 	D_ASSERT(arrow_type.HasDictionary());
-	auto &scan_state = array_state.state;
 	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(), NumericCast<idx_t>(array.dictionary->length));
-		SetValidityMask(*base_vector, *array.dictionary, scan_state, NumericCast<idx_t>(array.dictionary->length), 0, 0,
-		                has_nulls);
+		ArrowToDuckDBConversion::SetValidityMask(*base_vector, *array.dictionary, chunk_offset,
+		                                         NumericCast<idx_t>(array.dictionary->length), 0, 0, has_nulls);
 		auto &dictionary_type = arrow_type.GetDictionary();
-		auto arrow_physical_type = GetArrowArrayPhysicalType(dictionary_type);
+		auto arrow_physical_type = dictionary_type.GetPhysicalType();
+		;
 		switch (arrow_physical_type) {
 		case ArrowArrayPhysicalType::DICTIONARY_ENCODED:
-			ColumnArrowToDuckDBDictionary(*base_vector, *array.dictionary, array_state,
+			ColumnArrowToDuckDBDictionary(*base_vector, *array.dictionary, chunk_offset, array_state,
 			                              NumericCast<idx_t>(array.dictionary->length), dictionary_type);
 			break;
 		case ArrowArrayPhysicalType::RUN_END_ENCODED:
-			ColumnArrowToDuckDBRunEndEncoded(*base_vector, *array.dictionary, array_state,
+			ColumnArrowToDuckDBRunEndEncoded(*base_vector, *array.dictionary, chunk_offset, array_state,
 			                                 NumericCast<idx_t>(array.dictionary->length), dictionary_type);
 			break;
 		case ArrowArrayPhysicalType::DEFAULT:
-			ColumnArrowToDuckDB(*base_vector, *array.dictionary, array_state,
+			ColumnArrowToDuckDB(*base_vector, *array.dictionary, chunk_offset, array_state,
 			                    NumericCast<idx_t>(array.dictionary->length), dictionary_type);
 			break;
 		default:
@@ -1399,12 +1346,12 @@ static void ColumnArrowToDuckDBDictionary(Vector &vector, ArrowArray &array, Arr
 	//! Get Pointer to Indices of Dictionary
 	auto indices = ArrowBufferData<data_t>(array, 1) +
 	               GetTypeIdSize(offset_type.InternalType()) *
-	                   GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset);
+	                   GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), chunk_offset, nested_offset);
 
 	SelectionVector sel;
 	if (has_nulls) {
 		ValidityMask indices_validity;
-		GetValidityMask(indices_validity, array, scan_state, size, NumericCast<int64_t>(parent_offset));
+		GetValidityMask(indices_validity, array, chunk_offset, 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++) {
@@ -1467,19 +1414,22 @@ void ArrowTableFunction::ArrowToDuckDB(ArrowScanLocalState &scan_state, const ar
 		if (!array_state.owned_data) {
 			array_state.owned_data = scan_state.chunk;
 		}
-
-		auto array_physical_type = GetArrowArrayPhysicalType(arrow_type);
+		auto array_physical_type = arrow_type.GetPhysicalType();
 
 		switch (array_physical_type) {
 		case ArrowArrayPhysicalType::DICTIONARY_ENCODED:
-			ColumnArrowToDuckDBDictionary(output.data[idx], array, array_state, output.size(), arrow_type);
+			ArrowToDuckDBConversion::ColumnArrowToDuckDBDictionary(output.data[idx], array, scan_state.chunk_offset,
+			                                                       array_state, output.size(), arrow_type);
 			break;
 		case ArrowArrayPhysicalType::RUN_END_ENCODED:
-			ColumnArrowToDuckDBRunEndEncoded(output.data[idx], array, array_state, output.size(), arrow_type);
+			ArrowToDuckDBConversion::ColumnArrowToDuckDBRunEndEncoded(output.data[idx], array, scan_state.chunk_offset,
+			                                                          array_state, output.size(), arrow_type);
 			break;
 		case ArrowArrayPhysicalType::DEFAULT:
-			SetValidityMask(output.data[idx], array, scan_state, output.size(), parent_array.offset, -1);
-			ColumnArrowToDuckDB(output.data[idx], array, array_state, output.size(), arrow_type);
+			ArrowToDuckDBConversion::SetValidityMask(output.data[idx], array, scan_state.chunk_offset, output.size(),
+			                                         parent_array.offset, -1);
+			ArrowToDuckDBConversion::ColumnArrowToDuckDB(output.data[idx], array, scan_state.chunk_offset, array_state,
+			                                             output.size(), arrow_type);
 			break;
 		default:
 			throw NotImplementedException("ArrowArrayPhysicalType not recognized");