duckdb 0.8.1-dev23.0 → 0.8.1-dev253.0

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

@@ -59,8 +59,8 @@ bool ScalarFunction::Equal(const ScalarFunction &rhs) const {
 bool ScalarFunction::CompareScalarFunctionT(const scalar_function_t &other) const {
 	typedef void(scalar_function_ptr_t)(DataChunk &, ExpressionState &, Vector &);
 
-	auto func_ptr = (scalar_function_ptr_t **)function.template target<scalar_function_ptr_t *>();
-	auto other_ptr = (scalar_function_ptr_t **)other.template target<scalar_function_ptr_t *>();
+	auto func_ptr = (scalar_function_ptr_t **)function.template target<scalar_function_ptr_t *>(); // NOLINT
+	auto other_ptr = (scalar_function_ptr_t **)other.template target<scalar_function_ptr_t *>();   // NOLINT
 
 	// Case the functions were created from lambdas the target will return a nullptr
 	if (!func_ptr && !other_ptr) {
@@ -70,7 +70,7 @@ bool ScalarFunction::CompareScalarFunctionT(const scalar_function_t &other) cons
 		// scalar_function_t (std::functions) from lambdas cannot be compared
 		return false;
 	}
-	return ((size_t)*func_ptr == (size_t)*other_ptr);
+	return CastPointerToValue(*func_ptr) == CastPointerToValue(*other_ptr);
 }
 
 void ScalarFunction::NopFunction(DataChunk &input, ExpressionState &state, Vector &result) {

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

@@ -193,8 +193,8 @@ void ArrowTableFunction::RenameArrowColumns(vector<string> &names) {
 unique_ptr<FunctionData> ArrowTableFunction::ArrowScanBind(ClientContext &context, TableFunctionBindInput &input,
                                                            vector<LogicalType> &return_types, vector<string> &names) {
 	auto stream_factory_ptr = input.inputs[0].GetPointer();
-	auto stream_factory_produce = (stream_factory_produce_t)input.inputs[1].GetPointer();
-	auto stream_factory_get_schema = (stream_factory_get_schema_t)input.inputs[2].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);
 
@@ -206,8 +206,8 @@ unique_ptr<FunctionData> ArrowTableFunction::ArrowScanBind(ClientContext &contex
 			throw InvalidInputException("arrow_scan: released schema passed");
 		}
 		if (schema.dictionary) {
-			res->arrow_convert_data[col_idx] =
-			    make_uniq<ArrowConvertData>(GetArrowLogicalType(schema, res->arrow_convert_data, col_idx));
+			auto logical_type = GetArrowLogicalType(schema, res->arrow_convert_data, col_idx);
+			res->arrow_convert_data[col_idx] = make_uniq<ArrowConvertData>(std::move(logical_type));
 			return_types.emplace_back(GetArrowLogicalType(*schema.dictionary, res->arrow_convert_data, col_idx));
 		} else {
 			return_types.emplace_back(GetArrowLogicalType(schema, res->arrow_convert_data, col_idx));
@@ -269,7 +269,7 @@ bool ArrowTableFunction::ArrowScanParallelStateNext(ClientContext &context, cons
 
 unique_ptr<GlobalTableFunctionState> ArrowTableFunction::ArrowScanInitGlobal(ClientContext &context,
                                                                              TableFunctionInitInput &input) {
-	auto &bind_data = (const ArrowScanFunctionData &)*input.bind_data;
+	auto &bind_data = input.bind_data->Cast<ArrowScanFunctionData>();
 	auto result = make_uniq<ArrowScanGlobalState>();
 	result->stream = ProduceArrowScan(bind_data, input.column_ids, input.filters.get());
 	result->max_threads = ArrowScanMaxThreads(context, input.bind_data.get());
@@ -314,7 +314,7 @@ void ArrowTableFunction::ArrowScanFunction(ClientContext &context, TableFunction
 	if (!data_p.local_state) {
 		return;
 	}
-	auto &data = (ArrowScanFunctionData &)*data_p.bind_data;
+	auto &data = data_p.bind_data->CastNoConst<ArrowScanFunctionData>(); // FIXME
 	auto &state = data_p.local_state->Cast<ArrowScanLocalState>();
 	auto &global_state = data_p.global_state->Cast<ArrowScanGlobalState>();
 

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

@@ -28,6 +28,11 @@ static void ShiftRight(unsigned char *ar, int size, int shift) {
 	}
 }
 
+template <class T>
+T *ArrowBufferData(ArrowArray &array, idx_t buffer_idx) {
+	return (T *)array.buffers[buffer_idx]; // NOLINT
+}
+
 static void GetValidityMask(ValidityMask &mask, ArrowArray &array, ArrowScanLocalState &scan_state, idx_t size,
                             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.
@@ -46,18 +51,18 @@ static void GetValidityMask(ValidityMask &mask, ArrowArray &array, ArrowScanLoca
 		auto n_bitmask_bytes = (size + 8 - 1) / 8;
 		if (bit_offset % 8 == 0) {
 			//! just memcpy nullmask
-			memcpy((void *)mask.GetData(), (uint8_t *)array.buffers[0] + bit_offset / 8, n_bitmask_bytes);
+			memcpy((void *)mask.GetData(), ArrowBufferData<uint8_t>(array, 0) + bit_offset / 8, n_bitmask_bytes);
 		} else {
 			//! need to re-align nullmask
 			vector<uint8_t> temp_nullmask(n_bitmask_bytes + 1);
-			memcpy(temp_nullmask.data(), (uint8_t *)array.buffers[0] + bit_offset / 8, 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,
 			           bit_offset % 8); //! why this has to be a right shift is a mystery to me
-			memcpy((void *)mask.GetData(), (data_ptr_t)temp_nullmask.data(), n_bitmask_bytes);
+			memcpy((void *)mask.GetData(), data_ptr_cast(temp_nullmask.data()), n_bitmask_bytes);
 		}
 #else
 		auto byte_offset = bit_offset / 8;
-		auto source_data = (uint8_t *)array.buffers[0];
+		auto source_data = ArrowBufferData<uint8_t>(array, 0);
 		bit_offset %= 8;
 		for (idx_t i = 0; i < size; i++) {
 			mask.Set(i, source_data[byte_offset] & (1 << bit_offset));
@@ -115,9 +120,9 @@ static void ArrowToDuckDBList(Vector &vector, ArrowArray &array, ArrowScanLocalS
 		}
 		list_size = start_offset + cur_offset;
 	} else if (original_type.first == ArrowVariableSizeType::NORMAL) {
-		auto offsets = (uint32_t *)array.buffers[1] + array.offset + scan_state.chunk_offset;
+		auto offsets = ArrowBufferData<uint32_t>(array, 1) + array.offset + scan_state.chunk_offset;
 		if (nested_offset != -1) {
-			offsets = (uint32_t *)array.buffers[1] + nested_offset;
+			offsets = ArrowBufferData<uint32_t>(array, 1) + nested_offset;
 		}
 		start_offset = offsets[0];
 		auto list_data = FlatVector::GetData<list_entry_t>(vector);
@@ -129,9 +134,9 @@ static void ArrowToDuckDBList(Vector &vector, ArrowArray &array, ArrowScanLocalS
 		}
 		list_size = offsets[size];
 	} else {
-		auto offsets = (uint64_t *)array.buffers[1] + array.offset + scan_state.chunk_offset;
+		auto offsets = ArrowBufferData<uint64_t>(array, 1) + array.offset + scan_state.chunk_offset;
 		if (nested_offset != -1) {
-			offsets = (uint64_t *)array.buffers[1] + nested_offset;
+			offsets = ArrowBufferData<uint64_t>(array, 1) + nested_offset;
 		}
 		start_offset = offsets[0];
 		auto list_data = FlatVector::GetData<list_entry_t>(vector);
@@ -179,7 +184,7 @@ static void ArrowToDuckDBBlob(Vector &vector, ArrowArray &array, ArrowScanLocalS
 		if (nested_offset != -1) {
 			offset = original_type.second * nested_offset;
 		}
-		auto cdata = (char *)array.buffers[1];
+		auto cdata = ArrowBufferData<char>(array, 1);
 		for (idx_t row_idx = 0; row_idx < size; row_idx++) {
 			if (FlatVector::IsNull(vector, row_idx)) {
 				continue;
@@ -190,11 +195,11 @@ static void ArrowToDuckDBBlob(Vector &vector, ArrowArray &array, ArrowScanLocalS
 			offset += blob_len;
 		}
 	} else if (original_type.first == ArrowVariableSizeType::NORMAL) {
-		auto offsets = (uint32_t *)array.buffers[1] + array.offset + scan_state.chunk_offset;
+		auto offsets = ArrowBufferData<uint32_t>(array, 1) + array.offset + scan_state.chunk_offset;
 		if (nested_offset != -1) {
-			offsets = (uint32_t *)array.buffers[1] + array.offset + nested_offset;
+			offsets = ArrowBufferData<uint32_t>(array, 1) + array.offset + nested_offset;
 		}
-		auto cdata = (char *)array.buffers[2];
+		auto cdata = ArrowBufferData<char>(array, 2);
 		for (idx_t row_idx = 0; row_idx < size; row_idx++) {
 			if (FlatVector::IsNull(vector, row_idx)) {
 				continue;
@@ -205,14 +210,14 @@ static void ArrowToDuckDBBlob(Vector &vector, ArrowArray &array, ArrowScanLocalS
 		}
 	} else {
 		//! Check if last offset is higher than max uint32
-		if (((uint64_t *)array.buffers[1])[array.length] > NumericLimits<uint32_t>::Maximum()) { // LCOV_EXCL_START
+		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 = (uint64_t *)array.buffers[1] + array.offset + scan_state.chunk_offset;
+		auto offsets = ArrowBufferData<uint64_t>(array, 1) + array.offset + scan_state.chunk_offset;
 		if (nested_offset != -1) {
-			offsets = (uint64_t *)array.buffers[1] + array.offset + nested_offset;
+			offsets = ArrowBufferData<uint64_t>(array, 1) + array.offset + nested_offset;
 		}
-		auto cdata = (char *)array.buffers[2];
+		auto cdata = ArrowBufferData<char>(array, 2);
 		for (idx_t row_idx = 0; row_idx < size; row_idx++) {
 			if (FlatVector::IsNull(vector, row_idx)) {
 				continue;
@@ -263,9 +268,9 @@ static void SetVectorString(Vector &vector, idx_t size, char *cdata, T *offsets)
 static void DirectConversion(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state,
                              int64_t nested_offset) {
 	auto internal_type = GetTypeIdSize(vector.GetType().InternalType());
-	auto data_ptr = (data_ptr_t)array.buffers[1] + internal_type * (scan_state.chunk_offset + array.offset);
+	auto data_ptr = ArrowBufferData<data_t>(array, 1) + internal_type * (scan_state.chunk_offset + array.offset);
 	if (nested_offset != -1) {
-		data_ptr = (data_ptr_t)array.buffers[1] + internal_type * (array.offset + nested_offset);
+		data_ptr = ArrowBufferData<data_t>(array, 1) + internal_type * (array.offset + nested_offset);
 	}
 	FlatVector::SetData(vector, data_ptr);
 }
@@ -273,7 +278,7 @@ static void DirectConversion(Vector &vector, ArrowArray &array, ArrowScanLocalSt
 template <class T>
 static void TimeConversion(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state, int64_t nested_offset,
                            idx_t size, int64_t conversion) {
-	auto tgt_ptr = (dtime_t *)FlatVector::GetData(vector);
+	auto tgt_ptr = FlatVector::GetData<dtime_t>(vector);
 	auto &validity_mask = FlatVector::Validity(vector);
 	auto src_ptr = (T *)array.buffers[1] + scan_state.chunk_offset + array.offset;
 	if (nested_offset != -1) {
@@ -291,11 +296,11 @@ static void TimeConversion(Vector &vector, ArrowArray &array, ArrowScanLocalStat
 
 static void TimestampTZConversion(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state,
                                   int64_t nested_offset, idx_t size, int64_t conversion) {
-	auto tgt_ptr = (timestamp_t *)FlatVector::GetData(vector);
+	auto tgt_ptr = FlatVector::GetData<timestamp_t>(vector);
 	auto &validity_mask = FlatVector::Validity(vector);
-	auto src_ptr = (int64_t *)array.buffers[1] + scan_state.chunk_offset + array.offset;
+	auto src_ptr = ArrowBufferData<int64_t>(array, 1) + scan_state.chunk_offset + array.offset;
 	if (nested_offset != -1) {
-		src_ptr = (int64_t *)array.buffers[1] + nested_offset + array.offset;
+		src_ptr = ArrowBufferData<int64_t>(array, 1) + nested_offset + array.offset;
 	}
 	for (idx_t row = 0; row < size; row++) {
 		if (!validity_mask.RowIsValid(row)) {
@@ -309,10 +314,10 @@ static void TimestampTZConversion(Vector &vector, ArrowArray &array, ArrowScanLo
 
 static void IntervalConversionUs(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state,
                                  int64_t nested_offset, idx_t size, int64_t conversion) {
-	auto tgt_ptr = (interval_t *)FlatVector::GetData(vector);
-	auto src_ptr = (int64_t *)array.buffers[1] + scan_state.chunk_offset + array.offset;
+	auto tgt_ptr = FlatVector::GetData<interval_t>(vector);
+	auto src_ptr = ArrowBufferData<int64_t>(array, 1) + scan_state.chunk_offset + array.offset;
 	if (nested_offset != -1) {
-		src_ptr = (int64_t *)array.buffers[1] + nested_offset + array.offset;
+		src_ptr = ArrowBufferData<int64_t>(array, 1) + nested_offset + array.offset;
 	}
 	for (idx_t row = 0; row < size; row++) {
 		tgt_ptr[row].days = 0;
@@ -325,10 +330,10 @@ static void IntervalConversionUs(Vector &vector, ArrowArray &array, ArrowScanLoc
 
 static void IntervalConversionMonths(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state,
                                      int64_t nested_offset, idx_t size) {
-	auto tgt_ptr = (interval_t *)FlatVector::GetData(vector);
-	auto src_ptr = (int32_t *)array.buffers[1] + scan_state.chunk_offset + array.offset;
+	auto tgt_ptr = FlatVector::GetData<interval_t>(vector);
+	auto src_ptr = ArrowBufferData<int32_t>(array, 1) + scan_state.chunk_offset + array.offset;
 	if (nested_offset != -1) {
-		src_ptr = (int32_t *)array.buffers[1] + nested_offset + array.offset;
+		src_ptr = ArrowBufferData<int32_t>(array, 1) + nested_offset + array.offset;
 	}
 	for (idx_t row = 0; row < size; row++) {
 		tgt_ptr[row].days = 0;
@@ -339,10 +344,10 @@ static void IntervalConversionMonths(Vector &vector, ArrowArray &array, ArrowSca
 
 static void IntervalConversionMonthDayNanos(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state,
                                             int64_t nested_offset, idx_t size) {
-	auto tgt_ptr = (interval_t *)FlatVector::GetData(vector);
-	auto src_ptr = (ArrowInterval *)array.buffers[1] + scan_state.chunk_offset + array.offset;
+	auto tgt_ptr = FlatVector::GetData<interval_t>(vector);
+	auto src_ptr = ArrowBufferData<ArrowInterval>(array, 1) + scan_state.chunk_offset + array.offset;
 	if (nested_offset != -1) {
-		src_ptr = (ArrowInterval *)array.buffers[1] + nested_offset + array.offset;
+		src_ptr = ArrowBufferData<ArrowInterval>(array, 1) + nested_offset + array.offset;
 	}
 	for (idx_t row = 0; row < size; row++) {
 		tgt_ptr[row].days = src_ptr[row].days;
@@ -362,10 +367,10 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowScanLoca
 	case LogicalTypeId::BOOLEAN: {
 		//! Arrow bit-packs boolean values
 		//! Lets first figure out where we are in the source array
-		auto src_ptr = (uint8_t *)array.buffers[1] + (scan_state.chunk_offset + array.offset) / 8;
+		auto src_ptr = ArrowBufferData<uint8_t>(array, 1) + (scan_state.chunk_offset + array.offset) / 8;
 
 		if (nested_offset != -1) {
-			src_ptr = (uint8_t *)array.buffers[1] + (nested_offset + array.offset) / 8;
+			src_ptr = ArrowBufferData<uint8_t>(array, 1) + (nested_offset + array.offset) / 8;
 		}
 		auto tgt_ptr = (uint8_t *)FlatVector::GetData(vector);
 		int src_pos = 0;
@@ -407,17 +412,17 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowScanLoca
 	}
 	case LogicalTypeId::VARCHAR: {
 		auto original_type = arrow_convert_data[col_idx]->variable_sz_type[arrow_convert_idx.variable_sized_index++];
-		auto cdata = (char *)array.buffers[2];
+		auto cdata = ArrowBufferData<char>(array, 2);
 		if (original_type.first == ArrowVariableSizeType::SUPER_SIZE) {
-			auto offsets = (uint64_t *)array.buffers[1] + array.offset + scan_state.chunk_offset;
+			auto offsets = ArrowBufferData<uint64_t>(array, 1) + array.offset + scan_state.chunk_offset;
 			if (nested_offset != -1) {
-				offsets = (uint64_t *)array.buffers[1] + array.offset + nested_offset;
+				offsets = ArrowBufferData<uint64_t>(array, 1) + array.offset + nested_offset;
 			}
 			SetVectorString(vector, size, cdata, offsets);
 		} else {
-			auto offsets = (uint32_t *)array.buffers[1] + array.offset + scan_state.chunk_offset;
+			auto offsets = ArrowBufferData<uint32_t>(array, 1) + array.offset + scan_state.chunk_offset;
 			if (nested_offset != -1) {
-				offsets = (uint32_t *)array.buffers[1] + array.offset + nested_offset;
+				offsets = ArrowBufferData<uint32_t>(array, 1) + array.offset + nested_offset;
 			}
 			SetVectorString(vector, size, cdata, offsets);
 		}
@@ -432,11 +437,11 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowScanLoca
 		}
 		case ArrowDateTimeType::MILLISECONDS: {
 			//! convert date from nanoseconds to days
-			auto src_ptr = (uint64_t *)array.buffers[1] + scan_state.chunk_offset + array.offset;
+			auto src_ptr = ArrowBufferData<uint64_t>(array, 1) + scan_state.chunk_offset + array.offset;
 			if (nested_offset != -1) {
-				src_ptr = (uint64_t *)array.buffers[1] + nested_offset + array.offset;
+				src_ptr = ArrowBufferData<uint64_t>(array, 1) + nested_offset + array.offset;
 			}
-			auto tgt_ptr = (date_t *)FlatVector::GetData(vector);
+			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));
 			}
@@ -463,10 +468,10 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowScanLoca
 			break;
 		}
 		case ArrowDateTimeType::NANOSECONDS: {
-			auto tgt_ptr = (dtime_t *)FlatVector::GetData(vector);
-			auto src_ptr = (int64_t *)array.buffers[1] + scan_state.chunk_offset + array.offset;
+			auto tgt_ptr = FlatVector::GetData<dtime_t>(vector);
+			auto src_ptr = ArrowBufferData<int64_t>(array, 1) + scan_state.chunk_offset + array.offset;
 			if (nested_offset != -1) {
-				src_ptr = (int64_t *)array.buffers[1] + nested_offset + array.offset;
+				src_ptr = ArrowBufferData<int64_t>(array, 1) + nested_offset + array.offset;
 			}
 			for (idx_t row = 0; row < size; row++) {
 				tgt_ptr[row].micros = src_ptr[row] / 1000;
@@ -494,10 +499,10 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowScanLoca
 			break;
 		}
 		case ArrowDateTimeType::NANOSECONDS: {
-			auto tgt_ptr = (timestamp_t *)FlatVector::GetData(vector);
-			auto src_ptr = (int64_t *)array.buffers[1] + scan_state.chunk_offset + array.offset;
+			auto tgt_ptr = FlatVector::GetData<timestamp_t>(vector);
+			auto src_ptr = ArrowBufferData<int64_t>(array, 1) + scan_state.chunk_offset + array.offset;
 			if (nested_offset != -1) {
-				src_ptr = (int64_t *)array.buffers[1] + nested_offset + array.offset;
+				src_ptr = ArrowBufferData<int64_t>(array, 1) + nested_offset + array.offset;
 			}
 			for (idx_t row = 0; row < size; row++) {
 				tgt_ptr[row].value = src_ptr[row] / 1000;
@@ -526,10 +531,10 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowScanLoca
 			break;
 		}
 		case ArrowDateTimeType::NANOSECONDS: {
-			auto tgt_ptr = (interval_t *)FlatVector::GetData(vector);
-			auto src_ptr = (int64_t *)array.buffers[1] + scan_state.chunk_offset + array.offset;
+			auto tgt_ptr = FlatVector::GetData<interval_t>(vector);
+			auto src_ptr = ArrowBufferData<int64_t>(array, 1) + scan_state.chunk_offset + array.offset;
 			if (nested_offset != -1) {
-				src_ptr = (int64_t *)array.buffers[1] + nested_offset + array.offset;
+				src_ptr = ArrowBufferData<int64_t>(array, 1) + nested_offset + array.offset;
 			}
 			for (idx_t row = 0; row < size; row++) {
 				tgt_ptr[row].micros = src_ptr[row] / 1000;
@@ -554,13 +559,13 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowScanLoca
 	case LogicalTypeId::DECIMAL: {
 		auto val_mask = FlatVector::Validity(vector);
 		//! We have to convert from INT128
-		auto src_ptr = (hugeint_t *)array.buffers[1] + scan_state.chunk_offset + array.offset;
+		auto src_ptr = ArrowBufferData<hugeint_t>(array, 1) + scan_state.chunk_offset + array.offset;
 		if (nested_offset != -1) {
-			src_ptr = (hugeint_t *)array.buffers[1] + nested_offset + array.offset;
+			src_ptr = ArrowBufferData<hugeint_t>(array, 1) + nested_offset + array.offset;
 		}
 		switch (vector.GetType().InternalType()) {
 		case PhysicalType::INT16: {
-			auto tgt_ptr = (int16_t *)FlatVector::GetData(vector);
+			auto tgt_ptr = FlatVector::GetData<int16_t>(vector);
 			for (idx_t row = 0; row < size; row++) {
 				if (val_mask.RowIsValid(row)) {
 					auto result = Hugeint::TryCast(src_ptr[row], tgt_ptr[row]);
@@ -571,7 +576,7 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowScanLoca
 			break;
 		}
 		case PhysicalType::INT32: {
-			auto tgt_ptr = (int32_t *)FlatVector::GetData(vector);
+			auto tgt_ptr = FlatVector::GetData<int32_t>(vector);
 			for (idx_t row = 0; row < size; row++) {
 				if (val_mask.RowIsValid(row)) {
 					auto result = Hugeint::TryCast(src_ptr[row], tgt_ptr[row]);
@@ -582,7 +587,7 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowScanLoca
 			break;
 		}
 		case PhysicalType::INT64: {
-			auto tgt_ptr = (int64_t *)FlatVector::GetData(vector);
+			auto tgt_ptr = FlatVector::GetData<int64_t>(vector);
 			for (idx_t row = 0; row < size; row++) {
 				if (val_mask.RowIsValid(row)) {
 					auto result = Hugeint::TryCast(src_ptr[row], tgt_ptr[row]);
@@ -593,8 +598,9 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowScanLoca
 			break;
 		}
 		case PhysicalType::INT128: {
-			FlatVector::SetData(vector, (data_ptr_t)array.buffers[1] + GetTypeIdSize(vector.GetType().InternalType()) *
-			                                                               (scan_state.chunk_offset + array.offset));
+			FlatVector::SetData(vector,
+			                    ArrowBufferData<data_t>(array, 1) + GetTypeIdSize(vector.GetType().InternalType()) *
+			                                                            (scan_state.chunk_offset + array.offset));
 			break;
 		}
 		default:
@@ -645,7 +651,7 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowScanLoca
 
 template <class T>
 static void SetSelectionVectorLoop(SelectionVector &sel, data_ptr_t indices_p, idx_t size) {
-	auto indices = (T *)indices_p;
+	auto indices = reinterpret_cast<T *>(indices_p);
 	for (idx_t row = 0; row < size; row++) {
 		sel.set_index(row, indices[row]);
 	}
@@ -654,7 +660,7 @@ static void SetSelectionVectorLoop(SelectionVector &sel, data_ptr_t indices_p, i
 template <class T>
 static void SetSelectionVectorLoopWithChecks(SelectionVector &sel, data_ptr_t indices_p, idx_t size) {
 
-	auto indices = (T *)indices_p;
+	auto indices = reinterpret_cast<T *>(indices_p);
 	for (idx_t row = 0; row < size; row++) {
 		if (indices[row] > NumericLimits<uint32_t>::Maximum()) {
 			throw ConversionException("DuckDB only supports indices that fit on an uint32");
@@ -666,7 +672,7 @@ static void SetSelectionVectorLoopWithChecks(SelectionVector &sel, data_ptr_t in
 template <class T>
 static void SetMaskedSelectionVectorLoop(SelectionVector &sel, data_ptr_t indices_p, idx_t size, ValidityMask &mask,
                                          idx_t last_element_pos) {
-	auto indices = (T *)indices_p;
+	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]);
@@ -782,7 +788,7 @@ static void ColumnArrowToDuckDBDictionary(Vector &vector, ArrowArray &array, Arr
 	}
 	auto dictionary_type = arrow_convert_data[col_idx]->dictionary_type;
 	//! Get Pointer to Indices of Dictionary
-	auto indices = (data_ptr_t)array.buffers[1] +
+	auto indices = ArrowBufferData<data_t>(array, 1) +
 	               GetTypeIdSize(dictionary_type.InternalType()) * (scan_state.chunk_offset + array.offset);
 	if (array.null_count > 0) {
 		ValidityMask indices_validity;

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

@@ -19,7 +19,7 @@ public:
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const CheckpointBindData &)other_p;
+		auto &other = other_p.Cast<CheckpointBindData>();
 		return db == other.db;
 	}
 };

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

@@ -187,13 +187,13 @@ static bool RequiresQuotes(WriteCSVData &csv_data, const char *str, idx_t len) {
 
 		// check for delimiter
 		if (options.delimiter.length() != 0 &&
-		    ContainsFun::Find((const unsigned char *)str, len, (const unsigned char *)options.delimiter.c_str(),
+		    ContainsFun::Find(const_uchar_ptr_cast(str), len, const_uchar_ptr_cast(options.delimiter.c_str()),
 		                      options.delimiter.size()) != DConstants::INVALID_INDEX) {
 			return true;
 		}
 		// check for quote
 		if (options.quote.length() != 0 &&
-		    ContainsFun::Find((const unsigned char *)str, len, (const unsigned char *)options.quote.c_str(),
+		    ContainsFun::Find(const_uchar_ptr_cast(str), len, const_uchar_ptr_cast(options.quote.c_str()),
 		                      options.quote.size()) != DConstants::INVALID_INDEX) {
 			return true;
 		}
@@ -224,11 +224,11 @@ static void WriteQuotedString(Serializer &serializer, WriteCSVData &csv_data, co
 			// complex CSV
 			// check for quote or escape separately
 			if (options.quote.length() != 0 &&
-			    ContainsFun::Find((const unsigned char *)str, len, (const unsigned char *)options.quote.c_str(),
+			    ContainsFun::Find(const_uchar_ptr_cast(str), len, const_uchar_ptr_cast(options.quote.c_str()),
 			                      options.quote.size()) != DConstants::INVALID_INDEX) {
 				requires_escape = true;
 			} else if (options.escape.length() != 0 &&
-			           ContainsFun::Find((const unsigned char *)str, len, (const unsigned char *)options.escape.c_str(),
+			           ContainsFun::Find(const_uchar_ptr_cast(str), len, const_uchar_ptr_cast(options.escape.c_str()),
 			                             options.escape.size()) != DConstants::INVALID_INDEX) {
 				requires_escape = true;
 			}
@@ -236,7 +236,7 @@ static void WriteQuotedString(Serializer &serializer, WriteCSVData &csv_data, co
 		if (!requires_escape) {
 			// fast path: no need to escape anything
 			serializer.WriteBufferData(options.quote);
-			serializer.WriteData((const_data_ptr_t)str, len);
+			serializer.WriteData(const_data_ptr_cast(str), len);
 			serializer.WriteBufferData(options.quote);
 			return;
 		}
@@ -252,7 +252,7 @@ static void WriteQuotedString(Serializer &serializer, WriteCSVData &csv_data, co
 		serializer.WriteBufferData(new_val);
 		serializer.WriteBufferData(options.quote);
 	} else {
-		serializer.WriteData((const_data_ptr_t)str, len);
+		serializer.WriteData(const_data_ptr_cast(str), len);
 	}
 }
 
@@ -281,6 +281,10 @@ struct GlobalWriteCSVData : public GlobalFunctionData {
 		handle->Write((void *)data, size);
 	}
 
+	void WriteData(const char *data, idx_t size) {
+		WriteData(const_data_ptr_cast(data), size);
+	}
+
 	//! Write rows
 	void WriteRows(const_data_ptr_t data, idx_t size, const string &newline) {
 		lock_guard<mutex> flock(lock);
@@ -321,7 +325,7 @@ static unique_ptr<GlobalFunctionData> WriteCSVInitializeGlobal(ClientContext &co
 	    make_uniq<GlobalWriteCSVData>(FileSystem::GetFileSystem(context), file_path, options.compression);
 
 	if (!options.prefix.empty()) {
-		global_data->WriteData((const_data_ptr_t)options.prefix.c_str(), options.prefix.size());
+		global_data->WriteData(options.prefix.c_str(), options.prefix.size());
 	}
 
 	if (options.header) {

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

@@ -33,7 +33,7 @@ static unique_ptr<GlobalTableFunctionState> GlobFunctionInit(ClientContext &cont
 
 static void GlobFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
 	auto &bind_data = data_p.bind_data->Cast<GlobFunctionBindData>();
-	auto &state = (GlobFunctionState &)*data_p.global_state;
+	auto &state = data_p.global_state->Cast<GlobFunctionState>();
 
 	idx_t count = 0;
 	idx_t next_idx = MinValue<idx_t>(state.current_idx + STANDARD_VECTOR_SIZE, bind_data.files.size());

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

@@ -62,7 +62,7 @@ unique_ptr<GlobalTableFunctionState> PragmaLastProfilingOutputInit(ClientContext
 
 static void PragmaLastProfilingOutputFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
 	auto &state = data_p.global_state->Cast<PragmaLastProfilingOutputOperatorData>();
-	auto &data = (PragmaLastProfilingOutputData &)*data_p.bind_data;
+	auto &data = data_p.bind_data->CastNoConst<PragmaLastProfilingOutputData>();
 	if (!state.initialized) {
 		// create a ColumnDataCollection
 		auto collection = make_uniq<ColumnDataCollection>(context, data.types);

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

@@ -18,7 +18,7 @@ struct RangeFunctionBindData : public TableFunctionData {
 
 public:
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const RangeFunctionBindData &)other_p;
+		auto &other = other_p.Cast<RangeFunctionBindData>();
 		return other.start == start && other.end == end && other.increment == increment;
 	}
 };
@@ -92,7 +92,7 @@ static unique_ptr<GlobalTableFunctionState> RangeFunctionInit(ClientContext &con
 
 static void RangeFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
 	auto &bind_data = data_p.bind_data->Cast<RangeFunctionBindData>();
-	auto &state = (RangeFunctionState &)*data_p.global_state;
+	auto &state = data_p.global_state->Cast<RangeFunctionState>();
 
 	auto increment = bind_data.increment;
 	auto end = bind_data.end;
@@ -129,7 +129,7 @@ struct RangeDateTimeBindData : public TableFunctionData {
 
 public:
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const RangeDateTimeBindData &)other_p;
+		auto &other = other_p.Cast<RangeDateTimeBindData>();
 		return other.start == start && other.end == end && other.increment == increment &&
 		       other.inclusive_bound == inclusive_bound && other.greater_than_check == greater_than_check;
 	}
@@ -213,7 +213,7 @@ static unique_ptr<GlobalTableFunctionState> RangeDateTimeInit(ClientContext &con
 
 static void RangeDateTimeFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
 	auto &bind_data = data_p.bind_data->Cast<RangeDateTimeBindData>();
-	auto &state = (RangeDateTimeState &)*data_p.global_state;
+	auto &state = data_p.global_state->Cast<RangeDateTimeState>();
 	if (state.finished) {
 		return;
 	}

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

@@ -378,8 +378,8 @@ private:
 	//! Current File Number
 	idx_t file_number = 0;
 	idx_t max_tuple_end = 0;
-	//! the vector stores positions where threads ended the last line they read in the CSV File, and the set stores
-	//! positions where they started reading the first line.
+	//! The vector stores positions where threads ended the last line they read in the CSV File, and the set stores
+	//! Positions where they started reading the first line.
 	vector<vector<idx_t>> tuple_end;
 	vector<set<idx_t>> tuple_start;
 	//! Tuple end to batch
@@ -559,15 +559,13 @@ bool ParallelCSVGlobalState::Next(ClientContext &context, const ReadCSVData &bin
 }
 void ParallelCSVGlobalState::UpdateVerification(VerificationPositions positions, idx_t file_number_p, idx_t batch_idx) {
 	lock_guard<mutex> parallel_lock(main_mutex);
-	if (positions.beginning_of_first_line < positions.end_of_last_line) {
-		if (positions.end_of_last_line > max_tuple_end) {
-			max_tuple_end = positions.end_of_last_line;
-		}
-		tuple_end_to_batch[file_number_p][positions.end_of_last_line] = batch_idx;
-		batch_to_tuple_end[file_number_p][batch_idx] = tuple_end[file_number_p].size();
-		tuple_start[file_number_p].insert(positions.beginning_of_first_line);
-		tuple_end[file_number_p].push_back(positions.end_of_last_line);
+	if (positions.end_of_last_line > max_tuple_end) {
+		max_tuple_end = positions.end_of_last_line;
 	}
+	tuple_end_to_batch[file_number_p][positions.end_of_last_line] = batch_idx;
+	batch_to_tuple_end[file_number_p][batch_idx] = tuple_end[file_number_p].size();
+	tuple_start[file_number_p].insert(positions.beginning_of_first_line);
+	tuple_end[file_number_p].push_back(positions.end_of_last_line);
 }
 
 void ParallelCSVGlobalState::UpdateLinesRead(CSVBufferRead &buffer_read, idx_t file_idx) {
@@ -690,17 +688,14 @@ static void ParallelReadCSVFunction(ClientContext &context, TableFunctionInput &
 		}
 		if (csv_local_state.csv_reader->finished) {
 			auto verification_updates = csv_local_state.csv_reader->GetVerificationPositions();
-			if (verification_updates.beginning_of_first_line != verification_updates.end_of_last_line) {
-				csv_global_state.UpdateVerification(verification_updates,
-				                                    csv_local_state.csv_reader->buffer->buffer->GetFileNumber(),
-				                                    csv_local_state.csv_reader->buffer->local_batch_index);
-			}
+			csv_global_state.UpdateVerification(verification_updates,
+			                                    csv_local_state.csv_reader->buffer->buffer->GetFileNumber(),
+			                                    csv_local_state.csv_reader->buffer->local_batch_index);
 			csv_global_state.UpdateLinesRead(*csv_local_state.csv_reader->buffer, csv_local_state.csv_reader->file_idx);
 			auto has_next = csv_global_state.Next(context, bind_data, csv_local_state.csv_reader);
 			if (csv_local_state.csv_reader) {
 				csv_local_state.csv_reader->linenr = 0;
 			}
-
 			if (!has_next) {
 				csv_global_state.DecrementThread();
 				break;
@@ -861,16 +856,16 @@ static unique_ptr<GlobalTableFunctionState> SingleThreadedCSVInit(ClientContext
 unique_ptr<LocalTableFunctionState> SingleThreadedReadCSVInitLocal(ExecutionContext &context,
                                                                    TableFunctionInitInput &input,
                                                                    GlobalTableFunctionState *global_state_p) {
-	auto &bind_data = (ReadCSVData &)*input.bind_data;
-	auto &data = (SingleThreadedCSVState &)*global_state_p;
+	auto &bind_data = input.bind_data->CastNoConst<ReadCSVData>();
+	auto &data = global_state_p->Cast<SingleThreadedCSVState>();
 	auto result = make_uniq<SingleThreadedCSVLocalState>();
 	result->csv_reader = data.GetCSVReader(context.client, bind_data, result->file_index, result->total_size);
 	return std::move(result);
 }
 
 static void SingleThreadedCSVFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = (ReadCSVData &)*data_p.bind_data;
-	auto &data = (SingleThreadedCSVState &)*data_p.global_state;
+	auto &bind_data = data_p.bind_data->CastNoConst<ReadCSVData>();
+	auto &data = data_p.global_state->Cast<SingleThreadedCSVState>();
 	auto &lstate = data_p.local_state->Cast<SingleThreadedCSVLocalState>();
 	if (!lstate.csv_reader) {
 		// no csv_reader was set, this can happen when a filename-based filter has filtered out all possible files

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

@@ -31,7 +31,7 @@ static unique_ptr<GlobalTableFunctionState> RepeatInit(ClientContext &context, T
 }
 
 static void RepeatFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = (const RepeatFunctionData &)*data_p.bind_data;
+	auto &bind_data = data_p.bind_data->Cast<RepeatFunctionData>();
 	auto &state = data_p.global_state->Cast<RepeatOperatorData>();
 
 	idx_t remaining = MinValue<idx_t>(bind_data.target_count - state.current_count, STANDARD_VECTOR_SIZE);
@@ -41,7 +41,7 @@ static void RepeatFunction(ClientContext &context, TableFunctionInput &data_p, D
 }
 
 static unique_ptr<NodeStatistics> RepeatCardinality(ClientContext &context, const FunctionData *bind_data_p) {
-	auto &bind_data = (const RepeatFunctionData &)*bind_data_p;
+	auto &bind_data = bind_data_p->Cast<RepeatFunctionData>();
 	return make_uniq<NodeStatistics>(bind_data.target_count, bind_data.target_count);
 }