1mod decimal;
41mod dictionary;
42mod list;
43mod map;
44mod string;
45use crate::cast::decimal::*;
46use crate::cast::dictionary::*;
47use crate::cast::list::*;
48use crate::cast::map::*;
49use crate::cast::string::*;
50
51use arrow_buffer::IntervalMonthDayNano;
52use arrow_data::ByteView;
53use chrono::{NaiveTime, Offset, TimeZone, Utc};
54use std::cmp::Ordering;
55use std::sync::Arc;
56
57use crate::display::{ArrayFormatter, FormatOptions};
58use crate::parse::{
59 parse_interval_day_time, parse_interval_month_day_nano, parse_interval_year_month,
60 string_to_datetime, Parser,
61};
62use arrow_array::{builder::*, cast::*, temporal_conversions::*, timezone::Tz, types::*, *};
63use arrow_buffer::{i256, ArrowNativeType, OffsetBuffer};
64use arrow_data::transform::MutableArrayData;
65use arrow_data::ArrayData;
66use arrow_schema::*;
67use arrow_select::take::take;
68use num::cast::AsPrimitive;
69use num::{NumCast, ToPrimitive};
70
71#[derive(Debug, Clone, PartialEq, Eq, Hash)]
73pub struct CastOptions<'a> {
74 pub safe: bool,
76 pub format_options: FormatOptions<'a>,
78}
79
80impl Default for CastOptions<'_> {
81 fn default() -> Self {
82 Self {
83 safe: true,
84 format_options: FormatOptions::default(),
85 }
86 }
87}
88
89pub fn can_cast_types(from_type: &DataType, to_type: &DataType) -> bool {
93 use self::DataType::*;
94 use self::IntervalUnit::*;
95 use self::TimeUnit::*;
96 if from_type == to_type {
97 return true;
98 }
99
100 match (from_type, to_type) {
101 (
102 Null,
103 Boolean
104 | Int8
105 | UInt8
106 | Int16
107 | UInt16
108 | Int32
109 | UInt32
110 | Float32
111 | Date32
112 | Time32(_)
113 | Int64
114 | UInt64
115 | Float64
116 | Date64
117 | Timestamp(_, _)
118 | Time64(_)
119 | Duration(_)
120 | Interval(_)
121 | FixedSizeBinary(_)
122 | Binary
123 | Utf8
124 | LargeBinary
125 | LargeUtf8
126 | BinaryView
127 | Utf8View
128 | List(_)
129 | LargeList(_)
130 | FixedSizeList(_, _)
131 | Struct(_)
132 | Map(_, _)
133 | Dictionary(_, _),
134 ) => true,
135 (Dictionary(_, from_value_type), Dictionary(_, to_value_type)) => {
137 can_cast_types(from_value_type, to_value_type)
138 }
139 (Dictionary(_, value_type), _) => can_cast_types(value_type, to_type),
140 (_, Dictionary(_, value_type)) => can_cast_types(from_type, value_type),
141 (List(list_from) | LargeList(list_from), List(list_to) | LargeList(list_to)) => {
142 can_cast_types(list_from.data_type(), list_to.data_type())
143 }
144 (List(list_from) | LargeList(list_from), Utf8 | LargeUtf8) => {
145 can_cast_types(list_from.data_type(), to_type)
146 }
147 (List(list_from) | LargeList(list_from), FixedSizeList(list_to, _)) => {
148 can_cast_types(list_from.data_type(), list_to.data_type())
149 }
150 (List(_), _) => false,
151 (FixedSizeList(list_from, _), List(list_to))
152 | (FixedSizeList(list_from, _), LargeList(list_to)) => {
153 can_cast_types(list_from.data_type(), list_to.data_type())
154 }
155 (FixedSizeList(inner, size), FixedSizeList(inner_to, size_to)) if size == size_to => {
156 can_cast_types(inner.data_type(), inner_to.data_type())
157 }
158 (_, List(list_to)) => can_cast_types(from_type, list_to.data_type()),
159 (_, LargeList(list_to)) => can_cast_types(from_type, list_to.data_type()),
160 (_, FixedSizeList(list_to, size)) if *size == 1 => {
161 can_cast_types(from_type, list_to.data_type())
162 }
163 (FixedSizeList(list_from, size), _) if *size == 1 => {
164 can_cast_types(list_from.data_type(), to_type)
165 }
166 (Map(from_entries, ordered_from), Map(to_entries, ordered_to))
167 if ordered_from == ordered_to =>
168 {
169 match (
170 key_field(from_entries),
171 key_field(to_entries),
172 value_field(from_entries),
173 value_field(to_entries),
174 ) {
175 (Some(from_key), Some(to_key), Some(from_value), Some(to_value)) => {
176 can_cast_types(from_key.data_type(), to_key.data_type())
177 && can_cast_types(from_value.data_type(), to_value.data_type())
178 }
179 _ => false,
180 }
181 }
182 (
184 Decimal32(_, _) | Decimal64(_, _) | Decimal128(_, _) | Decimal256(_, _),
185 Decimal32(_, _) | Decimal64(_, _) | Decimal128(_, _) | Decimal256(_, _),
186 ) => true,
187 (
189 UInt8 | UInt16 | UInt32 | UInt64,
190 Decimal32(_, _) | Decimal64(_, _) | Decimal128(_, _) | Decimal256(_, _),
191 ) => true,
192 (
194 Null | Int8 | Int16 | Int32 | Int64 | Float32 | Float64,
195 Decimal32(_, _) | Decimal64(_, _) | Decimal128(_, _) | Decimal256(_, _),
196 ) => true,
197 (
199 Decimal32(_, _) | Decimal64(_, _) | Decimal128(_, _) | Decimal256(_, _),
200 UInt8 | UInt16 | UInt32 | UInt64,
201 ) => true,
202 (
204 Decimal32(_, _) | Decimal64(_, _) | Decimal128(_, _) | Decimal256(_, _),
205 Null | Int8 | Int16 | Int32 | Int64 | Float32 | Float64,
206 ) => true,
207 (
209 Decimal32(_, _) | Decimal64(_, _) | Decimal128(_, _) | Decimal256(_, _),
210 Utf8View | Utf8 | LargeUtf8,
211 ) => true,
212 (
214 Utf8View | Utf8 | LargeUtf8,
215 Decimal32(_, _) | Decimal64(_, _) | Decimal128(_, _) | Decimal256(_, _),
216 ) => true,
217 (Struct(from_fields), Struct(to_fields)) => {
218 from_fields.len() == to_fields.len()
219 && from_fields.iter().zip(to_fields.iter()).all(|(f1, f2)| {
220 can_cast_types(f1.data_type(), f2.data_type())
223 })
224 }
225 (Struct(_), _) => false,
226 (_, Struct(_)) => false,
227 (_, Boolean) => {
228 DataType::is_integer(from_type)
229 || DataType::is_floating(from_type)
230 || from_type == &Utf8View
231 || from_type == &Utf8
232 || from_type == &LargeUtf8
233 }
234 (Boolean, _) => {
235 DataType::is_integer(to_type)
236 || DataType::is_floating(to_type)
237 || to_type == &Utf8View
238 || to_type == &Utf8
239 || to_type == &LargeUtf8
240 }
241
242 (Binary, LargeBinary | Utf8 | LargeUtf8 | FixedSizeBinary(_) | BinaryView | Utf8View) => {
243 true
244 }
245 (LargeBinary, Binary | Utf8 | LargeUtf8 | FixedSizeBinary(_) | BinaryView | Utf8View) => {
246 true
247 }
248 (FixedSizeBinary(_), Binary | LargeBinary | BinaryView) => true,
249 (
250 Utf8 | LargeUtf8 | Utf8View,
251 Binary
252 | LargeBinary
253 | Utf8
254 | LargeUtf8
255 | Date32
256 | Date64
257 | Time32(Second)
258 | Time32(Millisecond)
259 | Time64(Microsecond)
260 | Time64(Nanosecond)
261 | Timestamp(Second, _)
262 | Timestamp(Millisecond, _)
263 | Timestamp(Microsecond, _)
264 | Timestamp(Nanosecond, _)
265 | Interval(_)
266 | BinaryView,
267 ) => true,
268 (Utf8 | LargeUtf8, Utf8View) => true,
269 (BinaryView, Binary | LargeBinary | Utf8 | LargeUtf8 | Utf8View) => true,
270 (Utf8View | Utf8 | LargeUtf8, _) => to_type.is_numeric() && to_type != &Float16,
271 (_, Utf8 | LargeUtf8) => from_type.is_primitive(),
272 (_, Utf8View) => from_type.is_numeric(),
273
274 (_, Binary | LargeBinary) => from_type.is_integer(),
275
276 (
278 UInt8 | UInt16 | UInt32 | UInt64 | Int8 | Int16 | Int32 | Int64 | Float16 | Float32
279 | Float64,
280 UInt8 | UInt16 | UInt32 | UInt64 | Int8 | Int16 | Int32 | Int64 | Float16 | Float32
281 | Float64,
282 ) => true,
283 (Int32, Date32 | Date64 | Time32(_)) => true,
287 (Date32, Int32 | Int64) => true,
288 (Time32(_), Int32) => true,
289 (Int64, Date64 | Date32 | Time64(_)) => true,
290 (Date64, Int64 | Int32) => true,
291 (Time64(_), Int64) => true,
292 (Date32 | Date64, Date32 | Date64) => true,
293 (Time32(_), Time32(_)) => true,
295 (Time32(_), Time64(_)) => true,
296 (Time64(_), Time64(_)) => true,
297 (Time64(_), Time32(to_unit)) => {
298 matches!(to_unit, Second | Millisecond)
299 }
300 (Timestamp(_, _), _) if to_type.is_numeric() => true,
301 (_, Timestamp(_, _)) if from_type.is_numeric() => true,
302 (Date64, Timestamp(_, _)) => true,
303 (Date32, Timestamp(_, _)) => true,
304 (
305 Timestamp(_, _),
306 Timestamp(_, _)
307 | Date32
308 | Date64
309 | Time32(Second)
310 | Time32(Millisecond)
311 | Time64(Microsecond)
312 | Time64(Nanosecond),
313 ) => true,
314 (_, Duration(_)) if from_type.is_numeric() => true,
315 (Duration(_), _) if to_type.is_numeric() => true,
316 (Duration(_), Duration(_)) => true,
317 (Interval(from_type), Int64) => {
318 match from_type {
319 YearMonth => true,
320 DayTime => true,
321 MonthDayNano => false, }
323 }
324 (Int32, Interval(to_type)) => match to_type {
325 YearMonth => true,
326 DayTime => false,
327 MonthDayNano => false,
328 },
329 (Duration(_), Interval(MonthDayNano)) => true,
330 (Interval(MonthDayNano), Duration(_)) => true,
331 (Interval(YearMonth), Interval(MonthDayNano)) => true,
332 (Interval(DayTime), Interval(MonthDayNano)) => true,
333 (_, _) => false,
334 }
335}
336
337pub fn cast(array: &dyn Array, to_type: &DataType) -> Result<ArrayRef, ArrowError> {
341 cast_with_options(array, to_type, &CastOptions::default())
342}
343
344fn cast_integer_to_decimal<
345 T: ArrowPrimitiveType,
346 D: DecimalType + ArrowPrimitiveType<Native = M>,
347 M,
348>(
349 array: &PrimitiveArray<T>,
350 precision: u8,
351 scale: i8,
352 base: M,
353 cast_options: &CastOptions,
354) -> Result<ArrayRef, ArrowError>
355where
356 <T as ArrowPrimitiveType>::Native: AsPrimitive<M>,
357 M: ArrowNativeTypeOp,
358{
359 let scale_factor = base.pow_checked(scale.unsigned_abs() as u32).map_err(|_| {
360 ArrowError::CastError(format!(
361 "Cannot cast to {:?}({}, {}). The scale causes overflow.",
362 D::PREFIX,
363 precision,
364 scale,
365 ))
366 })?;
367
368 let array = if scale < 0 {
369 match cast_options.safe {
370 true => array.unary_opt::<_, D>(|v| {
371 v.as_()
372 .div_checked(scale_factor)
373 .ok()
374 .and_then(|v| (D::is_valid_decimal_precision(v, precision)).then_some(v))
375 }),
376 false => array.try_unary::<_, D, _>(|v| {
377 v.as_()
378 .div_checked(scale_factor)
379 .and_then(|v| D::validate_decimal_precision(v, precision).map(|_| v))
380 })?,
381 }
382 } else {
383 match cast_options.safe {
384 true => array.unary_opt::<_, D>(|v| {
385 v.as_()
386 .mul_checked(scale_factor)
387 .ok()
388 .and_then(|v| (D::is_valid_decimal_precision(v, precision)).then_some(v))
389 }),
390 false => array.try_unary::<_, D, _>(|v| {
391 v.as_()
392 .mul_checked(scale_factor)
393 .and_then(|v| D::validate_decimal_precision(v, precision).map(|_| v))
394 })?,
395 }
396 };
397
398 Ok(Arc::new(array.with_precision_and_scale(precision, scale)?))
399}
400
401fn cast_interval_year_month_to_interval_month_day_nano(
403 array: &dyn Array,
404 _cast_options: &CastOptions,
405) -> Result<ArrayRef, ArrowError> {
406 let array = array.as_primitive::<IntervalYearMonthType>();
407
408 Ok(Arc::new(array.unary::<_, IntervalMonthDayNanoType>(|v| {
409 let months = IntervalYearMonthType::to_months(v);
410 IntervalMonthDayNanoType::make_value(months, 0, 0)
411 })))
412}
413
414fn cast_interval_day_time_to_interval_month_day_nano(
416 array: &dyn Array,
417 _cast_options: &CastOptions,
418) -> Result<ArrayRef, ArrowError> {
419 let array = array.as_primitive::<IntervalDayTimeType>();
420 let mul = 1_000_000;
421
422 Ok(Arc::new(array.unary::<_, IntervalMonthDayNanoType>(|v| {
423 let (days, ms) = IntervalDayTimeType::to_parts(v);
424 IntervalMonthDayNanoType::make_value(0, days, ms as i64 * mul)
425 })))
426}
427
428fn cast_month_day_nano_to_duration<D: ArrowTemporalType<Native = i64>>(
430 array: &dyn Array,
431 cast_options: &CastOptions,
432) -> Result<ArrayRef, ArrowError> {
433 let array = array.as_primitive::<IntervalMonthDayNanoType>();
434 let scale = match D::DATA_TYPE {
435 DataType::Duration(TimeUnit::Second) => 1_000_000_000,
436 DataType::Duration(TimeUnit::Millisecond) => 1_000_000,
437 DataType::Duration(TimeUnit::Microsecond) => 1_000,
438 DataType::Duration(TimeUnit::Nanosecond) => 1,
439 _ => unreachable!(),
440 };
441
442 if cast_options.safe {
443 let iter = array.iter().map(|v| {
444 v.and_then(|v| (v.days == 0 && v.months == 0).then_some(v.nanoseconds / scale))
445 });
446 Ok(Arc::new(unsafe {
447 PrimitiveArray::<D>::from_trusted_len_iter(iter)
448 }))
449 } else {
450 let vec = array
451 .iter()
452 .map(|v| {
453 v.map(|v| match v.days == 0 && v.months == 0 {
454 true => Ok((v.nanoseconds) / scale),
455 _ => Err(ArrowError::ComputeError(
456 "Cannot convert interval containing non-zero months or days to duration"
457 .to_string(),
458 )),
459 })
460 .transpose()
461 })
462 .collect::<Result<Vec<_>, _>>()?;
463 Ok(Arc::new(unsafe {
464 PrimitiveArray::<D>::from_trusted_len_iter(vec.iter())
465 }))
466 }
467}
468
469fn cast_duration_to_interval<D: ArrowTemporalType<Native = i64>>(
471 array: &dyn Array,
472 cast_options: &CastOptions,
473) -> Result<ArrayRef, ArrowError> {
474 let array = array
475 .as_any()
476 .downcast_ref::<PrimitiveArray<D>>()
477 .ok_or_else(|| {
478 ArrowError::ComputeError(
479 "Internal Error: Cannot cast duration to DurationArray of expected type"
480 .to_string(),
481 )
482 })?;
483
484 let scale = match array.data_type() {
485 DataType::Duration(TimeUnit::Second) => 1_000_000_000,
486 DataType::Duration(TimeUnit::Millisecond) => 1_000_000,
487 DataType::Duration(TimeUnit::Microsecond) => 1_000,
488 DataType::Duration(TimeUnit::Nanosecond) => 1,
489 _ => unreachable!(),
490 };
491
492 if cast_options.safe {
493 let iter = array.iter().map(|v| {
494 v.and_then(|v| {
495 v.checked_mul(scale)
496 .map(|v| IntervalMonthDayNano::new(0, 0, v))
497 })
498 });
499 Ok(Arc::new(unsafe {
500 PrimitiveArray::<IntervalMonthDayNanoType>::from_trusted_len_iter(iter)
501 }))
502 } else {
503 let vec = array
504 .iter()
505 .map(|v| {
506 v.map(|v| {
507 if let Ok(v) = v.mul_checked(scale) {
508 Ok(IntervalMonthDayNano::new(0, 0, v))
509 } else {
510 Err(ArrowError::ComputeError(format!(
511 "Cannot cast to {:?}. Overflowing on {:?}",
512 IntervalMonthDayNanoType::DATA_TYPE,
513 v
514 )))
515 }
516 })
517 .transpose()
518 })
519 .collect::<Result<Vec<_>, _>>()?;
520 Ok(Arc::new(unsafe {
521 PrimitiveArray::<IntervalMonthDayNanoType>::from_trusted_len_iter(vec.iter())
522 }))
523 }
524}
525
526fn cast_reinterpret_arrays<I: ArrowPrimitiveType, O: ArrowPrimitiveType<Native = I::Native>>(
528 array: &dyn Array,
529) -> Result<ArrayRef, ArrowError> {
530 Ok(Arc::new(array.as_primitive::<I>().reinterpret_cast::<O>()))
531}
532
533fn make_timestamp_array(
534 array: &PrimitiveArray<Int64Type>,
535 unit: TimeUnit,
536 tz: Option<Arc<str>>,
537) -> ArrayRef {
538 match unit {
539 TimeUnit::Second => Arc::new(
540 array
541 .reinterpret_cast::<TimestampSecondType>()
542 .with_timezone_opt(tz),
543 ),
544 TimeUnit::Millisecond => Arc::new(
545 array
546 .reinterpret_cast::<TimestampMillisecondType>()
547 .with_timezone_opt(tz),
548 ),
549 TimeUnit::Microsecond => Arc::new(
550 array
551 .reinterpret_cast::<TimestampMicrosecondType>()
552 .with_timezone_opt(tz),
553 ),
554 TimeUnit::Nanosecond => Arc::new(
555 array
556 .reinterpret_cast::<TimestampNanosecondType>()
557 .with_timezone_opt(tz),
558 ),
559 }
560}
561
562fn make_duration_array(array: &PrimitiveArray<Int64Type>, unit: TimeUnit) -> ArrayRef {
563 match unit {
564 TimeUnit::Second => Arc::new(array.reinterpret_cast::<DurationSecondType>()),
565 TimeUnit::Millisecond => Arc::new(array.reinterpret_cast::<DurationMillisecondType>()),
566 TimeUnit::Microsecond => Arc::new(array.reinterpret_cast::<DurationMicrosecondType>()),
567 TimeUnit::Nanosecond => Arc::new(array.reinterpret_cast::<DurationNanosecondType>()),
568 }
569}
570
571fn as_time_res_with_timezone<T: ArrowPrimitiveType>(
572 v: i64,
573 tz: Option<Tz>,
574) -> Result<NaiveTime, ArrowError> {
575 let time = match tz {
576 Some(tz) => as_datetime_with_timezone::<T>(v, tz).map(|d| d.time()),
577 None => as_datetime::<T>(v).map(|d| d.time()),
578 };
579
580 time.ok_or_else(|| {
581 ArrowError::CastError(format!(
582 "Failed to create naive time with {} {}",
583 std::any::type_name::<T>(),
584 v
585 ))
586 })
587}
588
589fn timestamp_to_date32<T: ArrowTimestampType>(
590 array: &PrimitiveArray<T>,
591) -> Result<ArrayRef, ArrowError> {
592 let err = |x: i64| {
593 ArrowError::CastError(format!(
594 "Cannot convert {} {x} to datetime",
595 std::any::type_name::<T>()
596 ))
597 };
598
599 let array: Date32Array = match array.timezone() {
600 Some(tz) => {
601 let tz: Tz = tz.parse()?;
602 array.try_unary(|x| {
603 as_datetime_with_timezone::<T>(x, tz)
604 .ok_or_else(|| err(x))
605 .map(|d| Date32Type::from_naive_date(d.date_naive()))
606 })?
607 }
608 None => array.try_unary(|x| {
609 as_datetime::<T>(x)
610 .ok_or_else(|| err(x))
611 .map(|d| Date32Type::from_naive_date(d.date()))
612 })?,
613 };
614 Ok(Arc::new(array))
615}
616
617pub fn cast_with_options(
747 array: &dyn Array,
748 to_type: &DataType,
749 cast_options: &CastOptions,
750) -> Result<ArrayRef, ArrowError> {
751 use DataType::*;
752 let from_type = array.data_type();
753 if from_type == to_type {
755 return Ok(make_array(array.to_data()));
756 }
757 match (from_type, to_type) {
758 (
759 Null,
760 Boolean
761 | Int8
762 | UInt8
763 | Int16
764 | UInt16
765 | Int32
766 | UInt32
767 | Float32
768 | Date32
769 | Time32(_)
770 | Int64
771 | UInt64
772 | Float64
773 | Date64
774 | Timestamp(_, _)
775 | Time64(_)
776 | Duration(_)
777 | Interval(_)
778 | FixedSizeBinary(_)
779 | Binary
780 | Utf8
781 | LargeBinary
782 | LargeUtf8
783 | BinaryView
784 | Utf8View
785 | List(_)
786 | LargeList(_)
787 | FixedSizeList(_, _)
788 | Struct(_)
789 | Map(_, _)
790 | Dictionary(_, _),
791 ) => Ok(new_null_array(to_type, array.len())),
792 (Dictionary(index_type, _), _) => match **index_type {
793 Int8 => dictionary_cast::<Int8Type>(array, to_type, cast_options),
794 Int16 => dictionary_cast::<Int16Type>(array, to_type, cast_options),
795 Int32 => dictionary_cast::<Int32Type>(array, to_type, cast_options),
796 Int64 => dictionary_cast::<Int64Type>(array, to_type, cast_options),
797 UInt8 => dictionary_cast::<UInt8Type>(array, to_type, cast_options),
798 UInt16 => dictionary_cast::<UInt16Type>(array, to_type, cast_options),
799 UInt32 => dictionary_cast::<UInt32Type>(array, to_type, cast_options),
800 UInt64 => dictionary_cast::<UInt64Type>(array, to_type, cast_options),
801 _ => Err(ArrowError::CastError(format!(
802 "Casting from dictionary type {from_type:?} to {to_type:?} not supported",
803 ))),
804 },
805 (_, Dictionary(index_type, value_type)) => match **index_type {
806 Int8 => cast_to_dictionary::<Int8Type>(array, value_type, cast_options),
807 Int16 => cast_to_dictionary::<Int16Type>(array, value_type, cast_options),
808 Int32 => cast_to_dictionary::<Int32Type>(array, value_type, cast_options),
809 Int64 => cast_to_dictionary::<Int64Type>(array, value_type, cast_options),
810 UInt8 => cast_to_dictionary::<UInt8Type>(array, value_type, cast_options),
811 UInt16 => cast_to_dictionary::<UInt16Type>(array, value_type, cast_options),
812 UInt32 => cast_to_dictionary::<UInt32Type>(array, value_type, cast_options),
813 UInt64 => cast_to_dictionary::<UInt64Type>(array, value_type, cast_options),
814 _ => Err(ArrowError::CastError(format!(
815 "Casting from type {from_type:?} to dictionary type {to_type:?} not supported",
816 ))),
817 },
818 (List(_), List(to)) => cast_list_values::<i32>(array, to, cast_options),
819 (LargeList(_), LargeList(to)) => cast_list_values::<i64>(array, to, cast_options),
820 (List(_), LargeList(list_to)) => cast_list::<i32, i64>(array, list_to, cast_options),
821 (LargeList(_), List(list_to)) => cast_list::<i64, i32>(array, list_to, cast_options),
822 (List(_), FixedSizeList(field, size)) => {
823 let array = array.as_list::<i32>();
824 cast_list_to_fixed_size_list::<i32>(array, field, *size, cast_options)
825 }
826 (LargeList(_), FixedSizeList(field, size)) => {
827 let array = array.as_list::<i64>();
828 cast_list_to_fixed_size_list::<i64>(array, field, *size, cast_options)
829 }
830 (List(_) | LargeList(_), _) => match to_type {
831 Utf8 => value_to_string::<i32>(array, cast_options),
832 LargeUtf8 => value_to_string::<i64>(array, cast_options),
833 _ => Err(ArrowError::CastError(
834 "Cannot cast list to non-list data types".to_string(),
835 )),
836 },
837 (FixedSizeList(list_from, size), List(list_to)) => {
838 if list_to.data_type() != list_from.data_type() {
839 let fsl_to = DataType::FixedSizeList(list_to.clone(), *size);
841 let array = cast_with_options(array, &fsl_to, cast_options)?;
842 cast_fixed_size_list_to_list::<i32>(array.as_ref())
843 } else {
844 cast_fixed_size_list_to_list::<i32>(array)
845 }
846 }
847 (FixedSizeList(list_from, size), LargeList(list_to)) => {
848 if list_to.data_type() != list_from.data_type() {
849 let fsl_to = DataType::FixedSizeList(list_to.clone(), *size);
851 let array = cast_with_options(array, &fsl_to, cast_options)?;
852 cast_fixed_size_list_to_list::<i64>(array.as_ref())
853 } else {
854 cast_fixed_size_list_to_list::<i64>(array)
855 }
856 }
857 (FixedSizeList(_, size_from), FixedSizeList(list_to, size_to)) => {
858 if size_from != size_to {
859 return Err(ArrowError::CastError(
860 "cannot cast fixed-size-list to fixed-size-list with different size".into(),
861 ));
862 }
863 let array = array.as_any().downcast_ref::<FixedSizeListArray>().unwrap();
864 let values = cast_with_options(array.values(), list_to.data_type(), cast_options)?;
865 Ok(Arc::new(FixedSizeListArray::try_new(
866 list_to.clone(),
867 *size_from,
868 values,
869 array.nulls().cloned(),
870 )?))
871 }
872 (_, List(ref to)) => cast_values_to_list::<i32>(array, to, cast_options),
873 (_, LargeList(ref to)) => cast_values_to_list::<i64>(array, to, cast_options),
874 (_, FixedSizeList(ref to, size)) if *size == 1 => {
875 cast_values_to_fixed_size_list(array, to, *size, cast_options)
876 }
877 (FixedSizeList(_, size), _) if *size == 1 => {
878 cast_single_element_fixed_size_list_to_values(array, to_type, cast_options)
879 }
880 (Map(_, ordered1), Map(_, ordered2)) if ordered1 == ordered2 => {
881 cast_map_values(array.as_map(), to_type, cast_options, ordered1.to_owned())
882 }
883 (Decimal32(p1, s1), Decimal32(p2, s2)) => {
885 cast_decimal_to_decimal_same_type::<Decimal32Type>(
886 array.as_primitive(),
887 *p1,
888 *s1,
889 *p2,
890 *s2,
891 cast_options,
892 )
893 }
894 (Decimal64(p1, s1), Decimal64(p2, s2)) => {
895 cast_decimal_to_decimal_same_type::<Decimal64Type>(
896 array.as_primitive(),
897 *p1,
898 *s1,
899 *p2,
900 *s2,
901 cast_options,
902 )
903 }
904 (Decimal128(p1, s1), Decimal128(p2, s2)) => {
905 cast_decimal_to_decimal_same_type::<Decimal128Type>(
906 array.as_primitive(),
907 *p1,
908 *s1,
909 *p2,
910 *s2,
911 cast_options,
912 )
913 }
914 (Decimal256(p1, s1), Decimal256(p2, s2)) => {
915 cast_decimal_to_decimal_same_type::<Decimal256Type>(
916 array.as_primitive(),
917 *p1,
918 *s1,
919 *p2,
920 *s2,
921 cast_options,
922 )
923 }
924 (Decimal32(p1, s1), Decimal64(p2, s2)) => {
926 cast_decimal_to_decimal::<Decimal32Type, Decimal64Type>(
927 array.as_primitive(),
928 *p1,
929 *s1,
930 *p2,
931 *s2,
932 cast_options,
933 )
934 }
935 (Decimal32(p1, s1), Decimal128(p2, s2)) => {
936 cast_decimal_to_decimal::<Decimal32Type, Decimal128Type>(
937 array.as_primitive(),
938 *p1,
939 *s1,
940 *p2,
941 *s2,
942 cast_options,
943 )
944 }
945 (Decimal32(p1, s1), Decimal256(p2, s2)) => {
946 cast_decimal_to_decimal::<Decimal32Type, Decimal256Type>(
947 array.as_primitive(),
948 *p1,
949 *s1,
950 *p2,
951 *s2,
952 cast_options,
953 )
954 }
955 (Decimal64(p1, s1), Decimal32(p2, s2)) => {
956 cast_decimal_to_decimal::<Decimal64Type, Decimal32Type>(
957 array.as_primitive(),
958 *p1,
959 *s1,
960 *p2,
961 *s2,
962 cast_options,
963 )
964 }
965 (Decimal64(p1, s1), Decimal128(p2, s2)) => {
966 cast_decimal_to_decimal::<Decimal64Type, Decimal128Type>(
967 array.as_primitive(),
968 *p1,
969 *s1,
970 *p2,
971 *s2,
972 cast_options,
973 )
974 }
975 (Decimal64(p1, s1), Decimal256(p2, s2)) => {
976 cast_decimal_to_decimal::<Decimal64Type, Decimal256Type>(
977 array.as_primitive(),
978 *p1,
979 *s1,
980 *p2,
981 *s2,
982 cast_options,
983 )
984 }
985 (Decimal128(p1, s1), Decimal32(p2, s2)) => {
986 cast_decimal_to_decimal::<Decimal128Type, Decimal32Type>(
987 array.as_primitive(),
988 *p1,
989 *s1,
990 *p2,
991 *s2,
992 cast_options,
993 )
994 }
995 (Decimal128(p1, s1), Decimal64(p2, s2)) => {
996 cast_decimal_to_decimal::<Decimal128Type, Decimal64Type>(
997 array.as_primitive(),
998 *p1,
999 *s1,
1000 *p2,
1001 *s2,
1002 cast_options,
1003 )
1004 }
1005 (Decimal128(p1, s1), Decimal256(p2, s2)) => {
1006 cast_decimal_to_decimal::<Decimal128Type, Decimal256Type>(
1007 array.as_primitive(),
1008 *p1,
1009 *s1,
1010 *p2,
1011 *s2,
1012 cast_options,
1013 )
1014 }
1015 (Decimal256(p1, s1), Decimal32(p2, s2)) => {
1016 cast_decimal_to_decimal::<Decimal256Type, Decimal32Type>(
1017 array.as_primitive(),
1018 *p1,
1019 *s1,
1020 *p2,
1021 *s2,
1022 cast_options,
1023 )
1024 }
1025 (Decimal256(p1, s1), Decimal64(p2, s2)) => {
1026 cast_decimal_to_decimal::<Decimal256Type, Decimal64Type>(
1027 array.as_primitive(),
1028 *p1,
1029 *s1,
1030 *p2,
1031 *s2,
1032 cast_options,
1033 )
1034 }
1035 (Decimal256(p1, s1), Decimal128(p2, s2)) => {
1036 cast_decimal_to_decimal::<Decimal256Type, Decimal128Type>(
1037 array.as_primitive(),
1038 *p1,
1039 *s1,
1040 *p2,
1041 *s2,
1042 cast_options,
1043 )
1044 }
1045 (Decimal32(_, scale), _) if !to_type.is_temporal() => {
1047 cast_from_decimal::<Decimal32Type, _>(
1048 array,
1049 10_i32,
1050 scale,
1051 from_type,
1052 to_type,
1053 |x: i32| x as f64,
1054 cast_options,
1055 )
1056 }
1057 (Decimal64(_, scale), _) if !to_type.is_temporal() => {
1058 cast_from_decimal::<Decimal64Type, _>(
1059 array,
1060 10_i64,
1061 scale,
1062 from_type,
1063 to_type,
1064 |x: i64| x as f64,
1065 cast_options,
1066 )
1067 }
1068 (Decimal128(_, scale), _) if !to_type.is_temporal() => {
1069 cast_from_decimal::<Decimal128Type, _>(
1070 array,
1071 10_i128,
1072 scale,
1073 from_type,
1074 to_type,
1075 |x: i128| x as f64,
1076 cast_options,
1077 )
1078 }
1079 (Decimal256(_, scale), _) if !to_type.is_temporal() => {
1080 cast_from_decimal::<Decimal256Type, _>(
1081 array,
1082 i256::from_i128(10_i128),
1083 scale,
1084 from_type,
1085 to_type,
1086 |x: i256| x.to_f64().expect("All i256 values fit in f64"),
1087 cast_options,
1088 )
1089 }
1090 (_, Decimal32(precision, scale)) if !from_type.is_temporal() => {
1092 cast_to_decimal::<Decimal32Type, _>(
1093 array,
1094 10_i32,
1095 precision,
1096 scale,
1097 from_type,
1098 to_type,
1099 cast_options,
1100 )
1101 }
1102 (_, Decimal64(precision, scale)) if !from_type.is_temporal() => {
1103 cast_to_decimal::<Decimal64Type, _>(
1104 array,
1105 10_i64,
1106 precision,
1107 scale,
1108 from_type,
1109 to_type,
1110 cast_options,
1111 )
1112 }
1113 (_, Decimal128(precision, scale)) if !from_type.is_temporal() => {
1114 cast_to_decimal::<Decimal128Type, _>(
1115 array,
1116 10_i128,
1117 precision,
1118 scale,
1119 from_type,
1120 to_type,
1121 cast_options,
1122 )
1123 }
1124 (_, Decimal256(precision, scale)) if !from_type.is_temporal() => {
1125 cast_to_decimal::<Decimal256Type, _>(
1126 array,
1127 i256::from_i128(10_i128),
1128 precision,
1129 scale,
1130 from_type,
1131 to_type,
1132 cast_options,
1133 )
1134 }
1135 (Struct(_), Struct(to_fields)) => {
1136 let array = array.as_struct();
1137 let fields = array
1138 .columns()
1139 .iter()
1140 .zip(to_fields.iter())
1141 .map(|(l, field)| cast_with_options(l, field.data_type(), cast_options))
1142 .collect::<Result<Vec<ArrayRef>, ArrowError>>()?;
1143 let array = StructArray::try_new(to_fields.clone(), fields, array.nulls().cloned())?;
1144 Ok(Arc::new(array) as ArrayRef)
1145 }
1146 (Struct(_), _) => Err(ArrowError::CastError(format!(
1147 "Casting from {from_type:?} to {to_type:?} not supported"
1148 ))),
1149 (_, Struct(_)) => Err(ArrowError::CastError(format!(
1150 "Casting from {from_type:?} to {to_type:?} not supported"
1151 ))),
1152 (_, Boolean) => match from_type {
1153 UInt8 => cast_numeric_to_bool::<UInt8Type>(array),
1154 UInt16 => cast_numeric_to_bool::<UInt16Type>(array),
1155 UInt32 => cast_numeric_to_bool::<UInt32Type>(array),
1156 UInt64 => cast_numeric_to_bool::<UInt64Type>(array),
1157 Int8 => cast_numeric_to_bool::<Int8Type>(array),
1158 Int16 => cast_numeric_to_bool::<Int16Type>(array),
1159 Int32 => cast_numeric_to_bool::<Int32Type>(array),
1160 Int64 => cast_numeric_to_bool::<Int64Type>(array),
1161 Float16 => cast_numeric_to_bool::<Float16Type>(array),
1162 Float32 => cast_numeric_to_bool::<Float32Type>(array),
1163 Float64 => cast_numeric_to_bool::<Float64Type>(array),
1164 Utf8View => cast_utf8view_to_boolean(array, cast_options),
1165 Utf8 => cast_utf8_to_boolean::<i32>(array, cast_options),
1166 LargeUtf8 => cast_utf8_to_boolean::<i64>(array, cast_options),
1167 _ => Err(ArrowError::CastError(format!(
1168 "Casting from {from_type:?} to {to_type:?} not supported",
1169 ))),
1170 },
1171 (Boolean, _) => match to_type {
1172 UInt8 => cast_bool_to_numeric::<UInt8Type>(array, cast_options),
1173 UInt16 => cast_bool_to_numeric::<UInt16Type>(array, cast_options),
1174 UInt32 => cast_bool_to_numeric::<UInt32Type>(array, cast_options),
1175 UInt64 => cast_bool_to_numeric::<UInt64Type>(array, cast_options),
1176 Int8 => cast_bool_to_numeric::<Int8Type>(array, cast_options),
1177 Int16 => cast_bool_to_numeric::<Int16Type>(array, cast_options),
1178 Int32 => cast_bool_to_numeric::<Int32Type>(array, cast_options),
1179 Int64 => cast_bool_to_numeric::<Int64Type>(array, cast_options),
1180 Float16 => cast_bool_to_numeric::<Float16Type>(array, cast_options),
1181 Float32 => cast_bool_to_numeric::<Float32Type>(array, cast_options),
1182 Float64 => cast_bool_to_numeric::<Float64Type>(array, cast_options),
1183 Utf8View => value_to_string_view(array, cast_options),
1184 Utf8 => value_to_string::<i32>(array, cast_options),
1185 LargeUtf8 => value_to_string::<i64>(array, cast_options),
1186 _ => Err(ArrowError::CastError(format!(
1187 "Casting from {from_type:?} to {to_type:?} not supported",
1188 ))),
1189 },
1190 (Utf8, _) => match to_type {
1191 UInt8 => parse_string::<UInt8Type, i32>(array, cast_options),
1192 UInt16 => parse_string::<UInt16Type, i32>(array, cast_options),
1193 UInt32 => parse_string::<UInt32Type, i32>(array, cast_options),
1194 UInt64 => parse_string::<UInt64Type, i32>(array, cast_options),
1195 Int8 => parse_string::<Int8Type, i32>(array, cast_options),
1196 Int16 => parse_string::<Int16Type, i32>(array, cast_options),
1197 Int32 => parse_string::<Int32Type, i32>(array, cast_options),
1198 Int64 => parse_string::<Int64Type, i32>(array, cast_options),
1199 Float32 => parse_string::<Float32Type, i32>(array, cast_options),
1200 Float64 => parse_string::<Float64Type, i32>(array, cast_options),
1201 Date32 => parse_string::<Date32Type, i32>(array, cast_options),
1202 Date64 => parse_string::<Date64Type, i32>(array, cast_options),
1203 Binary => Ok(Arc::new(BinaryArray::from(
1204 array.as_string::<i32>().clone(),
1205 ))),
1206 LargeBinary => {
1207 let binary = BinaryArray::from(array.as_string::<i32>().clone());
1208 cast_byte_container::<BinaryType, LargeBinaryType>(&binary)
1209 }
1210 Utf8View => Ok(Arc::new(StringViewArray::from(array.as_string::<i32>()))),
1211 BinaryView => Ok(Arc::new(
1212 StringViewArray::from(array.as_string::<i32>()).to_binary_view(),
1213 )),
1214 LargeUtf8 => cast_byte_container::<Utf8Type, LargeUtf8Type>(array),
1215 Time32(TimeUnit::Second) => parse_string::<Time32SecondType, i32>(array, cast_options),
1216 Time32(TimeUnit::Millisecond) => {
1217 parse_string::<Time32MillisecondType, i32>(array, cast_options)
1218 }
1219 Time64(TimeUnit::Microsecond) => {
1220 parse_string::<Time64MicrosecondType, i32>(array, cast_options)
1221 }
1222 Time64(TimeUnit::Nanosecond) => {
1223 parse_string::<Time64NanosecondType, i32>(array, cast_options)
1224 }
1225 Timestamp(TimeUnit::Second, to_tz) => {
1226 cast_string_to_timestamp::<i32, TimestampSecondType>(array, to_tz, cast_options)
1227 }
1228 Timestamp(TimeUnit::Millisecond, to_tz) => cast_string_to_timestamp::<
1229 i32,
1230 TimestampMillisecondType,
1231 >(array, to_tz, cast_options),
1232 Timestamp(TimeUnit::Microsecond, to_tz) => cast_string_to_timestamp::<
1233 i32,
1234 TimestampMicrosecondType,
1235 >(array, to_tz, cast_options),
1236 Timestamp(TimeUnit::Nanosecond, to_tz) => {
1237 cast_string_to_timestamp::<i32, TimestampNanosecondType>(array, to_tz, cast_options)
1238 }
1239 Interval(IntervalUnit::YearMonth) => {
1240 cast_string_to_year_month_interval::<i32>(array, cast_options)
1241 }
1242 Interval(IntervalUnit::DayTime) => {
1243 cast_string_to_day_time_interval::<i32>(array, cast_options)
1244 }
1245 Interval(IntervalUnit::MonthDayNano) => {
1246 cast_string_to_month_day_nano_interval::<i32>(array, cast_options)
1247 }
1248 _ => Err(ArrowError::CastError(format!(
1249 "Casting from {from_type:?} to {to_type:?} not supported",
1250 ))),
1251 },
1252 (Utf8View, _) => match to_type {
1253 UInt8 => parse_string_view::<UInt8Type>(array, cast_options),
1254 UInt16 => parse_string_view::<UInt16Type>(array, cast_options),
1255 UInt32 => parse_string_view::<UInt32Type>(array, cast_options),
1256 UInt64 => parse_string_view::<UInt64Type>(array, cast_options),
1257 Int8 => parse_string_view::<Int8Type>(array, cast_options),
1258 Int16 => parse_string_view::<Int16Type>(array, cast_options),
1259 Int32 => parse_string_view::<Int32Type>(array, cast_options),
1260 Int64 => parse_string_view::<Int64Type>(array, cast_options),
1261 Float32 => parse_string_view::<Float32Type>(array, cast_options),
1262 Float64 => parse_string_view::<Float64Type>(array, cast_options),
1263 Date32 => parse_string_view::<Date32Type>(array, cast_options),
1264 Date64 => parse_string_view::<Date64Type>(array, cast_options),
1265 Binary => cast_view_to_byte::<StringViewType, GenericBinaryType<i32>>(array),
1266 LargeBinary => cast_view_to_byte::<StringViewType, GenericBinaryType<i64>>(array),
1267 BinaryView => Ok(Arc::new(array.as_string_view().clone().to_binary_view())),
1268 Utf8 => cast_view_to_byte::<StringViewType, GenericStringType<i32>>(array),
1269 LargeUtf8 => cast_view_to_byte::<StringViewType, GenericStringType<i64>>(array),
1270 Time32(TimeUnit::Second) => parse_string_view::<Time32SecondType>(array, cast_options),
1271 Time32(TimeUnit::Millisecond) => {
1272 parse_string_view::<Time32MillisecondType>(array, cast_options)
1273 }
1274 Time64(TimeUnit::Microsecond) => {
1275 parse_string_view::<Time64MicrosecondType>(array, cast_options)
1276 }
1277 Time64(TimeUnit::Nanosecond) => {
1278 parse_string_view::<Time64NanosecondType>(array, cast_options)
1279 }
1280 Timestamp(TimeUnit::Second, to_tz) => {
1281 cast_view_to_timestamp::<TimestampSecondType>(array, to_tz, cast_options)
1282 }
1283 Timestamp(TimeUnit::Millisecond, to_tz) => {
1284 cast_view_to_timestamp::<TimestampMillisecondType>(array, to_tz, cast_options)
1285 }
1286 Timestamp(TimeUnit::Microsecond, to_tz) => {
1287 cast_view_to_timestamp::<TimestampMicrosecondType>(array, to_tz, cast_options)
1288 }
1289 Timestamp(TimeUnit::Nanosecond, to_tz) => {
1290 cast_view_to_timestamp::<TimestampNanosecondType>(array, to_tz, cast_options)
1291 }
1292 Interval(IntervalUnit::YearMonth) => {
1293 cast_view_to_year_month_interval(array, cast_options)
1294 }
1295 Interval(IntervalUnit::DayTime) => cast_view_to_day_time_interval(array, cast_options),
1296 Interval(IntervalUnit::MonthDayNano) => {
1297 cast_view_to_month_day_nano_interval(array, cast_options)
1298 }
1299 _ => Err(ArrowError::CastError(format!(
1300 "Casting from {from_type:?} to {to_type:?} not supported",
1301 ))),
1302 },
1303 (LargeUtf8, _) => match to_type {
1304 UInt8 => parse_string::<UInt8Type, i64>(array, cast_options),
1305 UInt16 => parse_string::<UInt16Type, i64>(array, cast_options),
1306 UInt32 => parse_string::<UInt32Type, i64>(array, cast_options),
1307 UInt64 => parse_string::<UInt64Type, i64>(array, cast_options),
1308 Int8 => parse_string::<Int8Type, i64>(array, cast_options),
1309 Int16 => parse_string::<Int16Type, i64>(array, cast_options),
1310 Int32 => parse_string::<Int32Type, i64>(array, cast_options),
1311 Int64 => parse_string::<Int64Type, i64>(array, cast_options),
1312 Float32 => parse_string::<Float32Type, i64>(array, cast_options),
1313 Float64 => parse_string::<Float64Type, i64>(array, cast_options),
1314 Date32 => parse_string::<Date32Type, i64>(array, cast_options),
1315 Date64 => parse_string::<Date64Type, i64>(array, cast_options),
1316 Utf8 => cast_byte_container::<LargeUtf8Type, Utf8Type>(array),
1317 Binary => {
1318 let large_binary = LargeBinaryArray::from(array.as_string::<i64>().clone());
1319 cast_byte_container::<LargeBinaryType, BinaryType>(&large_binary)
1320 }
1321 LargeBinary => Ok(Arc::new(LargeBinaryArray::from(
1322 array.as_string::<i64>().clone(),
1323 ))),
1324 Utf8View => Ok(Arc::new(StringViewArray::from(array.as_string::<i64>()))),
1325 BinaryView => Ok(Arc::new(BinaryViewArray::from(
1326 array
1327 .as_string::<i64>()
1328 .into_iter()
1329 .map(|x| x.map(|x| x.as_bytes()))
1330 .collect::<Vec<_>>(),
1331 ))),
1332 Time32(TimeUnit::Second) => parse_string::<Time32SecondType, i64>(array, cast_options),
1333 Time32(TimeUnit::Millisecond) => {
1334 parse_string::<Time32MillisecondType, i64>(array, cast_options)
1335 }
1336 Time64(TimeUnit::Microsecond) => {
1337 parse_string::<Time64MicrosecondType, i64>(array, cast_options)
1338 }
1339 Time64(TimeUnit::Nanosecond) => {
1340 parse_string::<Time64NanosecondType, i64>(array, cast_options)
1341 }
1342 Timestamp(TimeUnit::Second, to_tz) => {
1343 cast_string_to_timestamp::<i64, TimestampSecondType>(array, to_tz, cast_options)
1344 }
1345 Timestamp(TimeUnit::Millisecond, to_tz) => cast_string_to_timestamp::<
1346 i64,
1347 TimestampMillisecondType,
1348 >(array, to_tz, cast_options),
1349 Timestamp(TimeUnit::Microsecond, to_tz) => cast_string_to_timestamp::<
1350 i64,
1351 TimestampMicrosecondType,
1352 >(array, to_tz, cast_options),
1353 Timestamp(TimeUnit::Nanosecond, to_tz) => {
1354 cast_string_to_timestamp::<i64, TimestampNanosecondType>(array, to_tz, cast_options)
1355 }
1356 Interval(IntervalUnit::YearMonth) => {
1357 cast_string_to_year_month_interval::<i64>(array, cast_options)
1358 }
1359 Interval(IntervalUnit::DayTime) => {
1360 cast_string_to_day_time_interval::<i64>(array, cast_options)
1361 }
1362 Interval(IntervalUnit::MonthDayNano) => {
1363 cast_string_to_month_day_nano_interval::<i64>(array, cast_options)
1364 }
1365 _ => Err(ArrowError::CastError(format!(
1366 "Casting from {from_type:?} to {to_type:?} not supported",
1367 ))),
1368 },
1369 (Binary, _) => match to_type {
1370 Utf8 => cast_binary_to_string::<i32>(array, cast_options),
1371 LargeUtf8 => {
1372 let array = cast_binary_to_string::<i32>(array, cast_options)?;
1373 cast_byte_container::<Utf8Type, LargeUtf8Type>(array.as_ref())
1374 }
1375 LargeBinary => cast_byte_container::<BinaryType, LargeBinaryType>(array),
1376 FixedSizeBinary(size) => {
1377 cast_binary_to_fixed_size_binary::<i32>(array, *size, cast_options)
1378 }
1379 BinaryView => Ok(Arc::new(BinaryViewArray::from(array.as_binary::<i32>()))),
1380 Utf8View => Ok(Arc::new(StringViewArray::from(
1381 cast_binary_to_string::<i32>(array, cast_options)?.as_string::<i32>(),
1382 ))),
1383 _ => Err(ArrowError::CastError(format!(
1384 "Casting from {from_type:?} to {to_type:?} not supported",
1385 ))),
1386 },
1387 (LargeBinary, _) => match to_type {
1388 Utf8 => {
1389 let array = cast_binary_to_string::<i64>(array, cast_options)?;
1390 cast_byte_container::<LargeUtf8Type, Utf8Type>(array.as_ref())
1391 }
1392 LargeUtf8 => cast_binary_to_string::<i64>(array, cast_options),
1393 Binary => cast_byte_container::<LargeBinaryType, BinaryType>(array),
1394 FixedSizeBinary(size) => {
1395 cast_binary_to_fixed_size_binary::<i64>(array, *size, cast_options)
1396 }
1397 BinaryView => Ok(Arc::new(BinaryViewArray::from(array.as_binary::<i64>()))),
1398 Utf8View => {
1399 let array = cast_binary_to_string::<i64>(array, cast_options)?;
1400 Ok(Arc::new(StringViewArray::from(array.as_string::<i64>())))
1401 }
1402 _ => Err(ArrowError::CastError(format!(
1403 "Casting from {from_type:?} to {to_type:?} not supported",
1404 ))),
1405 },
1406 (FixedSizeBinary(size), _) => match to_type {
1407 Binary => cast_fixed_size_binary_to_binary::<i32>(array, *size),
1408 LargeBinary => cast_fixed_size_binary_to_binary::<i64>(array, *size),
1409 BinaryView => cast_fixed_size_binary_to_binary_view(array, *size),
1410 _ => Err(ArrowError::CastError(format!(
1411 "Casting from {from_type:?} to {to_type:?} not supported",
1412 ))),
1413 },
1414 (BinaryView, Binary) => cast_view_to_byte::<BinaryViewType, GenericBinaryType<i32>>(array),
1415 (BinaryView, LargeBinary) => {
1416 cast_view_to_byte::<BinaryViewType, GenericBinaryType<i64>>(array)
1417 }
1418 (BinaryView, Utf8) => {
1419 let binary_arr = cast_view_to_byte::<BinaryViewType, GenericBinaryType<i32>>(array)?;
1420 cast_binary_to_string::<i32>(&binary_arr, cast_options)
1421 }
1422 (BinaryView, LargeUtf8) => {
1423 let binary_arr = cast_view_to_byte::<BinaryViewType, GenericBinaryType<i64>>(array)?;
1424 cast_binary_to_string::<i64>(&binary_arr, cast_options)
1425 }
1426 (BinaryView, Utf8View) => {
1427 Ok(Arc::new(array.as_binary_view().clone().to_string_view()?) as ArrayRef)
1428 }
1429 (BinaryView, _) => Err(ArrowError::CastError(format!(
1430 "Casting from {from_type:?} to {to_type:?} not supported",
1431 ))),
1432 (from_type, Utf8View) if from_type.is_primitive() => {
1433 value_to_string_view(array, cast_options)
1434 }
1435 (from_type, LargeUtf8) if from_type.is_primitive() => {
1436 value_to_string::<i64>(array, cast_options)
1437 }
1438 (from_type, Utf8) if from_type.is_primitive() => {
1439 value_to_string::<i32>(array, cast_options)
1440 }
1441 (from_type, Binary) if from_type.is_integer() => match from_type {
1442 UInt8 => cast_numeric_to_binary::<UInt8Type, i32>(array),
1443 UInt16 => cast_numeric_to_binary::<UInt16Type, i32>(array),
1444 UInt32 => cast_numeric_to_binary::<UInt32Type, i32>(array),
1445 UInt64 => cast_numeric_to_binary::<UInt64Type, i32>(array),
1446 Int8 => cast_numeric_to_binary::<Int8Type, i32>(array),
1447 Int16 => cast_numeric_to_binary::<Int16Type, i32>(array),
1448 Int32 => cast_numeric_to_binary::<Int32Type, i32>(array),
1449 Int64 => cast_numeric_to_binary::<Int64Type, i32>(array),
1450 _ => unreachable!(),
1451 },
1452 (from_type, LargeBinary) if from_type.is_integer() => match from_type {
1453 UInt8 => cast_numeric_to_binary::<UInt8Type, i64>(array),
1454 UInt16 => cast_numeric_to_binary::<UInt16Type, i64>(array),
1455 UInt32 => cast_numeric_to_binary::<UInt32Type, i64>(array),
1456 UInt64 => cast_numeric_to_binary::<UInt64Type, i64>(array),
1457 Int8 => cast_numeric_to_binary::<Int8Type, i64>(array),
1458 Int16 => cast_numeric_to_binary::<Int16Type, i64>(array),
1459 Int32 => cast_numeric_to_binary::<Int32Type, i64>(array),
1460 Int64 => cast_numeric_to_binary::<Int64Type, i64>(array),
1461 _ => unreachable!(),
1462 },
1463 (UInt8, UInt16) => cast_numeric_arrays::<UInt8Type, UInt16Type>(array, cast_options),
1465 (UInt8, UInt32) => cast_numeric_arrays::<UInt8Type, UInt32Type>(array, cast_options),
1466 (UInt8, UInt64) => cast_numeric_arrays::<UInt8Type, UInt64Type>(array, cast_options),
1467 (UInt8, Int8) => cast_numeric_arrays::<UInt8Type, Int8Type>(array, cast_options),
1468 (UInt8, Int16) => cast_numeric_arrays::<UInt8Type, Int16Type>(array, cast_options),
1469 (UInt8, Int32) => cast_numeric_arrays::<UInt8Type, Int32Type>(array, cast_options),
1470 (UInt8, Int64) => cast_numeric_arrays::<UInt8Type, Int64Type>(array, cast_options),
1471 (UInt8, Float16) => cast_numeric_arrays::<UInt8Type, Float16Type>(array, cast_options),
1472 (UInt8, Float32) => cast_numeric_arrays::<UInt8Type, Float32Type>(array, cast_options),
1473 (UInt8, Float64) => cast_numeric_arrays::<UInt8Type, Float64Type>(array, cast_options),
1474
1475 (UInt16, UInt8) => cast_numeric_arrays::<UInt16Type, UInt8Type>(array, cast_options),
1476 (UInt16, UInt32) => cast_numeric_arrays::<UInt16Type, UInt32Type>(array, cast_options),
1477 (UInt16, UInt64) => cast_numeric_arrays::<UInt16Type, UInt64Type>(array, cast_options),
1478 (UInt16, Int8) => cast_numeric_arrays::<UInt16Type, Int8Type>(array, cast_options),
1479 (UInt16, Int16) => cast_numeric_arrays::<UInt16Type, Int16Type>(array, cast_options),
1480 (UInt16, Int32) => cast_numeric_arrays::<UInt16Type, Int32Type>(array, cast_options),
1481 (UInt16, Int64) => cast_numeric_arrays::<UInt16Type, Int64Type>(array, cast_options),
1482 (UInt16, Float16) => cast_numeric_arrays::<UInt16Type, Float16Type>(array, cast_options),
1483 (UInt16, Float32) => cast_numeric_arrays::<UInt16Type, Float32Type>(array, cast_options),
1484 (UInt16, Float64) => cast_numeric_arrays::<UInt16Type, Float64Type>(array, cast_options),
1485
1486 (UInt32, UInt8) => cast_numeric_arrays::<UInt32Type, UInt8Type>(array, cast_options),
1487 (UInt32, UInt16) => cast_numeric_arrays::<UInt32Type, UInt16Type>(array, cast_options),
1488 (UInt32, UInt64) => cast_numeric_arrays::<UInt32Type, UInt64Type>(array, cast_options),
1489 (UInt32, Int8) => cast_numeric_arrays::<UInt32Type, Int8Type>(array, cast_options),
1490 (UInt32, Int16) => cast_numeric_arrays::<UInt32Type, Int16Type>(array, cast_options),
1491 (UInt32, Int32) => cast_numeric_arrays::<UInt32Type, Int32Type>(array, cast_options),
1492 (UInt32, Int64) => cast_numeric_arrays::<UInt32Type, Int64Type>(array, cast_options),
1493 (UInt32, Float16) => cast_numeric_arrays::<UInt32Type, Float16Type>(array, cast_options),
1494 (UInt32, Float32) => cast_numeric_arrays::<UInt32Type, Float32Type>(array, cast_options),
1495 (UInt32, Float64) => cast_numeric_arrays::<UInt32Type, Float64Type>(array, cast_options),
1496
1497 (UInt64, UInt8) => cast_numeric_arrays::<UInt64Type, UInt8Type>(array, cast_options),
1498 (UInt64, UInt16) => cast_numeric_arrays::<UInt64Type, UInt16Type>(array, cast_options),
1499 (UInt64, UInt32) => cast_numeric_arrays::<UInt64Type, UInt32Type>(array, cast_options),
1500 (UInt64, Int8) => cast_numeric_arrays::<UInt64Type, Int8Type>(array, cast_options),
1501 (UInt64, Int16) => cast_numeric_arrays::<UInt64Type, Int16Type>(array, cast_options),
1502 (UInt64, Int32) => cast_numeric_arrays::<UInt64Type, Int32Type>(array, cast_options),
1503 (UInt64, Int64) => cast_numeric_arrays::<UInt64Type, Int64Type>(array, cast_options),
1504 (UInt64, Float16) => cast_numeric_arrays::<UInt64Type, Float16Type>(array, cast_options),
1505 (UInt64, Float32) => cast_numeric_arrays::<UInt64Type, Float32Type>(array, cast_options),
1506 (UInt64, Float64) => cast_numeric_arrays::<UInt64Type, Float64Type>(array, cast_options),
1507
1508 (Int8, UInt8) => cast_numeric_arrays::<Int8Type, UInt8Type>(array, cast_options),
1509 (Int8, UInt16) => cast_numeric_arrays::<Int8Type, UInt16Type>(array, cast_options),
1510 (Int8, UInt32) => cast_numeric_arrays::<Int8Type, UInt32Type>(array, cast_options),
1511 (Int8, UInt64) => cast_numeric_arrays::<Int8Type, UInt64Type>(array, cast_options),
1512 (Int8, Int16) => cast_numeric_arrays::<Int8Type, Int16Type>(array, cast_options),
1513 (Int8, Int32) => cast_numeric_arrays::<Int8Type, Int32Type>(array, cast_options),
1514 (Int8, Int64) => cast_numeric_arrays::<Int8Type, Int64Type>(array, cast_options),
1515 (Int8, Float16) => cast_numeric_arrays::<Int8Type, Float16Type>(array, cast_options),
1516 (Int8, Float32) => cast_numeric_arrays::<Int8Type, Float32Type>(array, cast_options),
1517 (Int8, Float64) => cast_numeric_arrays::<Int8Type, Float64Type>(array, cast_options),
1518
1519 (Int16, UInt8) => cast_numeric_arrays::<Int16Type, UInt8Type>(array, cast_options),
1520 (Int16, UInt16) => cast_numeric_arrays::<Int16Type, UInt16Type>(array, cast_options),
1521 (Int16, UInt32) => cast_numeric_arrays::<Int16Type, UInt32Type>(array, cast_options),
1522 (Int16, UInt64) => cast_numeric_arrays::<Int16Type, UInt64Type>(array, cast_options),
1523 (Int16, Int8) => cast_numeric_arrays::<Int16Type, Int8Type>(array, cast_options),
1524 (Int16, Int32) => cast_numeric_arrays::<Int16Type, Int32Type>(array, cast_options),
1525 (Int16, Int64) => cast_numeric_arrays::<Int16Type, Int64Type>(array, cast_options),
1526 (Int16, Float16) => cast_numeric_arrays::<Int16Type, Float16Type>(array, cast_options),
1527 (Int16, Float32) => cast_numeric_arrays::<Int16Type, Float32Type>(array, cast_options),
1528 (Int16, Float64) => cast_numeric_arrays::<Int16Type, Float64Type>(array, cast_options),
1529
1530 (Int32, UInt8) => cast_numeric_arrays::<Int32Type, UInt8Type>(array, cast_options),
1531 (Int32, UInt16) => cast_numeric_arrays::<Int32Type, UInt16Type>(array, cast_options),
1532 (Int32, UInt32) => cast_numeric_arrays::<Int32Type, UInt32Type>(array, cast_options),
1533 (Int32, UInt64) => cast_numeric_arrays::<Int32Type, UInt64Type>(array, cast_options),
1534 (Int32, Int8) => cast_numeric_arrays::<Int32Type, Int8Type>(array, cast_options),
1535 (Int32, Int16) => cast_numeric_arrays::<Int32Type, Int16Type>(array, cast_options),
1536 (Int32, Int64) => cast_numeric_arrays::<Int32Type, Int64Type>(array, cast_options),
1537 (Int32, Float16) => cast_numeric_arrays::<Int32Type, Float16Type>(array, cast_options),
1538 (Int32, Float32) => cast_numeric_arrays::<Int32Type, Float32Type>(array, cast_options),
1539 (Int32, Float64) => cast_numeric_arrays::<Int32Type, Float64Type>(array, cast_options),
1540
1541 (Int64, UInt8) => cast_numeric_arrays::<Int64Type, UInt8Type>(array, cast_options),
1542 (Int64, UInt16) => cast_numeric_arrays::<Int64Type, UInt16Type>(array, cast_options),
1543 (Int64, UInt32) => cast_numeric_arrays::<Int64Type, UInt32Type>(array, cast_options),
1544 (Int64, UInt64) => cast_numeric_arrays::<Int64Type, UInt64Type>(array, cast_options),
1545 (Int64, Int8) => cast_numeric_arrays::<Int64Type, Int8Type>(array, cast_options),
1546 (Int64, Int16) => cast_numeric_arrays::<Int64Type, Int16Type>(array, cast_options),
1547 (Int64, Int32) => cast_numeric_arrays::<Int64Type, Int32Type>(array, cast_options),
1548 (Int64, Float16) => cast_numeric_arrays::<Int64Type, Float16Type>(array, cast_options),
1549 (Int64, Float32) => cast_numeric_arrays::<Int64Type, Float32Type>(array, cast_options),
1550 (Int64, Float64) => cast_numeric_arrays::<Int64Type, Float64Type>(array, cast_options),
1551
1552 (Float16, UInt8) => cast_numeric_arrays::<Float16Type, UInt8Type>(array, cast_options),
1553 (Float16, UInt16) => cast_numeric_arrays::<Float16Type, UInt16Type>(array, cast_options),
1554 (Float16, UInt32) => cast_numeric_arrays::<Float16Type, UInt32Type>(array, cast_options),
1555 (Float16, UInt64) => cast_numeric_arrays::<Float16Type, UInt64Type>(array, cast_options),
1556 (Float16, Int8) => cast_numeric_arrays::<Float16Type, Int8Type>(array, cast_options),
1557 (Float16, Int16) => cast_numeric_arrays::<Float16Type, Int16Type>(array, cast_options),
1558 (Float16, Int32) => cast_numeric_arrays::<Float16Type, Int32Type>(array, cast_options),
1559 (Float16, Int64) => cast_numeric_arrays::<Float16Type, Int64Type>(array, cast_options),
1560 (Float16, Float32) => cast_numeric_arrays::<Float16Type, Float32Type>(array, cast_options),
1561 (Float16, Float64) => cast_numeric_arrays::<Float16Type, Float64Type>(array, cast_options),
1562
1563 (Float32, UInt8) => cast_numeric_arrays::<Float32Type, UInt8Type>(array, cast_options),
1564 (Float32, UInt16) => cast_numeric_arrays::<Float32Type, UInt16Type>(array, cast_options),
1565 (Float32, UInt32) => cast_numeric_arrays::<Float32Type, UInt32Type>(array, cast_options),
1566 (Float32, UInt64) => cast_numeric_arrays::<Float32Type, UInt64Type>(array, cast_options),
1567 (Float32, Int8) => cast_numeric_arrays::<Float32Type, Int8Type>(array, cast_options),
1568 (Float32, Int16) => cast_numeric_arrays::<Float32Type, Int16Type>(array, cast_options),
1569 (Float32, Int32) => cast_numeric_arrays::<Float32Type, Int32Type>(array, cast_options),
1570 (Float32, Int64) => cast_numeric_arrays::<Float32Type, Int64Type>(array, cast_options),
1571 (Float32, Float16) => cast_numeric_arrays::<Float32Type, Float16Type>(array, cast_options),
1572 (Float32, Float64) => cast_numeric_arrays::<Float32Type, Float64Type>(array, cast_options),
1573
1574 (Float64, UInt8) => cast_numeric_arrays::<Float64Type, UInt8Type>(array, cast_options),
1575 (Float64, UInt16) => cast_numeric_arrays::<Float64Type, UInt16Type>(array, cast_options),
1576 (Float64, UInt32) => cast_numeric_arrays::<Float64Type, UInt32Type>(array, cast_options),
1577 (Float64, UInt64) => cast_numeric_arrays::<Float64Type, UInt64Type>(array, cast_options),
1578 (Float64, Int8) => cast_numeric_arrays::<Float64Type, Int8Type>(array, cast_options),
1579 (Float64, Int16) => cast_numeric_arrays::<Float64Type, Int16Type>(array, cast_options),
1580 (Float64, Int32) => cast_numeric_arrays::<Float64Type, Int32Type>(array, cast_options),
1581 (Float64, Int64) => cast_numeric_arrays::<Float64Type, Int64Type>(array, cast_options),
1582 (Float64, Float16) => cast_numeric_arrays::<Float64Type, Float16Type>(array, cast_options),
1583 (Float64, Float32) => cast_numeric_arrays::<Float64Type, Float32Type>(array, cast_options),
1584 (Int32, Date32) => cast_reinterpret_arrays::<Int32Type, Date32Type>(array),
1588 (Int32, Date64) => cast_with_options(
1589 &cast_with_options(array, &Date32, cast_options)?,
1590 &Date64,
1591 cast_options,
1592 ),
1593 (Int32, Time32(TimeUnit::Second)) => {
1594 cast_reinterpret_arrays::<Int32Type, Time32SecondType>(array)
1595 }
1596 (Int32, Time32(TimeUnit::Millisecond)) => {
1597 cast_reinterpret_arrays::<Int32Type, Time32MillisecondType>(array)
1598 }
1599 (Date32, Int32) => cast_reinterpret_arrays::<Date32Type, Int32Type>(array),
1601 (Date32, Int64) => cast_with_options(
1602 &cast_with_options(array, &Int32, cast_options)?,
1603 &Int64,
1604 cast_options,
1605 ),
1606 (Time32(TimeUnit::Second), Int32) => {
1607 cast_reinterpret_arrays::<Time32SecondType, Int32Type>(array)
1608 }
1609 (Time32(TimeUnit::Millisecond), Int32) => {
1610 cast_reinterpret_arrays::<Time32MillisecondType, Int32Type>(array)
1611 }
1612 (Int64, Date64) => cast_reinterpret_arrays::<Int64Type, Date64Type>(array),
1613 (Int64, Date32) => cast_with_options(
1614 &cast_with_options(array, &Int32, cast_options)?,
1615 &Date32,
1616 cast_options,
1617 ),
1618 (Int64, Time64(TimeUnit::Microsecond)) => {
1620 cast_reinterpret_arrays::<Int64Type, Time64MicrosecondType>(array)
1621 }
1622 (Int64, Time64(TimeUnit::Nanosecond)) => {
1623 cast_reinterpret_arrays::<Int64Type, Time64NanosecondType>(array)
1624 }
1625
1626 (Date64, Int64) => cast_reinterpret_arrays::<Date64Type, Int64Type>(array),
1627 (Date64, Int32) => cast_with_options(
1628 &cast_with_options(array, &Int64, cast_options)?,
1629 &Int32,
1630 cast_options,
1631 ),
1632 (Time64(TimeUnit::Microsecond), Int64) => {
1633 cast_reinterpret_arrays::<Time64MicrosecondType, Int64Type>(array)
1634 }
1635 (Time64(TimeUnit::Nanosecond), Int64) => {
1636 cast_reinterpret_arrays::<Time64NanosecondType, Int64Type>(array)
1637 }
1638 (Date32, Date64) => Ok(Arc::new(
1639 array
1640 .as_primitive::<Date32Type>()
1641 .unary::<_, Date64Type>(|x| x as i64 * MILLISECONDS_IN_DAY),
1642 )),
1643 (Date64, Date32) => Ok(Arc::new(
1644 array
1645 .as_primitive::<Date64Type>()
1646 .unary::<_, Date32Type>(|x| (x / MILLISECONDS_IN_DAY) as i32),
1647 )),
1648
1649 (Time32(TimeUnit::Second), Time32(TimeUnit::Millisecond)) => Ok(Arc::new(
1650 array
1651 .as_primitive::<Time32SecondType>()
1652 .unary::<_, Time32MillisecondType>(|x| x * MILLISECONDS as i32),
1653 )),
1654 (Time32(TimeUnit::Second), Time64(TimeUnit::Microsecond)) => Ok(Arc::new(
1655 array
1656 .as_primitive::<Time32SecondType>()
1657 .unary::<_, Time64MicrosecondType>(|x| x as i64 * MICROSECONDS),
1658 )),
1659 (Time32(TimeUnit::Second), Time64(TimeUnit::Nanosecond)) => Ok(Arc::new(
1660 array
1661 .as_primitive::<Time32SecondType>()
1662 .unary::<_, Time64NanosecondType>(|x| x as i64 * NANOSECONDS),
1663 )),
1664
1665 (Time32(TimeUnit::Millisecond), Time32(TimeUnit::Second)) => Ok(Arc::new(
1666 array
1667 .as_primitive::<Time32MillisecondType>()
1668 .unary::<_, Time32SecondType>(|x| x / MILLISECONDS as i32),
1669 )),
1670 (Time32(TimeUnit::Millisecond), Time64(TimeUnit::Microsecond)) => Ok(Arc::new(
1671 array
1672 .as_primitive::<Time32MillisecondType>()
1673 .unary::<_, Time64MicrosecondType>(|x| x as i64 * (MICROSECONDS / MILLISECONDS)),
1674 )),
1675 (Time32(TimeUnit::Millisecond), Time64(TimeUnit::Nanosecond)) => Ok(Arc::new(
1676 array
1677 .as_primitive::<Time32MillisecondType>()
1678 .unary::<_, Time64NanosecondType>(|x| x as i64 * (MICROSECONDS / NANOSECONDS)),
1679 )),
1680
1681 (Time64(TimeUnit::Microsecond), Time32(TimeUnit::Second)) => Ok(Arc::new(
1682 array
1683 .as_primitive::<Time64MicrosecondType>()
1684 .unary::<_, Time32SecondType>(|x| (x / MICROSECONDS) as i32),
1685 )),
1686 (Time64(TimeUnit::Microsecond), Time32(TimeUnit::Millisecond)) => Ok(Arc::new(
1687 array
1688 .as_primitive::<Time64MicrosecondType>()
1689 .unary::<_, Time32MillisecondType>(|x| (x / (MICROSECONDS / MILLISECONDS)) as i32),
1690 )),
1691 (Time64(TimeUnit::Microsecond), Time64(TimeUnit::Nanosecond)) => Ok(Arc::new(
1692 array
1693 .as_primitive::<Time64MicrosecondType>()
1694 .unary::<_, Time64NanosecondType>(|x| x * (NANOSECONDS / MICROSECONDS)),
1695 )),
1696
1697 (Time64(TimeUnit::Nanosecond), Time32(TimeUnit::Second)) => Ok(Arc::new(
1698 array
1699 .as_primitive::<Time64NanosecondType>()
1700 .unary::<_, Time32SecondType>(|x| (x / NANOSECONDS) as i32),
1701 )),
1702 (Time64(TimeUnit::Nanosecond), Time32(TimeUnit::Millisecond)) => Ok(Arc::new(
1703 array
1704 .as_primitive::<Time64NanosecondType>()
1705 .unary::<_, Time32MillisecondType>(|x| (x / (NANOSECONDS / MILLISECONDS)) as i32),
1706 )),
1707 (Time64(TimeUnit::Nanosecond), Time64(TimeUnit::Microsecond)) => Ok(Arc::new(
1708 array
1709 .as_primitive::<Time64NanosecondType>()
1710 .unary::<_, Time64MicrosecondType>(|x| x / (NANOSECONDS / MICROSECONDS)),
1711 )),
1712
1713 (Timestamp(TimeUnit::Second, _), _) if to_type.is_numeric() => {
1715 let array = cast_reinterpret_arrays::<TimestampSecondType, Int64Type>(array)?;
1716 cast_with_options(&array, to_type, cast_options)
1717 }
1718 (Timestamp(TimeUnit::Millisecond, _), _) if to_type.is_numeric() => {
1719 let array = cast_reinterpret_arrays::<TimestampMillisecondType, Int64Type>(array)?;
1720 cast_with_options(&array, to_type, cast_options)
1721 }
1722 (Timestamp(TimeUnit::Microsecond, _), _) if to_type.is_numeric() => {
1723 let array = cast_reinterpret_arrays::<TimestampMicrosecondType, Int64Type>(array)?;
1724 cast_with_options(&array, to_type, cast_options)
1725 }
1726 (Timestamp(TimeUnit::Nanosecond, _), _) if to_type.is_numeric() => {
1727 let array = cast_reinterpret_arrays::<TimestampNanosecondType, Int64Type>(array)?;
1728 cast_with_options(&array, to_type, cast_options)
1729 }
1730
1731 (_, Timestamp(unit, tz)) if from_type.is_numeric() => {
1732 let array = cast_with_options(array, &Int64, cast_options)?;
1733 Ok(make_timestamp_array(
1734 array.as_primitive(),
1735 *unit,
1736 tz.clone(),
1737 ))
1738 }
1739
1740 (Timestamp(from_unit, from_tz), Timestamp(to_unit, to_tz)) => {
1741 let array = cast_with_options(array, &Int64, cast_options)?;
1742 let time_array = array.as_primitive::<Int64Type>();
1743 let from_size = time_unit_multiple(from_unit);
1744 let to_size = time_unit_multiple(to_unit);
1745 let converted = match from_size.cmp(&to_size) {
1748 Ordering::Greater => {
1749 let divisor = from_size / to_size;
1750 time_array.unary::<_, Int64Type>(|o| o / divisor)
1751 }
1752 Ordering::Equal => time_array.clone(),
1753 Ordering::Less => {
1754 let mul = to_size / from_size;
1755 if cast_options.safe {
1756 time_array.unary_opt::<_, Int64Type>(|o| o.checked_mul(mul))
1757 } else {
1758 time_array.try_unary::<_, Int64Type, _>(|o| o.mul_checked(mul))?
1759 }
1760 }
1761 };
1762 let adjusted = match (from_tz, to_tz) {
1764 (None, Some(to_tz)) => {
1770 let to_tz: Tz = to_tz.parse()?;
1771 match to_unit {
1772 TimeUnit::Second => adjust_timestamp_to_timezone::<TimestampSecondType>(
1773 converted,
1774 &to_tz,
1775 cast_options,
1776 )?,
1777 TimeUnit::Millisecond => adjust_timestamp_to_timezone::<
1778 TimestampMillisecondType,
1779 >(
1780 converted, &to_tz, cast_options
1781 )?,
1782 TimeUnit::Microsecond => adjust_timestamp_to_timezone::<
1783 TimestampMicrosecondType,
1784 >(
1785 converted, &to_tz, cast_options
1786 )?,
1787 TimeUnit::Nanosecond => adjust_timestamp_to_timezone::<
1788 TimestampNanosecondType,
1789 >(
1790 converted, &to_tz, cast_options
1791 )?,
1792 }
1793 }
1794 _ => converted,
1795 };
1796 Ok(make_timestamp_array(&adjusted, *to_unit, to_tz.clone()))
1797 }
1798 (Timestamp(TimeUnit::Microsecond, _), Date32) => {
1799 timestamp_to_date32(array.as_primitive::<TimestampMicrosecondType>())
1800 }
1801 (Timestamp(TimeUnit::Millisecond, _), Date32) => {
1802 timestamp_to_date32(array.as_primitive::<TimestampMillisecondType>())
1803 }
1804 (Timestamp(TimeUnit::Second, _), Date32) => {
1805 timestamp_to_date32(array.as_primitive::<TimestampSecondType>())
1806 }
1807 (Timestamp(TimeUnit::Nanosecond, _), Date32) => {
1808 timestamp_to_date32(array.as_primitive::<TimestampNanosecondType>())
1809 }
1810 (Timestamp(TimeUnit::Second, _), Date64) => Ok(Arc::new(match cast_options.safe {
1811 true => {
1812 array
1814 .as_primitive::<TimestampSecondType>()
1815 .unary_opt::<_, Date64Type>(|x| x.checked_mul(MILLISECONDS))
1816 }
1817 false => array
1818 .as_primitive::<TimestampSecondType>()
1819 .try_unary::<_, Date64Type, _>(|x| x.mul_checked(MILLISECONDS))?,
1820 })),
1821 (Timestamp(TimeUnit::Millisecond, _), Date64) => {
1822 cast_reinterpret_arrays::<TimestampMillisecondType, Date64Type>(array)
1823 }
1824 (Timestamp(TimeUnit::Microsecond, _), Date64) => Ok(Arc::new(
1825 array
1826 .as_primitive::<TimestampMicrosecondType>()
1827 .unary::<_, Date64Type>(|x| x / (MICROSECONDS / MILLISECONDS)),
1828 )),
1829 (Timestamp(TimeUnit::Nanosecond, _), Date64) => Ok(Arc::new(
1830 array
1831 .as_primitive::<TimestampNanosecondType>()
1832 .unary::<_, Date64Type>(|x| x / (NANOSECONDS / MILLISECONDS)),
1833 )),
1834 (Timestamp(TimeUnit::Second, tz), Time64(TimeUnit::Microsecond)) => {
1835 let tz = tz.as_ref().map(|tz| tz.parse()).transpose()?;
1836 Ok(Arc::new(
1837 array
1838 .as_primitive::<TimestampSecondType>()
1839 .try_unary::<_, Time64MicrosecondType, ArrowError>(|x| {
1840 Ok(time_to_time64us(as_time_res_with_timezone::<
1841 TimestampSecondType,
1842 >(x, tz)?))
1843 })?,
1844 ))
1845 }
1846 (Timestamp(TimeUnit::Second, tz), Time64(TimeUnit::Nanosecond)) => {
1847 let tz = tz.as_ref().map(|tz| tz.parse()).transpose()?;
1848 Ok(Arc::new(
1849 array
1850 .as_primitive::<TimestampSecondType>()
1851 .try_unary::<_, Time64NanosecondType, ArrowError>(|x| {
1852 Ok(time_to_time64ns(as_time_res_with_timezone::<
1853 TimestampSecondType,
1854 >(x, tz)?))
1855 })?,
1856 ))
1857 }
1858 (Timestamp(TimeUnit::Millisecond, tz), Time64(TimeUnit::Microsecond)) => {
1859 let tz = tz.as_ref().map(|tz| tz.parse()).transpose()?;
1860 Ok(Arc::new(
1861 array
1862 .as_primitive::<TimestampMillisecondType>()
1863 .try_unary::<_, Time64MicrosecondType, ArrowError>(|x| {
1864 Ok(time_to_time64us(as_time_res_with_timezone::<
1865 TimestampMillisecondType,
1866 >(x, tz)?))
1867 })?,
1868 ))
1869 }
1870 (Timestamp(TimeUnit::Millisecond, tz), Time64(TimeUnit::Nanosecond)) => {
1871 let tz = tz.as_ref().map(|tz| tz.parse()).transpose()?;
1872 Ok(Arc::new(
1873 array
1874 .as_primitive::<TimestampMillisecondType>()
1875 .try_unary::<_, Time64NanosecondType, ArrowError>(|x| {
1876 Ok(time_to_time64ns(as_time_res_with_timezone::<
1877 TimestampMillisecondType,
1878 >(x, tz)?))
1879 })?,
1880 ))
1881 }
1882 (Timestamp(TimeUnit::Microsecond, tz), Time64(TimeUnit::Microsecond)) => {
1883 let tz = tz.as_ref().map(|tz| tz.parse()).transpose()?;
1884 Ok(Arc::new(
1885 array
1886 .as_primitive::<TimestampMicrosecondType>()
1887 .try_unary::<_, Time64MicrosecondType, ArrowError>(|x| {
1888 Ok(time_to_time64us(as_time_res_with_timezone::<
1889 TimestampMicrosecondType,
1890 >(x, tz)?))
1891 })?,
1892 ))
1893 }
1894 (Timestamp(TimeUnit::Microsecond, tz), Time64(TimeUnit::Nanosecond)) => {
1895 let tz = tz.as_ref().map(|tz| tz.parse()).transpose()?;
1896 Ok(Arc::new(
1897 array
1898 .as_primitive::<TimestampMicrosecondType>()
1899 .try_unary::<_, Time64NanosecondType, ArrowError>(|x| {
1900 Ok(time_to_time64ns(as_time_res_with_timezone::<
1901 TimestampMicrosecondType,
1902 >(x, tz)?))
1903 })?,
1904 ))
1905 }
1906 (Timestamp(TimeUnit::Nanosecond, tz), Time64(TimeUnit::Microsecond)) => {
1907 let tz = tz.as_ref().map(|tz| tz.parse()).transpose()?;
1908 Ok(Arc::new(
1909 array
1910 .as_primitive::<TimestampNanosecondType>()
1911 .try_unary::<_, Time64MicrosecondType, ArrowError>(|x| {
1912 Ok(time_to_time64us(as_time_res_with_timezone::<
1913 TimestampNanosecondType,
1914 >(x, tz)?))
1915 })?,
1916 ))
1917 }
1918 (Timestamp(TimeUnit::Nanosecond, tz), Time64(TimeUnit::Nanosecond)) => {
1919 let tz = tz.as_ref().map(|tz| tz.parse()).transpose()?;
1920 Ok(Arc::new(
1921 array
1922 .as_primitive::<TimestampNanosecondType>()
1923 .try_unary::<_, Time64NanosecondType, ArrowError>(|x| {
1924 Ok(time_to_time64ns(as_time_res_with_timezone::<
1925 TimestampNanosecondType,
1926 >(x, tz)?))
1927 })?,
1928 ))
1929 }
1930 (Timestamp(TimeUnit::Second, tz), Time32(TimeUnit::Second)) => {
1931 let tz = tz.as_ref().map(|tz| tz.parse()).transpose()?;
1932 Ok(Arc::new(
1933 array
1934 .as_primitive::<TimestampSecondType>()
1935 .try_unary::<_, Time32SecondType, ArrowError>(|x| {
1936 Ok(time_to_time32s(as_time_res_with_timezone::<
1937 TimestampSecondType,
1938 >(x, tz)?))
1939 })?,
1940 ))
1941 }
1942 (Timestamp(TimeUnit::Second, tz), Time32(TimeUnit::Millisecond)) => {
1943 let tz = tz.as_ref().map(|tz| tz.parse()).transpose()?;
1944 Ok(Arc::new(
1945 array
1946 .as_primitive::<TimestampSecondType>()
1947 .try_unary::<_, Time32MillisecondType, ArrowError>(|x| {
1948 Ok(time_to_time32ms(as_time_res_with_timezone::<
1949 TimestampSecondType,
1950 >(x, tz)?))
1951 })?,
1952 ))
1953 }
1954 (Timestamp(TimeUnit::Millisecond, tz), Time32(TimeUnit::Second)) => {
1955 let tz = tz.as_ref().map(|tz| tz.parse()).transpose()?;
1956 Ok(Arc::new(
1957 array
1958 .as_primitive::<TimestampMillisecondType>()
1959 .try_unary::<_, Time32SecondType, ArrowError>(|x| {
1960 Ok(time_to_time32s(as_time_res_with_timezone::<
1961 TimestampMillisecondType,
1962 >(x, tz)?))
1963 })?,
1964 ))
1965 }
1966 (Timestamp(TimeUnit::Millisecond, tz), Time32(TimeUnit::Millisecond)) => {
1967 let tz = tz.as_ref().map(|tz| tz.parse()).transpose()?;
1968 Ok(Arc::new(
1969 array
1970 .as_primitive::<TimestampMillisecondType>()
1971 .try_unary::<_, Time32MillisecondType, ArrowError>(|x| {
1972 Ok(time_to_time32ms(as_time_res_with_timezone::<
1973 TimestampMillisecondType,
1974 >(x, tz)?))
1975 })?,
1976 ))
1977 }
1978 (Timestamp(TimeUnit::Microsecond, tz), Time32(TimeUnit::Second)) => {
1979 let tz = tz.as_ref().map(|tz| tz.parse()).transpose()?;
1980 Ok(Arc::new(
1981 array
1982 .as_primitive::<TimestampMicrosecondType>()
1983 .try_unary::<_, Time32SecondType, ArrowError>(|x| {
1984 Ok(time_to_time32s(as_time_res_with_timezone::<
1985 TimestampMicrosecondType,
1986 >(x, tz)?))
1987 })?,
1988 ))
1989 }
1990 (Timestamp(TimeUnit::Microsecond, tz), Time32(TimeUnit::Millisecond)) => {
1991 let tz = tz.as_ref().map(|tz| tz.parse()).transpose()?;
1992 Ok(Arc::new(
1993 array
1994 .as_primitive::<TimestampMicrosecondType>()
1995 .try_unary::<_, Time32MillisecondType, ArrowError>(|x| {
1996 Ok(time_to_time32ms(as_time_res_with_timezone::<
1997 TimestampMicrosecondType,
1998 >(x, tz)?))
1999 })?,
2000 ))
2001 }
2002 (Timestamp(TimeUnit::Nanosecond, tz), Time32(TimeUnit::Second)) => {
2003 let tz = tz.as_ref().map(|tz| tz.parse()).transpose()?;
2004 Ok(Arc::new(
2005 array
2006 .as_primitive::<TimestampNanosecondType>()
2007 .try_unary::<_, Time32SecondType, ArrowError>(|x| {
2008 Ok(time_to_time32s(as_time_res_with_timezone::<
2009 TimestampNanosecondType,
2010 >(x, tz)?))
2011 })?,
2012 ))
2013 }
2014 (Timestamp(TimeUnit::Nanosecond, tz), Time32(TimeUnit::Millisecond)) => {
2015 let tz = tz.as_ref().map(|tz| tz.parse()).transpose()?;
2016 Ok(Arc::new(
2017 array
2018 .as_primitive::<TimestampNanosecondType>()
2019 .try_unary::<_, Time32MillisecondType, ArrowError>(|x| {
2020 Ok(time_to_time32ms(as_time_res_with_timezone::<
2021 TimestampNanosecondType,
2022 >(x, tz)?))
2023 })?,
2024 ))
2025 }
2026 (Date64, Timestamp(TimeUnit::Second, _)) => {
2027 let array = array
2028 .as_primitive::<Date64Type>()
2029 .unary::<_, TimestampSecondType>(|x| x / MILLISECONDS);
2030
2031 cast_with_options(&array, to_type, cast_options)
2032 }
2033 (Date64, Timestamp(TimeUnit::Millisecond, _)) => {
2034 let array = array
2035 .as_primitive::<Date64Type>()
2036 .reinterpret_cast::<TimestampMillisecondType>();
2037
2038 cast_with_options(&array, to_type, cast_options)
2039 }
2040
2041 (Date64, Timestamp(TimeUnit::Microsecond, _)) => {
2042 let array = array
2043 .as_primitive::<Date64Type>()
2044 .unary::<_, TimestampMicrosecondType>(|x| x * (MICROSECONDS / MILLISECONDS));
2045
2046 cast_with_options(&array, to_type, cast_options)
2047 }
2048 (Date64, Timestamp(TimeUnit::Nanosecond, _)) => {
2049 let array = array
2050 .as_primitive::<Date64Type>()
2051 .unary::<_, TimestampNanosecondType>(|x| x * (NANOSECONDS / MILLISECONDS));
2052
2053 cast_with_options(&array, to_type, cast_options)
2054 }
2055 (Date32, Timestamp(TimeUnit::Second, _)) => {
2056 let array = array
2057 .as_primitive::<Date32Type>()
2058 .unary::<_, TimestampSecondType>(|x| (x as i64) * SECONDS_IN_DAY);
2059
2060 cast_with_options(&array, to_type, cast_options)
2061 }
2062 (Date32, Timestamp(TimeUnit::Millisecond, _)) => {
2063 let array = array
2064 .as_primitive::<Date32Type>()
2065 .unary::<_, TimestampMillisecondType>(|x| (x as i64) * MILLISECONDS_IN_DAY);
2066
2067 cast_with_options(&array, to_type, cast_options)
2068 }
2069 (Date32, Timestamp(TimeUnit::Microsecond, _)) => {
2070 let array = array
2071 .as_primitive::<Date32Type>()
2072 .unary::<_, TimestampMicrosecondType>(|x| (x as i64) * MICROSECONDS_IN_DAY);
2073
2074 cast_with_options(&array, to_type, cast_options)
2075 }
2076 (Date32, Timestamp(TimeUnit::Nanosecond, _)) => {
2077 let array = array
2078 .as_primitive::<Date32Type>()
2079 .unary::<_, TimestampNanosecondType>(|x| (x as i64) * NANOSECONDS_IN_DAY);
2080
2081 cast_with_options(&array, to_type, cast_options)
2082 }
2083
2084 (_, Duration(unit)) if from_type.is_numeric() => {
2085 let array = cast_with_options(array, &Int64, cast_options)?;
2086 Ok(make_duration_array(array.as_primitive(), *unit))
2087 }
2088 (Duration(TimeUnit::Second), _) if to_type.is_numeric() => {
2089 let array = cast_reinterpret_arrays::<DurationSecondType, Int64Type>(array)?;
2090 cast_with_options(&array, to_type, cast_options)
2091 }
2092 (Duration(TimeUnit::Millisecond), _) if to_type.is_numeric() => {
2093 let array = cast_reinterpret_arrays::<DurationMillisecondType, Int64Type>(array)?;
2094 cast_with_options(&array, to_type, cast_options)
2095 }
2096 (Duration(TimeUnit::Microsecond), _) if to_type.is_numeric() => {
2097 let array = cast_reinterpret_arrays::<DurationMicrosecondType, Int64Type>(array)?;
2098 cast_with_options(&array, to_type, cast_options)
2099 }
2100 (Duration(TimeUnit::Nanosecond), _) if to_type.is_numeric() => {
2101 let array = cast_reinterpret_arrays::<DurationNanosecondType, Int64Type>(array)?;
2102 cast_with_options(&array, to_type, cast_options)
2103 }
2104
2105 (Duration(from_unit), Duration(to_unit)) => {
2106 let array = cast_with_options(array, &Int64, cast_options)?;
2107 let time_array = array.as_primitive::<Int64Type>();
2108 let from_size = time_unit_multiple(from_unit);
2109 let to_size = time_unit_multiple(to_unit);
2110 let converted = match from_size.cmp(&to_size) {
2113 Ordering::Greater => {
2114 let divisor = from_size / to_size;
2115 time_array.unary::<_, Int64Type>(|o| o / divisor)
2116 }
2117 Ordering::Equal => time_array.clone(),
2118 Ordering::Less => {
2119 let mul = to_size / from_size;
2120 if cast_options.safe {
2121 time_array.unary_opt::<_, Int64Type>(|o| o.checked_mul(mul))
2122 } else {
2123 time_array.try_unary::<_, Int64Type, _>(|o| o.mul_checked(mul))?
2124 }
2125 }
2126 };
2127 Ok(make_duration_array(&converted, *to_unit))
2128 }
2129
2130 (Duration(TimeUnit::Second), Interval(IntervalUnit::MonthDayNano)) => {
2131 cast_duration_to_interval::<DurationSecondType>(array, cast_options)
2132 }
2133 (Duration(TimeUnit::Millisecond), Interval(IntervalUnit::MonthDayNano)) => {
2134 cast_duration_to_interval::<DurationMillisecondType>(array, cast_options)
2135 }
2136 (Duration(TimeUnit::Microsecond), Interval(IntervalUnit::MonthDayNano)) => {
2137 cast_duration_to_interval::<DurationMicrosecondType>(array, cast_options)
2138 }
2139 (Duration(TimeUnit::Nanosecond), Interval(IntervalUnit::MonthDayNano)) => {
2140 cast_duration_to_interval::<DurationNanosecondType>(array, cast_options)
2141 }
2142 (Interval(IntervalUnit::MonthDayNano), Duration(TimeUnit::Second)) => {
2143 cast_month_day_nano_to_duration::<DurationSecondType>(array, cast_options)
2144 }
2145 (Interval(IntervalUnit::MonthDayNano), Duration(TimeUnit::Millisecond)) => {
2146 cast_month_day_nano_to_duration::<DurationMillisecondType>(array, cast_options)
2147 }
2148 (Interval(IntervalUnit::MonthDayNano), Duration(TimeUnit::Microsecond)) => {
2149 cast_month_day_nano_to_duration::<DurationMicrosecondType>(array, cast_options)
2150 }
2151 (Interval(IntervalUnit::MonthDayNano), Duration(TimeUnit::Nanosecond)) => {
2152 cast_month_day_nano_to_duration::<DurationNanosecondType>(array, cast_options)
2153 }
2154 (Interval(IntervalUnit::YearMonth), Interval(IntervalUnit::MonthDayNano)) => {
2155 cast_interval_year_month_to_interval_month_day_nano(array, cast_options)
2156 }
2157 (Interval(IntervalUnit::DayTime), Interval(IntervalUnit::MonthDayNano)) => {
2158 cast_interval_day_time_to_interval_month_day_nano(array, cast_options)
2159 }
2160 (Int32, Interval(IntervalUnit::YearMonth)) => {
2161 cast_reinterpret_arrays::<Int32Type, IntervalYearMonthType>(array)
2162 }
2163 (_, _) => Err(ArrowError::CastError(format!(
2164 "Casting from {from_type:?} to {to_type:?} not supported",
2165 ))),
2166 }
2167}
2168
2169fn cast_from_decimal<D, F>(
2170 array: &dyn Array,
2171 base: D::Native,
2172 scale: &i8,
2173 from_type: &DataType,
2174 to_type: &DataType,
2175 as_float: F,
2176 cast_options: &CastOptions,
2177) -> Result<ArrayRef, ArrowError>
2178where
2179 D: DecimalType + ArrowPrimitiveType,
2180 <D as ArrowPrimitiveType>::Native: ArrowNativeTypeOp + ToPrimitive,
2181 F: Fn(D::Native) -> f64,
2182{
2183 use DataType::*;
2184 match to_type {
2186 UInt8 => cast_decimal_to_integer::<D, UInt8Type>(array, base, *scale, cast_options),
2187 UInt16 => cast_decimal_to_integer::<D, UInt16Type>(array, base, *scale, cast_options),
2188 UInt32 => cast_decimal_to_integer::<D, UInt32Type>(array, base, *scale, cast_options),
2189 UInt64 => cast_decimal_to_integer::<D, UInt64Type>(array, base, *scale, cast_options),
2190 Int8 => cast_decimal_to_integer::<D, Int8Type>(array, base, *scale, cast_options),
2191 Int16 => cast_decimal_to_integer::<D, Int16Type>(array, base, *scale, cast_options),
2192 Int32 => cast_decimal_to_integer::<D, Int32Type>(array, base, *scale, cast_options),
2193 Int64 => cast_decimal_to_integer::<D, Int64Type>(array, base, *scale, cast_options),
2194 Float32 => cast_decimal_to_float::<D, Float32Type, _>(array, |x| {
2195 (as_float(x) / 10_f64.powi(*scale as i32)) as f32
2196 }),
2197 Float64 => cast_decimal_to_float::<D, Float64Type, _>(array, |x| {
2198 as_float(x) / 10_f64.powi(*scale as i32)
2199 }),
2200 Utf8View => value_to_string_view(array, cast_options),
2201 Utf8 => value_to_string::<i32>(array, cast_options),
2202 LargeUtf8 => value_to_string::<i64>(array, cast_options),
2203 Null => Ok(new_null_array(to_type, array.len())),
2204 _ => Err(ArrowError::CastError(format!(
2205 "Casting from {from_type:?} to {to_type:?} not supported"
2206 ))),
2207 }
2208}
2209
2210fn cast_to_decimal<D, M>(
2211 array: &dyn Array,
2212 base: M,
2213 precision: &u8,
2214 scale: &i8,
2215 from_type: &DataType,
2216 to_type: &DataType,
2217 cast_options: &CastOptions,
2218) -> Result<ArrayRef, ArrowError>
2219where
2220 D: DecimalType + ArrowPrimitiveType<Native = M>,
2221 M: ArrowNativeTypeOp + DecimalCast,
2222 u8: num::traits::AsPrimitive<M>,
2223 u16: num::traits::AsPrimitive<M>,
2224 u32: num::traits::AsPrimitive<M>,
2225 u64: num::traits::AsPrimitive<M>,
2226 i8: num::traits::AsPrimitive<M>,
2227 i16: num::traits::AsPrimitive<M>,
2228 i32: num::traits::AsPrimitive<M>,
2229 i64: num::traits::AsPrimitive<M>,
2230{
2231 use DataType::*;
2232 match from_type {
2234 UInt8 => cast_integer_to_decimal::<_, D, M>(
2235 array.as_primitive::<UInt8Type>(),
2236 *precision,
2237 *scale,
2238 base,
2239 cast_options,
2240 ),
2241 UInt16 => cast_integer_to_decimal::<_, D, _>(
2242 array.as_primitive::<UInt16Type>(),
2243 *precision,
2244 *scale,
2245 base,
2246 cast_options,
2247 ),
2248 UInt32 => cast_integer_to_decimal::<_, D, _>(
2249 array.as_primitive::<UInt32Type>(),
2250 *precision,
2251 *scale,
2252 base,
2253 cast_options,
2254 ),
2255 UInt64 => cast_integer_to_decimal::<_, D, _>(
2256 array.as_primitive::<UInt64Type>(),
2257 *precision,
2258 *scale,
2259 base,
2260 cast_options,
2261 ),
2262 Int8 => cast_integer_to_decimal::<_, D, _>(
2263 array.as_primitive::<Int8Type>(),
2264 *precision,
2265 *scale,
2266 base,
2267 cast_options,
2268 ),
2269 Int16 => cast_integer_to_decimal::<_, D, _>(
2270 array.as_primitive::<Int16Type>(),
2271 *precision,
2272 *scale,
2273 base,
2274 cast_options,
2275 ),
2276 Int32 => cast_integer_to_decimal::<_, D, _>(
2277 array.as_primitive::<Int32Type>(),
2278 *precision,
2279 *scale,
2280 base,
2281 cast_options,
2282 ),
2283 Int64 => cast_integer_to_decimal::<_, D, _>(
2284 array.as_primitive::<Int64Type>(),
2285 *precision,
2286 *scale,
2287 base,
2288 cast_options,
2289 ),
2290 Float32 => cast_floating_point_to_decimal::<_, D>(
2291 array.as_primitive::<Float32Type>(),
2292 *precision,
2293 *scale,
2294 cast_options,
2295 ),
2296 Float64 => cast_floating_point_to_decimal::<_, D>(
2297 array.as_primitive::<Float64Type>(),
2298 *precision,
2299 *scale,
2300 cast_options,
2301 ),
2302 Utf8View | Utf8 => {
2303 cast_string_to_decimal::<D, i32>(array, *precision, *scale, cast_options)
2304 }
2305 LargeUtf8 => cast_string_to_decimal::<D, i64>(array, *precision, *scale, cast_options),
2306 Null => Ok(new_null_array(to_type, array.len())),
2307 _ => Err(ArrowError::CastError(format!(
2308 "Casting from {from_type:?} to {to_type:?} not supported"
2309 ))),
2310 }
2311}
2312
2313const fn time_unit_multiple(unit: &TimeUnit) -> i64 {
2315 match unit {
2316 TimeUnit::Second => 1,
2317 TimeUnit::Millisecond => MILLISECONDS,
2318 TimeUnit::Microsecond => MICROSECONDS,
2319 TimeUnit::Nanosecond => NANOSECONDS,
2320 }
2321}
2322
2323fn cast_numeric_arrays<FROM, TO>(
2325 from: &dyn Array,
2326 cast_options: &CastOptions,
2327) -> Result<ArrayRef, ArrowError>
2328where
2329 FROM: ArrowPrimitiveType,
2330 TO: ArrowPrimitiveType,
2331 FROM::Native: NumCast,
2332 TO::Native: NumCast,
2333{
2334 if cast_options.safe {
2335 Ok(Arc::new(numeric_cast::<FROM, TO>(
2337 from.as_primitive::<FROM>(),
2338 )))
2339 } else {
2340 Ok(Arc::new(try_numeric_cast::<FROM, TO>(
2342 from.as_primitive::<FROM>(),
2343 )?))
2344 }
2345}
2346
2347fn try_numeric_cast<T, R>(from: &PrimitiveArray<T>) -> Result<PrimitiveArray<R>, ArrowError>
2350where
2351 T: ArrowPrimitiveType,
2352 R: ArrowPrimitiveType,
2353 T::Native: NumCast,
2354 R::Native: NumCast,
2355{
2356 from.try_unary(|value| {
2357 num::cast::cast::<T::Native, R::Native>(value).ok_or_else(|| {
2358 ArrowError::CastError(format!(
2359 "Can't cast value {:?} to type {}",
2360 value,
2361 R::DATA_TYPE
2362 ))
2363 })
2364 })
2365}
2366
2367fn numeric_cast<T, R>(from: &PrimitiveArray<T>) -> PrimitiveArray<R>
2370where
2371 T: ArrowPrimitiveType,
2372 R: ArrowPrimitiveType,
2373 T::Native: NumCast,
2374 R::Native: NumCast,
2375{
2376 from.unary_opt::<_, R>(num::cast::cast::<T::Native, R::Native>)
2377}
2378
2379fn cast_numeric_to_binary<FROM: ArrowPrimitiveType, O: OffsetSizeTrait>(
2380 array: &dyn Array,
2381) -> Result<ArrayRef, ArrowError> {
2382 let array = array.as_primitive::<FROM>();
2383 let size = std::mem::size_of::<FROM::Native>();
2384 let offsets = OffsetBuffer::from_lengths(std::iter::repeat_n(size, array.len()));
2385 Ok(Arc::new(GenericBinaryArray::<O>::new(
2386 offsets,
2387 array.values().inner().clone(),
2388 array.nulls().cloned(),
2389 )))
2390}
2391
2392fn adjust_timestamp_to_timezone<T: ArrowTimestampType>(
2393 array: PrimitiveArray<Int64Type>,
2394 to_tz: &Tz,
2395 cast_options: &CastOptions,
2396) -> Result<PrimitiveArray<Int64Type>, ArrowError> {
2397 let adjust = |o| {
2398 let local = as_datetime::<T>(o)?;
2399 let offset = to_tz.offset_from_local_datetime(&local).single()?;
2400 T::make_value(local - offset.fix())
2401 };
2402 let adjusted = if cast_options.safe {
2403 array.unary_opt::<_, Int64Type>(adjust)
2404 } else {
2405 array.try_unary::<_, Int64Type, _>(|o| {
2406 adjust(o).ok_or_else(|| {
2407 ArrowError::CastError("Cannot cast timezone to different timezone".to_string())
2408 })
2409 })?
2410 };
2411 Ok(adjusted)
2412}
2413
2414fn cast_numeric_to_bool<FROM>(from: &dyn Array) -> Result<ArrayRef, ArrowError>
2418where
2419 FROM: ArrowPrimitiveType,
2420{
2421 numeric_to_bool_cast::<FROM>(from.as_primitive::<FROM>()).map(|to| Arc::new(to) as ArrayRef)
2422}
2423
2424fn numeric_to_bool_cast<T>(from: &PrimitiveArray<T>) -> Result<BooleanArray, ArrowError>
2425where
2426 T: ArrowPrimitiveType + ArrowPrimitiveType,
2427{
2428 let mut b = BooleanBuilder::with_capacity(from.len());
2429
2430 for i in 0..from.len() {
2431 if from.is_null(i) {
2432 b.append_null();
2433 } else if from.value(i) != T::default_value() {
2434 b.append_value(true);
2435 } else {
2436 b.append_value(false);
2437 }
2438 }
2439
2440 Ok(b.finish())
2441}
2442
2443fn cast_bool_to_numeric<TO>(
2447 from: &dyn Array,
2448 cast_options: &CastOptions,
2449) -> Result<ArrayRef, ArrowError>
2450where
2451 TO: ArrowPrimitiveType,
2452 TO::Native: num::cast::NumCast,
2453{
2454 Ok(Arc::new(bool_to_numeric_cast::<TO>(
2455 from.as_any().downcast_ref::<BooleanArray>().unwrap(),
2456 cast_options,
2457 )))
2458}
2459
2460fn bool_to_numeric_cast<T>(from: &BooleanArray, _cast_options: &CastOptions) -> PrimitiveArray<T>
2461where
2462 T: ArrowPrimitiveType,
2463 T::Native: num::NumCast,
2464{
2465 let iter = (0..from.len()).map(|i| {
2466 if from.is_null(i) {
2467 None
2468 } else if from.value(i) {
2469 num::cast::cast(1)
2471 } else {
2472 Some(T::default_value())
2473 }
2474 });
2475 unsafe { PrimitiveArray::<T>::from_trusted_len_iter(iter) }
2480}
2481
2482fn cast_binary_to_fixed_size_binary<O: OffsetSizeTrait>(
2484 array: &dyn Array,
2485 byte_width: i32,
2486 cast_options: &CastOptions,
2487) -> Result<ArrayRef, ArrowError> {
2488 let array = array.as_binary::<O>();
2489 let mut builder = FixedSizeBinaryBuilder::with_capacity(array.len(), byte_width);
2490
2491 for i in 0..array.len() {
2492 if array.is_null(i) {
2493 builder.append_null();
2494 } else {
2495 match builder.append_value(array.value(i)) {
2496 Ok(_) => {}
2497 Err(e) => match cast_options.safe {
2498 true => builder.append_null(),
2499 false => return Err(e),
2500 },
2501 }
2502 }
2503 }
2504
2505 Ok(Arc::new(builder.finish()))
2506}
2507
2508fn cast_fixed_size_binary_to_binary<O: OffsetSizeTrait>(
2511 array: &dyn Array,
2512 byte_width: i32,
2513) -> Result<ArrayRef, ArrowError> {
2514 let array = array
2515 .as_any()
2516 .downcast_ref::<FixedSizeBinaryArray>()
2517 .unwrap();
2518
2519 let offsets: i128 = byte_width as i128 * array.len() as i128;
2520
2521 let is_binary = matches!(GenericBinaryType::<O>::DATA_TYPE, DataType::Binary);
2522 if is_binary && offsets > i32::MAX as i128 {
2523 return Err(ArrowError::ComputeError(
2524 "FixedSizeBinary array too large to cast to Binary array".to_string(),
2525 ));
2526 } else if !is_binary && offsets > i64::MAX as i128 {
2527 return Err(ArrowError::ComputeError(
2528 "FixedSizeBinary array too large to cast to LargeBinary array".to_string(),
2529 ));
2530 }
2531
2532 let mut builder = GenericBinaryBuilder::<O>::with_capacity(array.len(), array.len());
2533
2534 for i in 0..array.len() {
2535 if array.is_null(i) {
2536 builder.append_null();
2537 } else {
2538 builder.append_value(array.value(i));
2539 }
2540 }
2541
2542 Ok(Arc::new(builder.finish()))
2543}
2544
2545fn cast_fixed_size_binary_to_binary_view(
2546 array: &dyn Array,
2547 _byte_width: i32,
2548) -> Result<ArrayRef, ArrowError> {
2549 let array = array
2550 .as_any()
2551 .downcast_ref::<FixedSizeBinaryArray>()
2552 .unwrap();
2553
2554 let mut builder = BinaryViewBuilder::with_capacity(array.len());
2555 for i in 0..array.len() {
2556 if array.is_null(i) {
2557 builder.append_null();
2558 } else {
2559 builder.append_value(array.value(i));
2560 }
2561 }
2562
2563 Ok(Arc::new(builder.finish()))
2564}
2565
2566fn cast_byte_container<FROM, TO>(array: &dyn Array) -> Result<ArrayRef, ArrowError>
2569where
2570 FROM: ByteArrayType,
2571 TO: ByteArrayType<Native = FROM::Native>,
2572 FROM::Offset: OffsetSizeTrait + ToPrimitive,
2573 TO::Offset: OffsetSizeTrait + NumCast,
2574{
2575 let data = array.to_data();
2576 assert_eq!(data.data_type(), &FROM::DATA_TYPE);
2577 let str_values_buf = data.buffers()[1].clone();
2578 let offsets = data.buffers()[0].typed_data::<FROM::Offset>();
2579
2580 let mut offset_builder = BufferBuilder::<TO::Offset>::new(offsets.len());
2581 offsets
2582 .iter()
2583 .try_for_each::<_, Result<_, ArrowError>>(|offset| {
2584 let offset =
2585 <<TO as ByteArrayType>::Offset as NumCast>::from(*offset).ok_or_else(|| {
2586 ArrowError::ComputeError(format!(
2587 "{}{} array too large to cast to {}{} array",
2588 FROM::Offset::PREFIX,
2589 FROM::PREFIX,
2590 TO::Offset::PREFIX,
2591 TO::PREFIX
2592 ))
2593 })?;
2594 offset_builder.append(offset);
2595 Ok(())
2596 })?;
2597
2598 let offset_buffer = offset_builder.finish();
2599
2600 let dtype = TO::DATA_TYPE;
2601
2602 let builder = ArrayData::builder(dtype)
2603 .offset(array.offset())
2604 .len(array.len())
2605 .add_buffer(offset_buffer)
2606 .add_buffer(str_values_buf)
2607 .nulls(data.nulls().cloned());
2608
2609 let array_data = unsafe { builder.build_unchecked() };
2610
2611 Ok(Arc::new(GenericByteArray::<TO>::from(array_data)))
2612}
2613
2614fn cast_view_to_byte<FROM, TO>(array: &dyn Array) -> Result<ArrayRef, ArrowError>
2616where
2617 FROM: ByteViewType,
2618 TO: ByteArrayType,
2619 FROM::Native: AsRef<TO::Native>,
2620{
2621 let data = array.to_data();
2622 let view_array = GenericByteViewArray::<FROM>::from(data);
2623
2624 let len = view_array.len();
2625 let bytes = view_array
2626 .views()
2627 .iter()
2628 .map(|v| ByteView::from(*v).length as usize)
2629 .sum::<usize>();
2630
2631 let mut byte_array_builder = GenericByteBuilder::<TO>::with_capacity(len, bytes);
2632
2633 for val in view_array.iter() {
2634 byte_array_builder.append_option(val);
2635 }
2636
2637 Ok(Arc::new(byte_array_builder.finish()))
2638}
2639
2640#[cfg(test)]
2641mod tests {
2642 use super::*;
2643 use arrow_buffer::i256;
2644 use arrow_buffer::{Buffer, IntervalDayTime, NullBuffer};
2645 use chrono::NaiveDate;
2646 use half::f16;
2647
2648 #[derive(Clone)]
2649 struct DecimalCastTestConfig {
2650 input_prec: u8,
2651 input_scale: i8,
2652 input_repr: i128,
2653 output_prec: u8,
2654 output_scale: i8,
2655 expected_output_repr: Result<i128, String>, }
2660
2661 macro_rules! generate_cast_test_case {
2662 ($INPUT_ARRAY: expr, $OUTPUT_TYPE_ARRAY: ident, $OUTPUT_TYPE: expr, $OUTPUT_VALUES: expr) => {
2663 let output =
2664 $OUTPUT_TYPE_ARRAY::from($OUTPUT_VALUES).with_data_type($OUTPUT_TYPE.clone());
2665
2666 let input_array_type = $INPUT_ARRAY.data_type();
2668 assert!(can_cast_types(input_array_type, $OUTPUT_TYPE));
2669 let result = cast($INPUT_ARRAY, $OUTPUT_TYPE).unwrap();
2670 assert_eq!($OUTPUT_TYPE, result.data_type());
2671 assert_eq!(result.as_ref(), &output);
2672
2673 let cast_option = CastOptions {
2674 safe: false,
2675 format_options: FormatOptions::default(),
2676 };
2677 let result = cast_with_options($INPUT_ARRAY, $OUTPUT_TYPE, &cast_option).unwrap();
2678 assert_eq!($OUTPUT_TYPE, result.data_type());
2679 assert_eq!(result.as_ref(), &output);
2680 };
2681 }
2682
2683 fn run_decimal_cast_test_case<I, O>(t: DecimalCastTestConfig)
2684 where
2685 I: DecimalType,
2686 O: DecimalType,
2687 I::Native: DecimalCast,
2688 O::Native: DecimalCast,
2689 {
2690 let array = vec![I::Native::from_decimal(t.input_repr)];
2691 let array = array
2692 .into_iter()
2693 .collect::<PrimitiveArray<I>>()
2694 .with_precision_and_scale(t.input_prec, t.input_scale)
2695 .unwrap();
2696 let input_type = array.data_type();
2697 let output_type = O::TYPE_CONSTRUCTOR(t.output_prec, t.output_scale);
2698 assert!(can_cast_types(input_type, &output_type));
2699
2700 let options = CastOptions {
2701 safe: false,
2702 ..Default::default()
2703 };
2704 let result = cast_with_options(&array, &output_type, &options);
2705
2706 match t.expected_output_repr {
2707 Ok(v) => {
2708 let expected_array = vec![O::Native::from_decimal(v)];
2709 let expected_array = expected_array
2710 .into_iter()
2711 .collect::<PrimitiveArray<O>>()
2712 .with_precision_and_scale(t.output_prec, t.output_scale)
2713 .unwrap();
2714 assert_eq!(*result.unwrap(), expected_array);
2715 }
2716 Err(expected_output_message_template) => {
2717 assert!(result.is_err());
2718 let expected_error_message =
2719 expected_output_message_template.replace("{}", O::PREFIX);
2720 assert_eq!(result.unwrap_err().to_string(), expected_error_message);
2721 }
2722 }
2723 }
2724
2725 fn create_decimal32_array(
2726 array: Vec<Option<i32>>,
2727 precision: u8,
2728 scale: i8,
2729 ) -> Result<Decimal32Array, ArrowError> {
2730 array
2731 .into_iter()
2732 .collect::<Decimal32Array>()
2733 .with_precision_and_scale(precision, scale)
2734 }
2735
2736 fn create_decimal64_array(
2737 array: Vec<Option<i64>>,
2738 precision: u8,
2739 scale: i8,
2740 ) -> Result<Decimal64Array, ArrowError> {
2741 array
2742 .into_iter()
2743 .collect::<Decimal64Array>()
2744 .with_precision_and_scale(precision, scale)
2745 }
2746
2747 fn create_decimal128_array(
2748 array: Vec<Option<i128>>,
2749 precision: u8,
2750 scale: i8,
2751 ) -> Result<Decimal128Array, ArrowError> {
2752 array
2753 .into_iter()
2754 .collect::<Decimal128Array>()
2755 .with_precision_and_scale(precision, scale)
2756 }
2757
2758 fn create_decimal256_array(
2759 array: Vec<Option<i256>>,
2760 precision: u8,
2761 scale: i8,
2762 ) -> Result<Decimal256Array, ArrowError> {
2763 array
2764 .into_iter()
2765 .collect::<Decimal256Array>()
2766 .with_precision_and_scale(precision, scale)
2767 }
2768
2769 #[test]
2770 #[cfg(not(feature = "force_validate"))]
2771 #[should_panic(
2772 expected = "Cannot cast to Decimal128(20, 3). Overflowing on 57896044618658097711785492504343953926634992332820282019728792003956564819967"
2773 )]
2774 fn test_cast_decimal_to_decimal_round_with_error() {
2775 let array = vec![
2777 Some(i256::from_i128(1123454)),
2778 Some(i256::from_i128(2123456)),
2779 Some(i256::from_i128(-3123453)),
2780 Some(i256::from_i128(-3123456)),
2781 None,
2782 Some(i256::MAX),
2783 Some(i256::MIN),
2784 ];
2785 let input_decimal_array = create_decimal256_array(array, 76, 4).unwrap();
2786 let array = Arc::new(input_decimal_array) as ArrayRef;
2787 let input_type = DataType::Decimal256(76, 4);
2788 let output_type = DataType::Decimal128(20, 3);
2789 assert!(can_cast_types(&input_type, &output_type));
2790 generate_cast_test_case!(
2791 &array,
2792 Decimal128Array,
2793 &output_type,
2794 vec![
2795 Some(112345_i128),
2796 Some(212346_i128),
2797 Some(-312345_i128),
2798 Some(-312346_i128),
2799 None,
2800 None,
2801 None,
2802 ]
2803 );
2804 }
2805
2806 #[test]
2807 #[cfg(not(feature = "force_validate"))]
2808 fn test_cast_decimal_to_decimal_round() {
2809 let array = vec![
2810 Some(1123454),
2811 Some(2123456),
2812 Some(-3123453),
2813 Some(-3123456),
2814 None,
2815 ];
2816 let array = create_decimal128_array(array, 20, 4).unwrap();
2817 let input_type = DataType::Decimal128(20, 4);
2819 let output_type = DataType::Decimal128(20, 3);
2820 assert!(can_cast_types(&input_type, &output_type));
2821 generate_cast_test_case!(
2822 &array,
2823 Decimal128Array,
2824 &output_type,
2825 vec![
2826 Some(112345_i128),
2827 Some(212346_i128),
2828 Some(-312345_i128),
2829 Some(-312346_i128),
2830 None
2831 ]
2832 );
2833
2834 let input_type = DataType::Decimal128(20, 4);
2836 let output_type = DataType::Decimal256(20, 3);
2837 assert!(can_cast_types(&input_type, &output_type));
2838 generate_cast_test_case!(
2839 &array,
2840 Decimal256Array,
2841 &output_type,
2842 vec![
2843 Some(i256::from_i128(112345_i128)),
2844 Some(i256::from_i128(212346_i128)),
2845 Some(i256::from_i128(-312345_i128)),
2846 Some(i256::from_i128(-312346_i128)),
2847 None
2848 ]
2849 );
2850
2851 let array = vec![
2853 Some(i256::from_i128(1123454)),
2854 Some(i256::from_i128(2123456)),
2855 Some(i256::from_i128(-3123453)),
2856 Some(i256::from_i128(-3123456)),
2857 None,
2858 ];
2859 let array = create_decimal256_array(array, 20, 4).unwrap();
2860
2861 let input_type = DataType::Decimal256(20, 4);
2863 let output_type = DataType::Decimal256(20, 3);
2864 assert!(can_cast_types(&input_type, &output_type));
2865 generate_cast_test_case!(
2866 &array,
2867 Decimal256Array,
2868 &output_type,
2869 vec![
2870 Some(i256::from_i128(112345_i128)),
2871 Some(i256::from_i128(212346_i128)),
2872 Some(i256::from_i128(-312345_i128)),
2873 Some(i256::from_i128(-312346_i128)),
2874 None
2875 ]
2876 );
2877 let input_type = DataType::Decimal256(20, 4);
2879 let output_type = DataType::Decimal128(20, 3);
2880 assert!(can_cast_types(&input_type, &output_type));
2881 generate_cast_test_case!(
2882 &array,
2883 Decimal128Array,
2884 &output_type,
2885 vec![
2886 Some(112345_i128),
2887 Some(212346_i128),
2888 Some(-312345_i128),
2889 Some(-312346_i128),
2890 None
2891 ]
2892 );
2893 }
2894
2895 #[test]
2896 fn test_cast_decimal32_to_decimal32() {
2897 let input_type = DataType::Decimal32(9, 3);
2899 let output_type = DataType::Decimal32(9, 4);
2900 assert!(can_cast_types(&input_type, &output_type));
2901 let array = vec![Some(1123456), Some(2123456), Some(3123456), None];
2902 let array = create_decimal32_array(array, 9, 3).unwrap();
2903 generate_cast_test_case!(
2904 &array,
2905 Decimal32Array,
2906 &output_type,
2907 vec![
2908 Some(11234560_i32),
2909 Some(21234560_i32),
2910 Some(31234560_i32),
2911 None
2912 ]
2913 );
2914 let array = vec![Some(123456), None];
2916 let array = create_decimal32_array(array, 9, 0).unwrap();
2917 let result_safe = cast(&array, &DataType::Decimal32(2, 2));
2918 assert!(result_safe.is_ok());
2919 let options = CastOptions {
2920 safe: false,
2921 ..Default::default()
2922 };
2923
2924 let result_unsafe = cast_with_options(&array, &DataType::Decimal32(2, 2), &options);
2925 assert_eq!("Invalid argument error: 12345600 is too large to store in a Decimal32 of precision 2. Max is 99",
2926 result_unsafe.unwrap_err().to_string());
2927 }
2928
2929 #[test]
2930 fn test_cast_decimal64_to_decimal64() {
2931 let input_type = DataType::Decimal64(17, 3);
2933 let output_type = DataType::Decimal64(17, 4);
2934 assert!(can_cast_types(&input_type, &output_type));
2935 let array = vec![Some(1123456), Some(2123456), Some(3123456), None];
2936 let array = create_decimal64_array(array, 17, 3).unwrap();
2937 generate_cast_test_case!(
2938 &array,
2939 Decimal64Array,
2940 &output_type,
2941 vec![
2942 Some(11234560_i64),
2943 Some(21234560_i64),
2944 Some(31234560_i64),
2945 None
2946 ]
2947 );
2948 let array = vec![Some(123456), None];
2950 let array = create_decimal64_array(array, 9, 0).unwrap();
2951 let result_safe = cast(&array, &DataType::Decimal64(2, 2));
2952 assert!(result_safe.is_ok());
2953 let options = CastOptions {
2954 safe: false,
2955 ..Default::default()
2956 };
2957
2958 let result_unsafe = cast_with_options(&array, &DataType::Decimal64(2, 2), &options);
2959 assert_eq!("Invalid argument error: 12345600 is too large to store in a Decimal64 of precision 2. Max is 99",
2960 result_unsafe.unwrap_err().to_string());
2961 }
2962
2963 #[test]
2964 fn test_cast_decimal128_to_decimal128() {
2965 let input_type = DataType::Decimal128(20, 3);
2967 let output_type = DataType::Decimal128(20, 4);
2968 assert!(can_cast_types(&input_type, &output_type));
2969 let array = vec![Some(1123456), Some(2123456), Some(3123456), None];
2970 let array = create_decimal128_array(array, 20, 3).unwrap();
2971 generate_cast_test_case!(
2972 &array,
2973 Decimal128Array,
2974 &output_type,
2975 vec![
2976 Some(11234560_i128),
2977 Some(21234560_i128),
2978 Some(31234560_i128),
2979 None
2980 ]
2981 );
2982 let array = vec![Some(123456), None];
2984 let array = create_decimal128_array(array, 10, 0).unwrap();
2985 let result_safe = cast(&array, &DataType::Decimal128(2, 2));
2986 assert!(result_safe.is_ok());
2987 let options = CastOptions {
2988 safe: false,
2989 ..Default::default()
2990 };
2991
2992 let result_unsafe = cast_with_options(&array, &DataType::Decimal128(2, 2), &options);
2993 assert_eq!("Invalid argument error: 12345600 is too large to store in a Decimal128 of precision 2. Max is 99",
2994 result_unsafe.unwrap_err().to_string());
2995 }
2996
2997 #[test]
2998 fn test_cast_decimal32_to_decimal32_dict() {
2999 let p = 9;
3000 let s = 3;
3001 let input_type = DataType::Decimal32(p, s);
3002 let output_type = DataType::Dictionary(
3003 Box::new(DataType::Int32),
3004 Box::new(DataType::Decimal32(p, s)),
3005 );
3006 assert!(can_cast_types(&input_type, &output_type));
3007 let array = vec![Some(1123456), Some(2123456), Some(3123456), None];
3008 let array = create_decimal32_array(array, p, s).unwrap();
3009 let cast_array = cast_with_options(&array, &output_type, &CastOptions::default()).unwrap();
3010 assert_eq!(cast_array.data_type(), &output_type);
3011 }
3012
3013 #[test]
3014 fn test_cast_decimal64_to_decimal64_dict() {
3015 let p = 15;
3016 let s = 3;
3017 let input_type = DataType::Decimal64(p, s);
3018 let output_type = DataType::Dictionary(
3019 Box::new(DataType::Int32),
3020 Box::new(DataType::Decimal64(p, s)),
3021 );
3022 assert!(can_cast_types(&input_type, &output_type));
3023 let array = vec![Some(1123456), Some(2123456), Some(3123456), None];
3024 let array = create_decimal64_array(array, p, s).unwrap();
3025 let cast_array = cast_with_options(&array, &output_type, &CastOptions::default()).unwrap();
3026 assert_eq!(cast_array.data_type(), &output_type);
3027 }
3028
3029 #[test]
3030 fn test_cast_decimal128_to_decimal128_dict() {
3031 let p = 20;
3032 let s = 3;
3033 let input_type = DataType::Decimal128(p, s);
3034 let output_type = DataType::Dictionary(
3035 Box::new(DataType::Int32),
3036 Box::new(DataType::Decimal128(p, s)),
3037 );
3038 assert!(can_cast_types(&input_type, &output_type));
3039 let array = vec![Some(1123456), Some(2123456), Some(3123456), None];
3040 let array = create_decimal128_array(array, p, s).unwrap();
3041 let cast_array = cast_with_options(&array, &output_type, &CastOptions::default()).unwrap();
3042 assert_eq!(cast_array.data_type(), &output_type);
3043 }
3044
3045 #[test]
3046 fn test_cast_decimal256_to_decimal256_dict() {
3047 let p = 20;
3048 let s = 3;
3049 let input_type = DataType::Decimal256(p, s);
3050 let output_type = DataType::Dictionary(
3051 Box::new(DataType::Int32),
3052 Box::new(DataType::Decimal256(p, s)),
3053 );
3054 assert!(can_cast_types(&input_type, &output_type));
3055 let array = vec![Some(1123456), Some(2123456), Some(3123456), None];
3056 let array = create_decimal128_array(array, p, s).unwrap();
3057 let cast_array = cast_with_options(&array, &output_type, &CastOptions::default()).unwrap();
3058 assert_eq!(cast_array.data_type(), &output_type);
3059 }
3060
3061 #[test]
3062 fn test_cast_decimal32_to_decimal32_overflow() {
3063 let input_type = DataType::Decimal32(9, 3);
3064 let output_type = DataType::Decimal32(9, 9);
3065 assert!(can_cast_types(&input_type, &output_type));
3066
3067 let array = vec![Some(i32::MAX)];
3068 let array = create_decimal32_array(array, 9, 3).unwrap();
3069 let result = cast_with_options(
3070 &array,
3071 &output_type,
3072 &CastOptions {
3073 safe: false,
3074 format_options: FormatOptions::default(),
3075 },
3076 );
3077 assert_eq!(
3078 "Cast error: Cannot cast to Decimal32(9, 9). Overflowing on 2147483647",
3079 result.unwrap_err().to_string()
3080 );
3081 }
3082
3083 #[test]
3084 fn test_cast_decimal64_to_decimal64_overflow() {
3085 let input_type = DataType::Decimal64(18, 3);
3086 let output_type = DataType::Decimal64(18, 18);
3087 assert!(can_cast_types(&input_type, &output_type));
3088
3089 let array = vec![Some(i64::MAX)];
3090 let array = create_decimal64_array(array, 18, 3).unwrap();
3091 let result = cast_with_options(
3092 &array,
3093 &output_type,
3094 &CastOptions {
3095 safe: false,
3096 format_options: FormatOptions::default(),
3097 },
3098 );
3099 assert_eq!(
3100 "Cast error: Cannot cast to Decimal64(18, 18). Overflowing on 9223372036854775807",
3101 result.unwrap_err().to_string()
3102 );
3103 }
3104
3105 #[test]
3106 fn test_cast_decimal128_to_decimal128_overflow() {
3107 let input_type = DataType::Decimal128(38, 3);
3108 let output_type = DataType::Decimal128(38, 38);
3109 assert!(can_cast_types(&input_type, &output_type));
3110
3111 let array = vec![Some(i128::MAX)];
3112 let array = create_decimal128_array(array, 38, 3).unwrap();
3113 let result = cast_with_options(
3114 &array,
3115 &output_type,
3116 &CastOptions {
3117 safe: false,
3118 format_options: FormatOptions::default(),
3119 },
3120 );
3121 assert_eq!("Cast error: Cannot cast to Decimal128(38, 38). Overflowing on 170141183460469231731687303715884105727",
3122 result.unwrap_err().to_string());
3123 }
3124
3125 #[test]
3126 fn test_cast_decimal128_to_decimal256_overflow() {
3127 let input_type = DataType::Decimal128(38, 3);
3128 let output_type = DataType::Decimal256(76, 76);
3129 assert!(can_cast_types(&input_type, &output_type));
3130
3131 let array = vec![Some(i128::MAX)];
3132 let array = create_decimal128_array(array, 38, 3).unwrap();
3133 let result = cast_with_options(
3134 &array,
3135 &output_type,
3136 &CastOptions {
3137 safe: false,
3138 format_options: FormatOptions::default(),
3139 },
3140 );
3141 assert_eq!("Cast error: Cannot cast to Decimal256(76, 76). Overflowing on 170141183460469231731687303715884105727",
3142 result.unwrap_err().to_string());
3143 }
3144
3145 #[test]
3146 fn test_cast_decimal32_to_decimal256() {
3147 let input_type = DataType::Decimal32(8, 3);
3148 let output_type = DataType::Decimal256(20, 4);
3149 assert!(can_cast_types(&input_type, &output_type));
3150 let array = vec![Some(1123456), Some(2123456), Some(3123456), None];
3151 let array = create_decimal32_array(array, 8, 3).unwrap();
3152 generate_cast_test_case!(
3153 &array,
3154 Decimal256Array,
3155 &output_type,
3156 vec![
3157 Some(i256::from_i128(11234560_i128)),
3158 Some(i256::from_i128(21234560_i128)),
3159 Some(i256::from_i128(31234560_i128)),
3160 None
3161 ]
3162 );
3163 }
3164 #[test]
3165 fn test_cast_decimal64_to_decimal256() {
3166 let input_type = DataType::Decimal64(12, 3);
3167 let output_type = DataType::Decimal256(20, 4);
3168 assert!(can_cast_types(&input_type, &output_type));
3169 let array = vec![Some(1123456), Some(2123456), Some(3123456), None];
3170 let array = create_decimal64_array(array, 12, 3).unwrap();
3171 generate_cast_test_case!(
3172 &array,
3173 Decimal256Array,
3174 &output_type,
3175 vec![
3176 Some(i256::from_i128(11234560_i128)),
3177 Some(i256::from_i128(21234560_i128)),
3178 Some(i256::from_i128(31234560_i128)),
3179 None
3180 ]
3181 );
3182 }
3183 #[test]
3184 fn test_cast_decimal128_to_decimal256() {
3185 let input_type = DataType::Decimal128(20, 3);
3186 let output_type = DataType::Decimal256(20, 4);
3187 assert!(can_cast_types(&input_type, &output_type));
3188 let array = vec![Some(1123456), Some(2123456), Some(3123456), None];
3189 let array = create_decimal128_array(array, 20, 3).unwrap();
3190 generate_cast_test_case!(
3191 &array,
3192 Decimal256Array,
3193 &output_type,
3194 vec![
3195 Some(i256::from_i128(11234560_i128)),
3196 Some(i256::from_i128(21234560_i128)),
3197 Some(i256::from_i128(31234560_i128)),
3198 None
3199 ]
3200 );
3201 }
3202
3203 #[test]
3204 fn test_cast_decimal256_to_decimal128_overflow() {
3205 let input_type = DataType::Decimal256(76, 5);
3206 let output_type = DataType::Decimal128(38, 7);
3207 assert!(can_cast_types(&input_type, &output_type));
3208 let array = vec![Some(i256::from_i128(i128::MAX))];
3209 let array = create_decimal256_array(array, 76, 5).unwrap();
3210 let result = cast_with_options(
3211 &array,
3212 &output_type,
3213 &CastOptions {
3214 safe: false,
3215 format_options: FormatOptions::default(),
3216 },
3217 );
3218 assert_eq!("Cast error: Cannot cast to Decimal128(38, 7). Overflowing on 170141183460469231731687303715884105727",
3219 result.unwrap_err().to_string());
3220 }
3221
3222 #[test]
3223 fn test_cast_decimal256_to_decimal256_overflow() {
3224 let input_type = DataType::Decimal256(76, 5);
3225 let output_type = DataType::Decimal256(76, 55);
3226 assert!(can_cast_types(&input_type, &output_type));
3227 let array = vec![Some(i256::from_i128(i128::MAX))];
3228 let array = create_decimal256_array(array, 76, 5).unwrap();
3229 let result = cast_with_options(
3230 &array,
3231 &output_type,
3232 &CastOptions {
3233 safe: false,
3234 format_options: FormatOptions::default(),
3235 },
3236 );
3237 assert_eq!("Cast error: Cannot cast to Decimal256(76, 55). Overflowing on 170141183460469231731687303715884105727",
3238 result.unwrap_err().to_string());
3239 }
3240
3241 #[test]
3242 fn test_cast_decimal256_to_decimal128() {
3243 let input_type = DataType::Decimal256(20, 3);
3244 let output_type = DataType::Decimal128(20, 4);
3245 assert!(can_cast_types(&input_type, &output_type));
3246 let array = vec![
3247 Some(i256::from_i128(1123456)),
3248 Some(i256::from_i128(2123456)),
3249 Some(i256::from_i128(3123456)),
3250 None,
3251 ];
3252 let array = create_decimal256_array(array, 20, 3).unwrap();
3253 generate_cast_test_case!(
3254 &array,
3255 Decimal128Array,
3256 &output_type,
3257 vec![
3258 Some(11234560_i128),
3259 Some(21234560_i128),
3260 Some(31234560_i128),
3261 None
3262 ]
3263 );
3264 }
3265
3266 #[test]
3267 fn test_cast_decimal256_to_decimal256() {
3268 let input_type = DataType::Decimal256(20, 3);
3269 let output_type = DataType::Decimal256(20, 4);
3270 assert!(can_cast_types(&input_type, &output_type));
3271 let array = vec![
3272 Some(i256::from_i128(1123456)),
3273 Some(i256::from_i128(2123456)),
3274 Some(i256::from_i128(3123456)),
3275 None,
3276 ];
3277 let array = create_decimal256_array(array, 20, 3).unwrap();
3278 generate_cast_test_case!(
3279 &array,
3280 Decimal256Array,
3281 &output_type,
3282 vec![
3283 Some(i256::from_i128(11234560_i128)),
3284 Some(i256::from_i128(21234560_i128)),
3285 Some(i256::from_i128(31234560_i128)),
3286 None
3287 ]
3288 );
3289 }
3290
3291 fn generate_decimal_to_numeric_cast_test_case<T>(array: &PrimitiveArray<T>)
3292 where
3293 T: ArrowPrimitiveType + DecimalType,
3294 {
3295 generate_cast_test_case!(
3297 array,
3298 UInt8Array,
3299 &DataType::UInt8,
3300 vec![Some(1_u8), Some(2_u8), Some(3_u8), None, Some(5_u8)]
3301 );
3302 generate_cast_test_case!(
3304 array,
3305 UInt16Array,
3306 &DataType::UInt16,
3307 vec![Some(1_u16), Some(2_u16), Some(3_u16), None, Some(5_u16)]
3308 );
3309 generate_cast_test_case!(
3311 array,
3312 UInt32Array,
3313 &DataType::UInt32,
3314 vec![Some(1_u32), Some(2_u32), Some(3_u32), None, Some(5_u32)]
3315 );
3316 generate_cast_test_case!(
3318 array,
3319 UInt64Array,
3320 &DataType::UInt64,
3321 vec![Some(1_u64), Some(2_u64), Some(3_u64), None, Some(5_u64)]
3322 );
3323 generate_cast_test_case!(
3325 array,
3326 Int8Array,
3327 &DataType::Int8,
3328 vec![Some(1_i8), Some(2_i8), Some(3_i8), None, Some(5_i8)]
3329 );
3330 generate_cast_test_case!(
3332 array,
3333 Int16Array,
3334 &DataType::Int16,
3335 vec![Some(1_i16), Some(2_i16), Some(3_i16), None, Some(5_i16)]
3336 );
3337 generate_cast_test_case!(
3339 array,
3340 Int32Array,
3341 &DataType::Int32,
3342 vec![Some(1_i32), Some(2_i32), Some(3_i32), None, Some(5_i32)]
3343 );
3344 generate_cast_test_case!(
3346 array,
3347 Int64Array,
3348 &DataType::Int64,
3349 vec![Some(1_i64), Some(2_i64), Some(3_i64), None, Some(5_i64)]
3350 );
3351 generate_cast_test_case!(
3353 array,
3354 Float32Array,
3355 &DataType::Float32,
3356 vec![
3357 Some(1.25_f32),
3358 Some(2.25_f32),
3359 Some(3.25_f32),
3360 None,
3361 Some(5.25_f32)
3362 ]
3363 );
3364 generate_cast_test_case!(
3366 array,
3367 Float64Array,
3368 &DataType::Float64,
3369 vec![
3370 Some(1.25_f64),
3371 Some(2.25_f64),
3372 Some(3.25_f64),
3373 None,
3374 Some(5.25_f64)
3375 ]
3376 );
3377 }
3378
3379 #[test]
3380 fn test_cast_decimal32_to_numeric() {
3381 let value_array: Vec<Option<i32>> = vec![Some(125), Some(225), Some(325), None, Some(525)];
3382 let array = create_decimal32_array(value_array, 8, 2).unwrap();
3383
3384 generate_decimal_to_numeric_cast_test_case(&array);
3385 }
3386
3387 #[test]
3388 fn test_cast_decimal64_to_numeric() {
3389 let value_array: Vec<Option<i64>> = vec![Some(125), Some(225), Some(325), None, Some(525)];
3390 let array = create_decimal64_array(value_array, 8, 2).unwrap();
3391
3392 generate_decimal_to_numeric_cast_test_case(&array);
3393 }
3394
3395 #[test]
3396 fn test_cast_decimal128_to_numeric() {
3397 let value_array: Vec<Option<i128>> = vec![Some(125), Some(225), Some(325), None, Some(525)];
3398 let array = create_decimal128_array(value_array, 38, 2).unwrap();
3399
3400 generate_decimal_to_numeric_cast_test_case(&array);
3401
3402 let value_array: Vec<Option<i128>> = vec![Some(51300)];
3404 let array = create_decimal128_array(value_array, 38, 2).unwrap();
3405 let casted_array = cast_with_options(
3406 &array,
3407 &DataType::UInt8,
3408 &CastOptions {
3409 safe: false,
3410 format_options: FormatOptions::default(),
3411 },
3412 );
3413 assert_eq!(
3414 "Cast error: value of 513 is out of range UInt8".to_string(),
3415 casted_array.unwrap_err().to_string()
3416 );
3417
3418 let casted_array = cast_with_options(
3419 &array,
3420 &DataType::UInt8,
3421 &CastOptions {
3422 safe: true,
3423 format_options: FormatOptions::default(),
3424 },
3425 );
3426 assert!(casted_array.is_ok());
3427 assert!(casted_array.unwrap().is_null(0));
3428
3429 let value_array: Vec<Option<i128>> = vec![Some(24400)];
3431 let array = create_decimal128_array(value_array, 38, 2).unwrap();
3432 let casted_array = cast_with_options(
3433 &array,
3434 &DataType::Int8,
3435 &CastOptions {
3436 safe: false,
3437 format_options: FormatOptions::default(),
3438 },
3439 );
3440 assert_eq!(
3441 "Cast error: value of 244 is out of range Int8".to_string(),
3442 casted_array.unwrap_err().to_string()
3443 );
3444
3445 let casted_array = cast_with_options(
3446 &array,
3447 &DataType::Int8,
3448 &CastOptions {
3449 safe: true,
3450 format_options: FormatOptions::default(),
3451 },
3452 );
3453 assert!(casted_array.is_ok());
3454 assert!(casted_array.unwrap().is_null(0));
3455
3456 let value_array: Vec<Option<i128>> = vec![
3460 Some(125),
3461 Some(225),
3462 Some(325),
3463 None,
3464 Some(525),
3465 Some(112345678),
3466 Some(112345679),
3467 ];
3468 let array = create_decimal128_array(value_array, 38, 2).unwrap();
3469 generate_cast_test_case!(
3470 &array,
3471 Float32Array,
3472 &DataType::Float32,
3473 vec![
3474 Some(1.25_f32),
3475 Some(2.25_f32),
3476 Some(3.25_f32),
3477 None,
3478 Some(5.25_f32),
3479 Some(1_123_456.7_f32),
3480 Some(1_123_456.7_f32)
3481 ]
3482 );
3483
3484 let value_array: Vec<Option<i128>> = vec![
3487 Some(125),
3488 Some(225),
3489 Some(325),
3490 None,
3491 Some(525),
3492 Some(112345678901234568),
3493 Some(112345678901234560),
3494 ];
3495 let array = create_decimal128_array(value_array, 38, 2).unwrap();
3496 generate_cast_test_case!(
3497 &array,
3498 Float64Array,
3499 &DataType::Float64,
3500 vec![
3501 Some(1.25_f64),
3502 Some(2.25_f64),
3503 Some(3.25_f64),
3504 None,
3505 Some(5.25_f64),
3506 Some(1_123_456_789_012_345.6_f64),
3507 Some(1_123_456_789_012_345.6_f64),
3508 ]
3509 );
3510 }
3511
3512 #[test]
3513 fn test_cast_decimal256_to_numeric() {
3514 let value_array: Vec<Option<i256>> = vec![
3515 Some(i256::from_i128(125)),
3516 Some(i256::from_i128(225)),
3517 Some(i256::from_i128(325)),
3518 None,
3519 Some(i256::from_i128(525)),
3520 ];
3521 let array = create_decimal256_array(value_array, 38, 2).unwrap();
3522 generate_cast_test_case!(
3524 &array,
3525 UInt8Array,
3526 &DataType::UInt8,
3527 vec![Some(1_u8), Some(2_u8), Some(3_u8), None, Some(5_u8)]
3528 );
3529 generate_cast_test_case!(
3531 &array,
3532 UInt16Array,
3533 &DataType::UInt16,
3534 vec![Some(1_u16), Some(2_u16), Some(3_u16), None, Some(5_u16)]
3535 );
3536 generate_cast_test_case!(
3538 &array,
3539 UInt32Array,
3540 &DataType::UInt32,
3541 vec![Some(1_u32), Some(2_u32), Some(3_u32), None, Some(5_u32)]
3542 );
3543 generate_cast_test_case!(
3545 &array,
3546 UInt64Array,
3547 &DataType::UInt64,
3548 vec![Some(1_u64), Some(2_u64), Some(3_u64), None, Some(5_u64)]
3549 );
3550 generate_cast_test_case!(
3552 &array,
3553 Int8Array,
3554 &DataType::Int8,
3555 vec![Some(1_i8), Some(2_i8), Some(3_i8), None, Some(5_i8)]
3556 );
3557 generate_cast_test_case!(
3559 &array,
3560 Int16Array,
3561 &DataType::Int16,
3562 vec![Some(1_i16), Some(2_i16), Some(3_i16), None, Some(5_i16)]
3563 );
3564 generate_cast_test_case!(
3566 &array,
3567 Int32Array,
3568 &DataType::Int32,
3569 vec![Some(1_i32), Some(2_i32), Some(3_i32), None, Some(5_i32)]
3570 );
3571 generate_cast_test_case!(
3573 &array,
3574 Int64Array,
3575 &DataType::Int64,
3576 vec![Some(1_i64), Some(2_i64), Some(3_i64), None, Some(5_i64)]
3577 );
3578 generate_cast_test_case!(
3580 &array,
3581 Float32Array,
3582 &DataType::Float32,
3583 vec![
3584 Some(1.25_f32),
3585 Some(2.25_f32),
3586 Some(3.25_f32),
3587 None,
3588 Some(5.25_f32)
3589 ]
3590 );
3591 generate_cast_test_case!(
3593 &array,
3594 Float64Array,
3595 &DataType::Float64,
3596 vec![
3597 Some(1.25_f64),
3598 Some(2.25_f64),
3599 Some(3.25_f64),
3600 None,
3601 Some(5.25_f64)
3602 ]
3603 );
3604
3605 let value_array: Vec<Option<i256>> = vec![Some(i256::from_i128(24400))];
3607 let array = create_decimal256_array(value_array, 38, 2).unwrap();
3608 let casted_array = cast_with_options(
3609 &array,
3610 &DataType::Int8,
3611 &CastOptions {
3612 safe: false,
3613 format_options: FormatOptions::default(),
3614 },
3615 );
3616 assert_eq!(
3617 "Cast error: value of 244 is out of range Int8".to_string(),
3618 casted_array.unwrap_err().to_string()
3619 );
3620
3621 let casted_array = cast_with_options(
3622 &array,
3623 &DataType::Int8,
3624 &CastOptions {
3625 safe: true,
3626 format_options: FormatOptions::default(),
3627 },
3628 );
3629 assert!(casted_array.is_ok());
3630 assert!(casted_array.unwrap().is_null(0));
3631
3632 let value_array: Vec<Option<i256>> = vec![
3636 Some(i256::from_i128(125)),
3637 Some(i256::from_i128(225)),
3638 Some(i256::from_i128(325)),
3639 None,
3640 Some(i256::from_i128(525)),
3641 Some(i256::from_i128(112345678)),
3642 Some(i256::from_i128(112345679)),
3643 ];
3644 let array = create_decimal256_array(value_array, 76, 2).unwrap();
3645 generate_cast_test_case!(
3646 &array,
3647 Float32Array,
3648 &DataType::Float32,
3649 vec![
3650 Some(1.25_f32),
3651 Some(2.25_f32),
3652 Some(3.25_f32),
3653 None,
3654 Some(5.25_f32),
3655 Some(1_123_456.7_f32),
3656 Some(1_123_456.7_f32)
3657 ]
3658 );
3659
3660 let value_array: Vec<Option<i256>> = vec![
3663 Some(i256::from_i128(125)),
3664 Some(i256::from_i128(225)),
3665 Some(i256::from_i128(325)),
3666 None,
3667 Some(i256::from_i128(525)),
3668 Some(i256::from_i128(112345678901234568)),
3669 Some(i256::from_i128(112345678901234560)),
3670 ];
3671 let array = create_decimal256_array(value_array, 76, 2).unwrap();
3672 generate_cast_test_case!(
3673 &array,
3674 Float64Array,
3675 &DataType::Float64,
3676 vec![
3677 Some(1.25_f64),
3678 Some(2.25_f64),
3679 Some(3.25_f64),
3680 None,
3681 Some(5.25_f64),
3682 Some(1_123_456_789_012_345.6_f64),
3683 Some(1_123_456_789_012_345.6_f64),
3684 ]
3685 );
3686 }
3687
3688 #[test]
3689 fn test_cast_numeric_to_decimal128() {
3690 let decimal_type = DataType::Decimal128(38, 6);
3691 let input_datas = vec![
3693 Arc::new(UInt8Array::from(vec![
3694 Some(1),
3695 Some(2),
3696 Some(3),
3697 None,
3698 Some(5),
3699 ])) as ArrayRef, Arc::new(UInt16Array::from(vec![
3701 Some(1),
3702 Some(2),
3703 Some(3),
3704 None,
3705 Some(5),
3706 ])) as ArrayRef, Arc::new(UInt32Array::from(vec![
3708 Some(1),
3709 Some(2),
3710 Some(3),
3711 None,
3712 Some(5),
3713 ])) as ArrayRef, Arc::new(UInt64Array::from(vec![
3715 Some(1),
3716 Some(2),
3717 Some(3),
3718 None,
3719 Some(5),
3720 ])) as ArrayRef, ];
3722
3723 for array in input_datas {
3724 generate_cast_test_case!(
3725 &array,
3726 Decimal128Array,
3727 &decimal_type,
3728 vec![
3729 Some(1000000_i128),
3730 Some(2000000_i128),
3731 Some(3000000_i128),
3732 None,
3733 Some(5000000_i128)
3734 ]
3735 );
3736 }
3737
3738 let input_datas = vec![
3740 Arc::new(Int8Array::from(vec![
3741 Some(1),
3742 Some(2),
3743 Some(3),
3744 None,
3745 Some(5),
3746 ])) as ArrayRef, Arc::new(Int16Array::from(vec![
3748 Some(1),
3749 Some(2),
3750 Some(3),
3751 None,
3752 Some(5),
3753 ])) as ArrayRef, Arc::new(Int32Array::from(vec![
3755 Some(1),
3756 Some(2),
3757 Some(3),
3758 None,
3759 Some(5),
3760 ])) as ArrayRef, Arc::new(Int64Array::from(vec![
3762 Some(1),
3763 Some(2),
3764 Some(3),
3765 None,
3766 Some(5),
3767 ])) as ArrayRef, ];
3769 for array in input_datas {
3770 generate_cast_test_case!(
3771 &array,
3772 Decimal128Array,
3773 &decimal_type,
3774 vec![
3775 Some(1000000_i128),
3776 Some(2000000_i128),
3777 Some(3000000_i128),
3778 None,
3779 Some(5000000_i128)
3780 ]
3781 );
3782 }
3783
3784 let array = UInt8Array::from(vec![1, 2, 3, 4, 100]);
3787 let casted_array = cast(&array, &DataType::Decimal128(3, 1));
3788 assert!(casted_array.is_ok());
3789 let array = casted_array.unwrap();
3790 let array: &Decimal128Array = array.as_primitive();
3791 assert!(array.is_null(4));
3792
3793 let array = Int8Array::from(vec![1, 2, 3, 4, 100]);
3796 let casted_array = cast(&array, &DataType::Decimal128(3, 1));
3797 assert!(casted_array.is_ok());
3798 let array = casted_array.unwrap();
3799 let array: &Decimal128Array = array.as_primitive();
3800 assert!(array.is_null(4));
3801
3802 let array = Float32Array::from(vec![
3804 Some(1.1),
3805 Some(2.2),
3806 Some(4.4),
3807 None,
3808 Some(1.123_456_4), Some(1.123_456_7), ]);
3811 let array = Arc::new(array) as ArrayRef;
3812 generate_cast_test_case!(
3813 &array,
3814 Decimal128Array,
3815 &decimal_type,
3816 vec![
3817 Some(1100000_i128),
3818 Some(2200000_i128),
3819 Some(4400000_i128),
3820 None,
3821 Some(1123456_i128), Some(1123457_i128), ]
3824 );
3825
3826 let array = Float64Array::from(vec![
3828 Some(1.1),
3829 Some(2.2),
3830 Some(4.4),
3831 None,
3832 Some(1.123_456_489_123_4), Some(1.123_456_789_123_4), Some(1.123_456_489_012_345_6), Some(1.123_456_789_012_345_6), ]);
3837 generate_cast_test_case!(
3838 &array,
3839 Decimal128Array,
3840 &decimal_type,
3841 vec![
3842 Some(1100000_i128),
3843 Some(2200000_i128),
3844 Some(4400000_i128),
3845 None,
3846 Some(1123456_i128), Some(1123457_i128), Some(1123456_i128), Some(1123457_i128), ]
3851 );
3852 }
3853
3854 #[test]
3855 fn test_cast_numeric_to_decimal256() {
3856 let decimal_type = DataType::Decimal256(76, 6);
3857 let input_datas = vec![
3859 Arc::new(UInt8Array::from(vec![
3860 Some(1),
3861 Some(2),
3862 Some(3),
3863 None,
3864 Some(5),
3865 ])) as ArrayRef, Arc::new(UInt16Array::from(vec![
3867 Some(1),
3868 Some(2),
3869 Some(3),
3870 None,
3871 Some(5),
3872 ])) as ArrayRef, Arc::new(UInt32Array::from(vec![
3874 Some(1),
3875 Some(2),
3876 Some(3),
3877 None,
3878 Some(5),
3879 ])) as ArrayRef, Arc::new(UInt64Array::from(vec![
3881 Some(1),
3882 Some(2),
3883 Some(3),
3884 None,
3885 Some(5),
3886 ])) as ArrayRef, ];
3888
3889 for array in input_datas {
3890 generate_cast_test_case!(
3891 &array,
3892 Decimal256Array,
3893 &decimal_type,
3894 vec![
3895 Some(i256::from_i128(1000000_i128)),
3896 Some(i256::from_i128(2000000_i128)),
3897 Some(i256::from_i128(3000000_i128)),
3898 None,
3899 Some(i256::from_i128(5000000_i128))
3900 ]
3901 );
3902 }
3903
3904 let input_datas = vec![
3906 Arc::new(Int8Array::from(vec![
3907 Some(1),
3908 Some(2),
3909 Some(3),
3910 None,
3911 Some(5),
3912 ])) as ArrayRef, Arc::new(Int16Array::from(vec![
3914 Some(1),
3915 Some(2),
3916 Some(3),
3917 None,
3918 Some(5),
3919 ])) as ArrayRef, Arc::new(Int32Array::from(vec![
3921 Some(1),
3922 Some(2),
3923 Some(3),
3924 None,
3925 Some(5),
3926 ])) as ArrayRef, Arc::new(Int64Array::from(vec![
3928 Some(1),
3929 Some(2),
3930 Some(3),
3931 None,
3932 Some(5),
3933 ])) as ArrayRef, ];
3935 for array in input_datas {
3936 generate_cast_test_case!(
3937 &array,
3938 Decimal256Array,
3939 &decimal_type,
3940 vec![
3941 Some(i256::from_i128(1000000_i128)),
3942 Some(i256::from_i128(2000000_i128)),
3943 Some(i256::from_i128(3000000_i128)),
3944 None,
3945 Some(i256::from_i128(5000000_i128))
3946 ]
3947 );
3948 }
3949
3950 let array = Int8Array::from(vec![1, 2, 3, 4, 100]);
3953 let array = Arc::new(array) as ArrayRef;
3954 let casted_array = cast(&array, &DataType::Decimal256(3, 1));
3955 assert!(casted_array.is_ok());
3956 let array = casted_array.unwrap();
3957 let array: &Decimal256Array = array.as_primitive();
3958 assert!(array.is_null(4));
3959
3960 let array = Float32Array::from(vec![
3962 Some(1.1),
3963 Some(2.2),
3964 Some(4.4),
3965 None,
3966 Some(1.123_456_4), Some(1.123_456_7), ]);
3969 generate_cast_test_case!(
3970 &array,
3971 Decimal256Array,
3972 &decimal_type,
3973 vec![
3974 Some(i256::from_i128(1100000_i128)),
3975 Some(i256::from_i128(2200000_i128)),
3976 Some(i256::from_i128(4400000_i128)),
3977 None,
3978 Some(i256::from_i128(1123456_i128)), Some(i256::from_i128(1123457_i128)), ]
3981 );
3982
3983 let array = Float64Array::from(vec![
3985 Some(1.1),
3986 Some(2.2),
3987 Some(4.4),
3988 None,
3989 Some(1.123_456_489_123_4), Some(1.123_456_789_123_4), Some(1.123_456_489_012_345_6), Some(1.123_456_789_012_345_6), ]);
3994 generate_cast_test_case!(
3995 &array,
3996 Decimal256Array,
3997 &decimal_type,
3998 vec![
3999 Some(i256::from_i128(1100000_i128)),
4000 Some(i256::from_i128(2200000_i128)),
4001 Some(i256::from_i128(4400000_i128)),
4002 None,
4003 Some(i256::from_i128(1123456_i128)), Some(i256::from_i128(1123457_i128)), Some(i256::from_i128(1123456_i128)), Some(i256::from_i128(1123457_i128)), ]
4008 );
4009 }
4010
4011 #[test]
4012 fn test_cast_i32_to_f64() {
4013 let array = Int32Array::from(vec![5, 6, 7, 8, 9]);
4014 let b = cast(&array, &DataType::Float64).unwrap();
4015 let c = b.as_primitive::<Float64Type>();
4016 assert_eq!(5.0, c.value(0));
4017 assert_eq!(6.0, c.value(1));
4018 assert_eq!(7.0, c.value(2));
4019 assert_eq!(8.0, c.value(3));
4020 assert_eq!(9.0, c.value(4));
4021 }
4022
4023 #[test]
4024 fn test_cast_i32_to_u8() {
4025 let array = Int32Array::from(vec![-5, 6, -7, 8, 100000000]);
4026 let b = cast(&array, &DataType::UInt8).unwrap();
4027 let c = b.as_primitive::<UInt8Type>();
4028 assert!(!c.is_valid(0));
4029 assert_eq!(6, c.value(1));
4030 assert!(!c.is_valid(2));
4031 assert_eq!(8, c.value(3));
4032 assert!(!c.is_valid(4));
4034 }
4035
4036 #[test]
4037 #[should_panic(expected = "Can't cast value -5 to type UInt8")]
4038 fn test_cast_int32_to_u8_with_error() {
4039 let array = Int32Array::from(vec![-5, 6, -7, 8, 100000000]);
4040 let cast_option = CastOptions {
4042 safe: false,
4043 format_options: FormatOptions::default(),
4044 };
4045 let result = cast_with_options(&array, &DataType::UInt8, &cast_option);
4046 assert!(result.is_err());
4047 result.unwrap();
4048 }
4049
4050 #[test]
4051 fn test_cast_i32_to_u8_sliced() {
4052 let array = Int32Array::from(vec![-5, 6, -7, 8, 100000000]);
4053 assert_eq!(0, array.offset());
4054 let array = array.slice(2, 3);
4055 let b = cast(&array, &DataType::UInt8).unwrap();
4056 assert_eq!(3, b.len());
4057 let c = b.as_primitive::<UInt8Type>();
4058 assert!(!c.is_valid(0));
4059 assert_eq!(8, c.value(1));
4060 assert!(!c.is_valid(2));
4062 }
4063
4064 #[test]
4065 fn test_cast_i32_to_i32() {
4066 let array = Int32Array::from(vec![5, 6, 7, 8, 9]);
4067 let b = cast(&array, &DataType::Int32).unwrap();
4068 let c = b.as_primitive::<Int32Type>();
4069 assert_eq!(5, c.value(0));
4070 assert_eq!(6, c.value(1));
4071 assert_eq!(7, c.value(2));
4072 assert_eq!(8, c.value(3));
4073 assert_eq!(9, c.value(4));
4074 }
4075
4076 #[test]
4077 fn test_cast_i32_to_list_i32() {
4078 let array = Int32Array::from(vec![5, 6, 7, 8, 9]);
4079 let b = cast(
4080 &array,
4081 &DataType::List(Arc::new(Field::new_list_field(DataType::Int32, true))),
4082 )
4083 .unwrap();
4084 assert_eq!(5, b.len());
4085 let arr = b.as_list::<i32>();
4086 assert_eq!(&[0, 1, 2, 3, 4, 5], arr.value_offsets());
4087 assert_eq!(1, arr.value_length(0));
4088 assert_eq!(1, arr.value_length(1));
4089 assert_eq!(1, arr.value_length(2));
4090 assert_eq!(1, arr.value_length(3));
4091 assert_eq!(1, arr.value_length(4));
4092 let c = arr.values().as_primitive::<Int32Type>();
4093 assert_eq!(5, c.value(0));
4094 assert_eq!(6, c.value(1));
4095 assert_eq!(7, c.value(2));
4096 assert_eq!(8, c.value(3));
4097 assert_eq!(9, c.value(4));
4098 }
4099
4100 #[test]
4101 fn test_cast_i32_to_list_i32_nullable() {
4102 let array = Int32Array::from(vec![Some(5), None, Some(7), Some(8), Some(9)]);
4103 let b = cast(
4104 &array,
4105 &DataType::List(Arc::new(Field::new_list_field(DataType::Int32, true))),
4106 )
4107 .unwrap();
4108 assert_eq!(5, b.len());
4109 assert_eq!(0, b.null_count());
4110 let arr = b.as_list::<i32>();
4111 assert_eq!(&[0, 1, 2, 3, 4, 5], arr.value_offsets());
4112 assert_eq!(1, arr.value_length(0));
4113 assert_eq!(1, arr.value_length(1));
4114 assert_eq!(1, arr.value_length(2));
4115 assert_eq!(1, arr.value_length(3));
4116 assert_eq!(1, arr.value_length(4));
4117
4118 let c = arr.values().as_primitive::<Int32Type>();
4119 assert_eq!(1, c.null_count());
4120 assert_eq!(5, c.value(0));
4121 assert!(!c.is_valid(1));
4122 assert_eq!(7, c.value(2));
4123 assert_eq!(8, c.value(3));
4124 assert_eq!(9, c.value(4));
4125 }
4126
4127 #[test]
4128 fn test_cast_i32_to_list_f64_nullable_sliced() {
4129 let array = Int32Array::from(vec![Some(5), None, Some(7), Some(8), None, Some(10)]);
4130 let array = array.slice(2, 4);
4131 let b = cast(
4132 &array,
4133 &DataType::List(Arc::new(Field::new_list_field(DataType::Float64, true))),
4134 )
4135 .unwrap();
4136 assert_eq!(4, b.len());
4137 assert_eq!(0, b.null_count());
4138 let arr = b.as_list::<i32>();
4139 assert_eq!(&[0, 1, 2, 3, 4], arr.value_offsets());
4140 assert_eq!(1, arr.value_length(0));
4141 assert_eq!(1, arr.value_length(1));
4142 assert_eq!(1, arr.value_length(2));
4143 assert_eq!(1, arr.value_length(3));
4144 let c = arr.values().as_primitive::<Float64Type>();
4145 assert_eq!(1, c.null_count());
4146 assert_eq!(7.0, c.value(0));
4147 assert_eq!(8.0, c.value(1));
4148 assert!(!c.is_valid(2));
4149 assert_eq!(10.0, c.value(3));
4150 }
4151
4152 #[test]
4153 fn test_cast_int_to_utf8view() {
4154 let inputs = vec![
4155 Arc::new(Int8Array::from(vec![None, Some(8), Some(9), Some(10)])) as ArrayRef,
4156 Arc::new(Int16Array::from(vec![None, Some(8), Some(9), Some(10)])) as ArrayRef,
4157 Arc::new(Int32Array::from(vec![None, Some(8), Some(9), Some(10)])) as ArrayRef,
4158 Arc::new(Int64Array::from(vec![None, Some(8), Some(9), Some(10)])) as ArrayRef,
4159 Arc::new(UInt8Array::from(vec![None, Some(8), Some(9), Some(10)])) as ArrayRef,
4160 Arc::new(UInt16Array::from(vec![None, Some(8), Some(9), Some(10)])) as ArrayRef,
4161 Arc::new(UInt32Array::from(vec![None, Some(8), Some(9), Some(10)])) as ArrayRef,
4162 Arc::new(UInt64Array::from(vec![None, Some(8), Some(9), Some(10)])) as ArrayRef,
4163 ];
4164 let expected: ArrayRef = Arc::new(StringViewArray::from(vec![
4165 None,
4166 Some("8"),
4167 Some("9"),
4168 Some("10"),
4169 ]));
4170
4171 for array in inputs {
4172 assert!(can_cast_types(array.data_type(), &DataType::Utf8View));
4173 let arr = cast(&array, &DataType::Utf8View).unwrap();
4174 assert_eq!(expected.as_ref(), arr.as_ref());
4175 }
4176 }
4177
4178 #[test]
4179 fn test_cast_float_to_utf8view() {
4180 let inputs = vec![
4181 Arc::new(Float16Array::from(vec![
4182 Some(f16::from_f64(1.5)),
4183 Some(f16::from_f64(2.5)),
4184 None,
4185 ])) as ArrayRef,
4186 Arc::new(Float32Array::from(vec![Some(1.5), Some(2.5), None])) as ArrayRef,
4187 Arc::new(Float64Array::from(vec![Some(1.5), Some(2.5), None])) as ArrayRef,
4188 ];
4189
4190 let expected: ArrayRef =
4191 Arc::new(StringViewArray::from(vec![Some("1.5"), Some("2.5"), None]));
4192
4193 for array in inputs {
4194 assert!(can_cast_types(array.data_type(), &DataType::Utf8View));
4195 let arr = cast(&array, &DataType::Utf8View).unwrap();
4196 assert_eq!(expected.as_ref(), arr.as_ref());
4197 }
4198 }
4199
4200 #[test]
4201 fn test_cast_utf8_to_i32() {
4202 let array = StringArray::from(vec!["5", "6", "seven", "8", "9.1"]);
4203 let b = cast(&array, &DataType::Int32).unwrap();
4204 let c = b.as_primitive::<Int32Type>();
4205 assert_eq!(5, c.value(0));
4206 assert_eq!(6, c.value(1));
4207 assert!(!c.is_valid(2));
4208 assert_eq!(8, c.value(3));
4209 assert!(!c.is_valid(4));
4210 }
4211
4212 #[test]
4213 fn test_cast_utf8view_to_i32() {
4214 let array = StringViewArray::from(vec!["5", "6", "seven", "8", "9.1"]);
4215 let b = cast(&array, &DataType::Int32).unwrap();
4216 let c = b.as_primitive::<Int32Type>();
4217 assert_eq!(5, c.value(0));
4218 assert_eq!(6, c.value(1));
4219 assert!(!c.is_valid(2));
4220 assert_eq!(8, c.value(3));
4221 assert!(!c.is_valid(4));
4222 }
4223
4224 #[test]
4225 fn test_cast_utf8view_to_f32() {
4226 let array = StringViewArray::from(vec!["3", "4.56", "seven", "8.9"]);
4227 let b = cast(&array, &DataType::Float32).unwrap();
4228 let c = b.as_primitive::<Float32Type>();
4229 assert_eq!(3.0, c.value(0));
4230 assert_eq!(4.56, c.value(1));
4231 assert!(!c.is_valid(2));
4232 assert_eq!(8.9, c.value(3));
4233 }
4234
4235 #[test]
4236 fn test_cast_utf8view_to_decimal128() {
4237 let array = StringViewArray::from(vec![None, Some("4"), Some("5.6"), Some("7.89")]);
4238 let arr = Arc::new(array) as ArrayRef;
4239 generate_cast_test_case!(
4240 &arr,
4241 Decimal128Array,
4242 &DataType::Decimal128(4, 2),
4243 vec![None, Some(400_i128), Some(560_i128), Some(789_i128)]
4244 );
4245 }
4246
4247 #[test]
4248 fn test_cast_with_options_utf8_to_i32() {
4249 let array = StringArray::from(vec!["5", "6", "seven", "8", "9.1"]);
4250 let result = cast_with_options(
4251 &array,
4252 &DataType::Int32,
4253 &CastOptions {
4254 safe: false,
4255 format_options: FormatOptions::default(),
4256 },
4257 );
4258 match result {
4259 Ok(_) => panic!("expected error"),
4260 Err(e) => {
4261 assert!(
4262 e.to_string()
4263 .contains("Cast error: Cannot cast string 'seven' to value of Int32 type",),
4264 "Error: {e}"
4265 )
4266 }
4267 }
4268 }
4269
4270 #[test]
4271 fn test_cast_utf8_to_bool() {
4272 let strings = StringArray::from(vec!["true", "false", "invalid", " Y ", ""]);
4273 let casted = cast(&strings, &DataType::Boolean).unwrap();
4274 let expected = BooleanArray::from(vec![Some(true), Some(false), None, Some(true), None]);
4275 assert_eq!(*as_boolean_array(&casted), expected);
4276 }
4277
4278 #[test]
4279 fn test_cast_utf8view_to_bool() {
4280 let strings = StringViewArray::from(vec!["true", "false", "invalid", " Y ", ""]);
4281 let casted = cast(&strings, &DataType::Boolean).unwrap();
4282 let expected = BooleanArray::from(vec![Some(true), Some(false), None, Some(true), None]);
4283 assert_eq!(*as_boolean_array(&casted), expected);
4284 }
4285
4286 #[test]
4287 fn test_cast_with_options_utf8_to_bool() {
4288 let strings = StringArray::from(vec!["true", "false", "invalid", " Y ", ""]);
4289 let casted = cast_with_options(
4290 &strings,
4291 &DataType::Boolean,
4292 &CastOptions {
4293 safe: false,
4294 format_options: FormatOptions::default(),
4295 },
4296 );
4297 match casted {
4298 Ok(_) => panic!("expected error"),
4299 Err(e) => {
4300 assert!(e
4301 .to_string()
4302 .contains("Cast error: Cannot cast value 'invalid' to value of Boolean type"))
4303 }
4304 }
4305 }
4306
4307 #[test]
4308 fn test_cast_bool_to_i32() {
4309 let array = BooleanArray::from(vec![Some(true), Some(false), None]);
4310 let b = cast(&array, &DataType::Int32).unwrap();
4311 let c = b.as_primitive::<Int32Type>();
4312 assert_eq!(1, c.value(0));
4313 assert_eq!(0, c.value(1));
4314 assert!(!c.is_valid(2));
4315 }
4316
4317 #[test]
4318 fn test_cast_bool_to_utf8view() {
4319 let array = BooleanArray::from(vec![Some(true), Some(false), None]);
4320 let b = cast(&array, &DataType::Utf8View).unwrap();
4321 let c = b.as_any().downcast_ref::<StringViewArray>().unwrap();
4322 assert_eq!("true", c.value(0));
4323 assert_eq!("false", c.value(1));
4324 assert!(!c.is_valid(2));
4325 }
4326
4327 #[test]
4328 fn test_cast_bool_to_utf8() {
4329 let array = BooleanArray::from(vec![Some(true), Some(false), None]);
4330 let b = cast(&array, &DataType::Utf8).unwrap();
4331 let c = b.as_any().downcast_ref::<StringArray>().unwrap();
4332 assert_eq!("true", c.value(0));
4333 assert_eq!("false", c.value(1));
4334 assert!(!c.is_valid(2));
4335 }
4336
4337 #[test]
4338 fn test_cast_bool_to_large_utf8() {
4339 let array = BooleanArray::from(vec![Some(true), Some(false), None]);
4340 let b = cast(&array, &DataType::LargeUtf8).unwrap();
4341 let c = b.as_any().downcast_ref::<LargeStringArray>().unwrap();
4342 assert_eq!("true", c.value(0));
4343 assert_eq!("false", c.value(1));
4344 assert!(!c.is_valid(2));
4345 }
4346
4347 #[test]
4348 fn test_cast_bool_to_f64() {
4349 let array = BooleanArray::from(vec![Some(true), Some(false), None]);
4350 let b = cast(&array, &DataType::Float64).unwrap();
4351 let c = b.as_primitive::<Float64Type>();
4352 assert_eq!(1.0, c.value(0));
4353 assert_eq!(0.0, c.value(1));
4354 assert!(!c.is_valid(2));
4355 }
4356
4357 #[test]
4358 fn test_cast_integer_to_timestamp() {
4359 let array = Int64Array::from(vec![Some(2), Some(10), None]);
4360 let expected = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
4361
4362 let array = Int8Array::from(vec![Some(2), Some(10), None]);
4363 let actual = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
4364
4365 assert_eq!(&actual, &expected);
4366
4367 let array = Int16Array::from(vec![Some(2), Some(10), None]);
4368 let actual = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
4369
4370 assert_eq!(&actual, &expected);
4371
4372 let array = Int32Array::from(vec![Some(2), Some(10), None]);
4373 let actual = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
4374
4375 assert_eq!(&actual, &expected);
4376
4377 let array = UInt8Array::from(vec![Some(2), Some(10), None]);
4378 let actual = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
4379
4380 assert_eq!(&actual, &expected);
4381
4382 let array = UInt16Array::from(vec![Some(2), Some(10), None]);
4383 let actual = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
4384
4385 assert_eq!(&actual, &expected);
4386
4387 let array = UInt32Array::from(vec![Some(2), Some(10), None]);
4388 let actual = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
4389
4390 assert_eq!(&actual, &expected);
4391
4392 let array = UInt64Array::from(vec![Some(2), Some(10), None]);
4393 let actual = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
4394
4395 assert_eq!(&actual, &expected);
4396 }
4397
4398 #[test]
4399 fn test_cast_timestamp_to_integer() {
4400 let array = TimestampMillisecondArray::from(vec![Some(5), Some(1), None])
4401 .with_timezone("UTC".to_string());
4402 let expected = cast(&array, &DataType::Int64).unwrap();
4403
4404 let actual = cast(&cast(&array, &DataType::Int8).unwrap(), &DataType::Int64).unwrap();
4405 assert_eq!(&actual, &expected);
4406
4407 let actual = cast(&cast(&array, &DataType::Int16).unwrap(), &DataType::Int64).unwrap();
4408 assert_eq!(&actual, &expected);
4409
4410 let actual = cast(&cast(&array, &DataType::Int32).unwrap(), &DataType::Int64).unwrap();
4411 assert_eq!(&actual, &expected);
4412
4413 let actual = cast(&cast(&array, &DataType::UInt8).unwrap(), &DataType::Int64).unwrap();
4414 assert_eq!(&actual, &expected);
4415
4416 let actual = cast(&cast(&array, &DataType::UInt16).unwrap(), &DataType::Int64).unwrap();
4417 assert_eq!(&actual, &expected);
4418
4419 let actual = cast(&cast(&array, &DataType::UInt32).unwrap(), &DataType::Int64).unwrap();
4420 assert_eq!(&actual, &expected);
4421
4422 let actual = cast(&cast(&array, &DataType::UInt64).unwrap(), &DataType::Int64).unwrap();
4423 assert_eq!(&actual, &expected);
4424 }
4425
4426 #[test]
4427 fn test_cast_floating_to_timestamp() {
4428 let array = Int64Array::from(vec![Some(2), Some(10), None]);
4429 let expected = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
4430
4431 let array = Float16Array::from(vec![
4432 Some(f16::from_f32(2.0)),
4433 Some(f16::from_f32(10.6)),
4434 None,
4435 ]);
4436 let actual = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
4437
4438 assert_eq!(&actual, &expected);
4439
4440 let array = Float32Array::from(vec![Some(2.0), Some(10.6), None]);
4441 let actual = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
4442
4443 assert_eq!(&actual, &expected);
4444
4445 let array = Float64Array::from(vec![Some(2.1), Some(10.2), None]);
4446 let actual = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
4447
4448 assert_eq!(&actual, &expected);
4449 }
4450
4451 #[test]
4452 fn test_cast_timestamp_to_floating() {
4453 let array = TimestampMillisecondArray::from(vec![Some(5), Some(1), None])
4454 .with_timezone("UTC".to_string());
4455 let expected = cast(&array, &DataType::Int64).unwrap();
4456
4457 let actual = cast(&cast(&array, &DataType::Float16).unwrap(), &DataType::Int64).unwrap();
4458 assert_eq!(&actual, &expected);
4459
4460 let actual = cast(&cast(&array, &DataType::Float32).unwrap(), &DataType::Int64).unwrap();
4461 assert_eq!(&actual, &expected);
4462
4463 let actual = cast(&cast(&array, &DataType::Float64).unwrap(), &DataType::Int64).unwrap();
4464 assert_eq!(&actual, &expected);
4465 }
4466
4467 #[test]
4468 fn test_cast_decimal_to_timestamp() {
4469 let array = Int64Array::from(vec![Some(2), Some(10), None]);
4470 let expected = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
4471
4472 let array = Decimal128Array::from(vec![Some(200), Some(1000), None])
4473 .with_precision_and_scale(4, 2)
4474 .unwrap();
4475 let actual = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
4476
4477 assert_eq!(&actual, &expected);
4478
4479 let array = Decimal256Array::from(vec![
4480 Some(i256::from_i128(2000)),
4481 Some(i256::from_i128(10000)),
4482 None,
4483 ])
4484 .with_precision_and_scale(5, 3)
4485 .unwrap();
4486 let actual = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
4487
4488 assert_eq!(&actual, &expected);
4489 }
4490
4491 #[test]
4492 fn test_cast_timestamp_to_decimal() {
4493 let array = TimestampMillisecondArray::from(vec![Some(5), Some(1), None])
4494 .with_timezone("UTC".to_string());
4495 let expected = cast(&array, &DataType::Int64).unwrap();
4496
4497 let actual = cast(
4498 &cast(&array, &DataType::Decimal128(5, 2)).unwrap(),
4499 &DataType::Int64,
4500 )
4501 .unwrap();
4502 assert_eq!(&actual, &expected);
4503
4504 let actual = cast(
4505 &cast(&array, &DataType::Decimal256(10, 5)).unwrap(),
4506 &DataType::Int64,
4507 )
4508 .unwrap();
4509 assert_eq!(&actual, &expected);
4510 }
4511
4512 #[test]
4513 fn test_cast_list_i32_to_list_u16() {
4514 let value_data = Int32Array::from(vec![0, 0, 0, -1, -2, -1, 2, 100000000]).into_data();
4515
4516 let value_offsets = Buffer::from_slice_ref([0, 3, 6, 8]);
4517
4518 let list_data_type = DataType::List(Arc::new(Field::new_list_field(DataType::Int32, true)));
4521 let list_data = ArrayData::builder(list_data_type)
4522 .len(3)
4523 .add_buffer(value_offsets)
4524 .add_child_data(value_data)
4525 .build()
4526 .unwrap();
4527 let list_array = ListArray::from(list_data);
4528
4529 let cast_array = cast(
4530 &list_array,
4531 &DataType::List(Arc::new(Field::new_list_field(DataType::UInt16, true))),
4532 )
4533 .unwrap();
4534
4535 assert_eq!(0, cast_array.null_count());
4540
4541 let array = cast_array.as_list::<i32>();
4543 assert_eq!(list_array.value_offsets(), array.value_offsets());
4544
4545 assert_eq!(DataType::UInt16, array.value_type());
4546 assert_eq!(3, array.value_length(0));
4547 assert_eq!(3, array.value_length(1));
4548 assert_eq!(2, array.value_length(2));
4549
4550 let u16arr = array.values().as_primitive::<UInt16Type>();
4552 assert_eq!(4, u16arr.null_count());
4553
4554 let expected: UInt16Array =
4556 vec![Some(0), Some(0), Some(0), None, None, None, Some(2), None]
4557 .into_iter()
4558 .collect();
4559
4560 assert_eq!(u16arr, &expected);
4561 }
4562
4563 #[test]
4564 fn test_cast_list_i32_to_list_timestamp() {
4565 let value_data = Int32Array::from(vec![0, 0, 0, -1, -2, -1, 2, 8, 100000000]).into_data();
4567
4568 let value_offsets = Buffer::from_slice_ref([0, 3, 6, 9]);
4569
4570 let list_data_type = DataType::List(Arc::new(Field::new_list_field(DataType::Int32, true)));
4572 let list_data = ArrayData::builder(list_data_type)
4573 .len(3)
4574 .add_buffer(value_offsets)
4575 .add_child_data(value_data)
4576 .build()
4577 .unwrap();
4578 let list_array = Arc::new(ListArray::from(list_data)) as ArrayRef;
4579
4580 let actual = cast(
4581 &list_array,
4582 &DataType::List(Arc::new(Field::new_list_field(
4583 DataType::Timestamp(TimeUnit::Microsecond, None),
4584 true,
4585 ))),
4586 )
4587 .unwrap();
4588
4589 let expected = cast(
4590 &cast(
4591 &list_array,
4592 &DataType::List(Arc::new(Field::new_list_field(DataType::Int64, true))),
4593 )
4594 .unwrap(),
4595 &DataType::List(Arc::new(Field::new_list_field(
4596 DataType::Timestamp(TimeUnit::Microsecond, None),
4597 true,
4598 ))),
4599 )
4600 .unwrap();
4601
4602 assert_eq!(&actual, &expected);
4603 }
4604
4605 #[test]
4606 fn test_cast_date32_to_date64() {
4607 let a = Date32Array::from(vec![10000, 17890]);
4608 let array = Arc::new(a) as ArrayRef;
4609 let b = cast(&array, &DataType::Date64).unwrap();
4610 let c = b.as_primitive::<Date64Type>();
4611 assert_eq!(864000000000, c.value(0));
4612 assert_eq!(1545696000000, c.value(1));
4613 }
4614
4615 #[test]
4616 fn test_cast_date64_to_date32() {
4617 let a = Date64Array::from(vec![Some(864000000005), Some(1545696000001), None]);
4618 let array = Arc::new(a) as ArrayRef;
4619 let b = cast(&array, &DataType::Date32).unwrap();
4620 let c = b.as_primitive::<Date32Type>();
4621 assert_eq!(10000, c.value(0));
4622 assert_eq!(17890, c.value(1));
4623 assert!(c.is_null(2));
4624 }
4625
4626 #[test]
4627 fn test_cast_string_to_integral_overflow() {
4628 let str = Arc::new(StringArray::from(vec![
4629 Some("123"),
4630 Some("-123"),
4631 Some("86374"),
4632 None,
4633 ])) as ArrayRef;
4634
4635 let options = CastOptions {
4636 safe: true,
4637 format_options: FormatOptions::default(),
4638 };
4639 let res = cast_with_options(&str, &DataType::Int16, &options).expect("should cast to i16");
4640 let expected =
4641 Arc::new(Int16Array::from(vec![Some(123), Some(-123), None, None])) as ArrayRef;
4642 assert_eq!(&res, &expected);
4643 }
4644
4645 #[test]
4646 fn test_cast_string_to_timestamp() {
4647 let a0 = Arc::new(StringViewArray::from(vec![
4648 Some("2020-09-08T12:00:00.123456789+00:00"),
4649 Some("Not a valid date"),
4650 None,
4651 ])) as ArrayRef;
4652 let a1 = Arc::new(StringArray::from(vec![
4653 Some("2020-09-08T12:00:00.123456789+00:00"),
4654 Some("Not a valid date"),
4655 None,
4656 ])) as ArrayRef;
4657 let a2 = Arc::new(LargeStringArray::from(vec![
4658 Some("2020-09-08T12:00:00.123456789+00:00"),
4659 Some("Not a valid date"),
4660 None,
4661 ])) as ArrayRef;
4662 for array in &[a0, a1, a2] {
4663 for time_unit in &[
4664 TimeUnit::Second,
4665 TimeUnit::Millisecond,
4666 TimeUnit::Microsecond,
4667 TimeUnit::Nanosecond,
4668 ] {
4669 let to_type = DataType::Timestamp(*time_unit, None);
4670 let b = cast(array, &to_type).unwrap();
4671
4672 match time_unit {
4673 TimeUnit::Second => {
4674 let c = b.as_primitive::<TimestampSecondType>();
4675 assert_eq!(1599566400, c.value(0));
4676 assert!(c.is_null(1));
4677 assert!(c.is_null(2));
4678 }
4679 TimeUnit::Millisecond => {
4680 let c = b
4681 .as_any()
4682 .downcast_ref::<TimestampMillisecondArray>()
4683 .unwrap();
4684 assert_eq!(1599566400123, c.value(0));
4685 assert!(c.is_null(1));
4686 assert!(c.is_null(2));
4687 }
4688 TimeUnit::Microsecond => {
4689 let c = b
4690 .as_any()
4691 .downcast_ref::<TimestampMicrosecondArray>()
4692 .unwrap();
4693 assert_eq!(1599566400123456, c.value(0));
4694 assert!(c.is_null(1));
4695 assert!(c.is_null(2));
4696 }
4697 TimeUnit::Nanosecond => {
4698 let c = b
4699 .as_any()
4700 .downcast_ref::<TimestampNanosecondArray>()
4701 .unwrap();
4702 assert_eq!(1599566400123456789, c.value(0));
4703 assert!(c.is_null(1));
4704 assert!(c.is_null(2));
4705 }
4706 }
4707
4708 let options = CastOptions {
4709 safe: false,
4710 format_options: FormatOptions::default(),
4711 };
4712 let err = cast_with_options(array, &to_type, &options).unwrap_err();
4713 assert_eq!(
4714 err.to_string(),
4715 "Parser error: Error parsing timestamp from 'Not a valid date': error parsing date"
4716 );
4717 }
4718 }
4719 }
4720
4721 #[test]
4722 fn test_cast_string_to_timestamp_overflow() {
4723 let array = StringArray::from(vec!["9800-09-08T12:00:00.123456789"]);
4724 let result = cast(&array, &DataType::Timestamp(TimeUnit::Second, None)).unwrap();
4725 let result = result.as_primitive::<TimestampSecondType>();
4726 assert_eq!(result.values(), &[247112596800]);
4727 }
4728
4729 #[test]
4730 fn test_cast_string_to_date32() {
4731 let a0 = Arc::new(StringViewArray::from(vec![
4732 Some("2018-12-25"),
4733 Some("Not a valid date"),
4734 None,
4735 ])) as ArrayRef;
4736 let a1 = Arc::new(StringArray::from(vec![
4737 Some("2018-12-25"),
4738 Some("Not a valid date"),
4739 None,
4740 ])) as ArrayRef;
4741 let a2 = Arc::new(LargeStringArray::from(vec![
4742 Some("2018-12-25"),
4743 Some("Not a valid date"),
4744 None,
4745 ])) as ArrayRef;
4746 for array in &[a0, a1, a2] {
4747 let to_type = DataType::Date32;
4748 let b = cast(array, &to_type).unwrap();
4749 let c = b.as_primitive::<Date32Type>();
4750 assert_eq!(17890, c.value(0));
4751 assert!(c.is_null(1));
4752 assert!(c.is_null(2));
4753
4754 let options = CastOptions {
4755 safe: false,
4756 format_options: FormatOptions::default(),
4757 };
4758 let err = cast_with_options(array, &to_type, &options).unwrap_err();
4759 assert_eq!(
4760 err.to_string(),
4761 "Cast error: Cannot cast string 'Not a valid date' to value of Date32 type"
4762 );
4763 }
4764 }
4765
4766 #[test]
4767 fn test_cast_string_with_large_date_to_date32() {
4768 let array = Arc::new(StringArray::from(vec![
4769 Some("+10999-12-31"),
4770 Some("-0010-02-28"),
4771 Some("0010-02-28"),
4772 Some("0000-01-01"),
4773 Some("-0000-01-01"),
4774 Some("-0001-01-01"),
4775 ])) as ArrayRef;
4776 let to_type = DataType::Date32;
4777 let options = CastOptions {
4778 safe: false,
4779 format_options: FormatOptions::default(),
4780 };
4781 let b = cast_with_options(&array, &to_type, &options).unwrap();
4782 let c = b.as_primitive::<Date32Type>();
4783 assert_eq!(3298139, c.value(0)); assert_eq!(-723122, c.value(1)); assert_eq!(-715817, c.value(2)); assert_eq!(c.value(3), c.value(4)); assert_eq!(-719528, c.value(3)); assert_eq!(-719528, c.value(4)); assert_eq!(-719893, c.value(5)); }
4791
4792 #[test]
4793 fn test_cast_invalid_string_with_large_date_to_date32() {
4794 let array = Arc::new(StringArray::from(vec![Some("10999-12-31")])) as ArrayRef;
4796 let to_type = DataType::Date32;
4797 let options = CastOptions {
4798 safe: false,
4799 format_options: FormatOptions::default(),
4800 };
4801 let err = cast_with_options(&array, &to_type, &options).unwrap_err();
4802 assert_eq!(
4803 err.to_string(),
4804 "Cast error: Cannot cast string '10999-12-31' to value of Date32 type"
4805 );
4806 }
4807
4808 #[test]
4809 fn test_cast_string_format_yyyymmdd_to_date32() {
4810 let a0 = Arc::new(StringViewArray::from(vec![
4811 Some("2020-12-25"),
4812 Some("20201117"),
4813 ])) as ArrayRef;
4814 let a1 = Arc::new(StringArray::from(vec![
4815 Some("2020-12-25"),
4816 Some("20201117"),
4817 ])) as ArrayRef;
4818 let a2 = Arc::new(LargeStringArray::from(vec![
4819 Some("2020-12-25"),
4820 Some("20201117"),
4821 ])) as ArrayRef;
4822
4823 for array in &[a0, a1, a2] {
4824 let to_type = DataType::Date32;
4825 let options = CastOptions {
4826 safe: false,
4827 format_options: FormatOptions::default(),
4828 };
4829 let result = cast_with_options(&array, &to_type, &options).unwrap();
4830 let c = result.as_primitive::<Date32Type>();
4831 assert_eq!(
4832 chrono::NaiveDate::from_ymd_opt(2020, 12, 25),
4833 c.value_as_date(0)
4834 );
4835 assert_eq!(
4836 chrono::NaiveDate::from_ymd_opt(2020, 11, 17),
4837 c.value_as_date(1)
4838 );
4839 }
4840 }
4841
4842 #[test]
4843 fn test_cast_string_to_time32second() {
4844 let a0 = Arc::new(StringViewArray::from(vec![
4845 Some("08:08:35.091323414"),
4846 Some("08:08:60.091323414"), Some("08:08:61.091323414"), Some("Not a valid time"),
4849 None,
4850 ])) as ArrayRef;
4851 let a1 = Arc::new(StringArray::from(vec![
4852 Some("08:08:35.091323414"),
4853 Some("08:08:60.091323414"), Some("08:08:61.091323414"), Some("Not a valid time"),
4856 None,
4857 ])) as ArrayRef;
4858 let a2 = Arc::new(LargeStringArray::from(vec![
4859 Some("08:08:35.091323414"),
4860 Some("08:08:60.091323414"), Some("08:08:61.091323414"), Some("Not a valid time"),
4863 None,
4864 ])) as ArrayRef;
4865 for array in &[a0, a1, a2] {
4866 let to_type = DataType::Time32(TimeUnit::Second);
4867 let b = cast(array, &to_type).unwrap();
4868 let c = b.as_primitive::<Time32SecondType>();
4869 assert_eq!(29315, c.value(0));
4870 assert_eq!(29340, c.value(1));
4871 assert!(c.is_null(2));
4872 assert!(c.is_null(3));
4873 assert!(c.is_null(4));
4874
4875 let options = CastOptions {
4876 safe: false,
4877 format_options: FormatOptions::default(),
4878 };
4879 let err = cast_with_options(array, &to_type, &options).unwrap_err();
4880 assert_eq!(err.to_string(), "Cast error: Cannot cast string '08:08:61.091323414' to value of Time32(Second) type");
4881 }
4882 }
4883
4884 #[test]
4885 fn test_cast_string_to_time32millisecond() {
4886 let a0 = Arc::new(StringViewArray::from(vec![
4887 Some("08:08:35.091323414"),
4888 Some("08:08:60.091323414"), Some("08:08:61.091323414"), Some("Not a valid time"),
4891 None,
4892 ])) as ArrayRef;
4893 let a1 = Arc::new(StringArray::from(vec![
4894 Some("08:08:35.091323414"),
4895 Some("08:08:60.091323414"), Some("08:08:61.091323414"), Some("Not a valid time"),
4898 None,
4899 ])) as ArrayRef;
4900 let a2 = Arc::new(LargeStringArray::from(vec![
4901 Some("08:08:35.091323414"),
4902 Some("08:08:60.091323414"), Some("08:08:61.091323414"), Some("Not a valid time"),
4905 None,
4906 ])) as ArrayRef;
4907 for array in &[a0, a1, a2] {
4908 let to_type = DataType::Time32(TimeUnit::Millisecond);
4909 let b = cast(array, &to_type).unwrap();
4910 let c = b.as_primitive::<Time32MillisecondType>();
4911 assert_eq!(29315091, c.value(0));
4912 assert_eq!(29340091, c.value(1));
4913 assert!(c.is_null(2));
4914 assert!(c.is_null(3));
4915 assert!(c.is_null(4));
4916
4917 let options = CastOptions {
4918 safe: false,
4919 format_options: FormatOptions::default(),
4920 };
4921 let err = cast_with_options(array, &to_type, &options).unwrap_err();
4922 assert_eq!(err.to_string(), "Cast error: Cannot cast string '08:08:61.091323414' to value of Time32(Millisecond) type");
4923 }
4924 }
4925
4926 #[test]
4927 fn test_cast_string_to_time64microsecond() {
4928 let a0 = Arc::new(StringViewArray::from(vec![
4929 Some("08:08:35.091323414"),
4930 Some("Not a valid time"),
4931 None,
4932 ])) as ArrayRef;
4933 let a1 = Arc::new(StringArray::from(vec![
4934 Some("08:08:35.091323414"),
4935 Some("Not a valid time"),
4936 None,
4937 ])) as ArrayRef;
4938 let a2 = Arc::new(LargeStringArray::from(vec![
4939 Some("08:08:35.091323414"),
4940 Some("Not a valid time"),
4941 None,
4942 ])) as ArrayRef;
4943 for array in &[a0, a1, a2] {
4944 let to_type = DataType::Time64(TimeUnit::Microsecond);
4945 let b = cast(array, &to_type).unwrap();
4946 let c = b.as_primitive::<Time64MicrosecondType>();
4947 assert_eq!(29315091323, c.value(0));
4948 assert!(c.is_null(1));
4949 assert!(c.is_null(2));
4950
4951 let options = CastOptions {
4952 safe: false,
4953 format_options: FormatOptions::default(),
4954 };
4955 let err = cast_with_options(array, &to_type, &options).unwrap_err();
4956 assert_eq!(err.to_string(), "Cast error: Cannot cast string 'Not a valid time' to value of Time64(Microsecond) type");
4957 }
4958 }
4959
4960 #[test]
4961 fn test_cast_string_to_time64nanosecond() {
4962 let a0 = Arc::new(StringViewArray::from(vec![
4963 Some("08:08:35.091323414"),
4964 Some("Not a valid time"),
4965 None,
4966 ])) as ArrayRef;
4967 let a1 = Arc::new(StringArray::from(vec![
4968 Some("08:08:35.091323414"),
4969 Some("Not a valid time"),
4970 None,
4971 ])) as ArrayRef;
4972 let a2 = Arc::new(LargeStringArray::from(vec![
4973 Some("08:08:35.091323414"),
4974 Some("Not a valid time"),
4975 None,
4976 ])) as ArrayRef;
4977 for array in &[a0, a1, a2] {
4978 let to_type = DataType::Time64(TimeUnit::Nanosecond);
4979 let b = cast(array, &to_type).unwrap();
4980 let c = b.as_primitive::<Time64NanosecondType>();
4981 assert_eq!(29315091323414, c.value(0));
4982 assert!(c.is_null(1));
4983 assert!(c.is_null(2));
4984
4985 let options = CastOptions {
4986 safe: false,
4987 format_options: FormatOptions::default(),
4988 };
4989 let err = cast_with_options(array, &to_type, &options).unwrap_err();
4990 assert_eq!(err.to_string(), "Cast error: Cannot cast string 'Not a valid time' to value of Time64(Nanosecond) type");
4991 }
4992 }
4993
4994 #[test]
4995 fn test_cast_string_to_date64() {
4996 let a0 = Arc::new(StringViewArray::from(vec![
4997 Some("2020-09-08T12:00:00"),
4998 Some("Not a valid date"),
4999 None,
5000 ])) as ArrayRef;
5001 let a1 = Arc::new(StringArray::from(vec![
5002 Some("2020-09-08T12:00:00"),
5003 Some("Not a valid date"),
5004 None,
5005 ])) as ArrayRef;
5006 let a2 = Arc::new(LargeStringArray::from(vec![
5007 Some("2020-09-08T12:00:00"),
5008 Some("Not a valid date"),
5009 None,
5010 ])) as ArrayRef;
5011 for array in &[a0, a1, a2] {
5012 let to_type = DataType::Date64;
5013 let b = cast(array, &to_type).unwrap();
5014 let c = b.as_primitive::<Date64Type>();
5015 assert_eq!(1599566400000, c.value(0));
5016 assert!(c.is_null(1));
5017 assert!(c.is_null(2));
5018
5019 let options = CastOptions {
5020 safe: false,
5021 format_options: FormatOptions::default(),
5022 };
5023 let err = cast_with_options(array, &to_type, &options).unwrap_err();
5024 assert_eq!(
5025 err.to_string(),
5026 "Cast error: Cannot cast string 'Not a valid date' to value of Date64 type"
5027 );
5028 }
5029 }
5030
5031 macro_rules! test_safe_string_to_interval {
5032 ($data_vec:expr, $interval_unit:expr, $array_ty:ty, $expect_vec:expr) => {
5033 let source_string_array = Arc::new(StringArray::from($data_vec.clone())) as ArrayRef;
5034
5035 let options = CastOptions {
5036 safe: true,
5037 format_options: FormatOptions::default(),
5038 };
5039
5040 let target_interval_array = cast_with_options(
5041 &source_string_array.clone(),
5042 &DataType::Interval($interval_unit),
5043 &options,
5044 )
5045 .unwrap()
5046 .as_any()
5047 .downcast_ref::<$array_ty>()
5048 .unwrap()
5049 .clone() as $array_ty;
5050
5051 let target_string_array =
5052 cast_with_options(&target_interval_array, &DataType::Utf8, &options)
5053 .unwrap()
5054 .as_any()
5055 .downcast_ref::<StringArray>()
5056 .unwrap()
5057 .clone();
5058
5059 let expect_string_array = StringArray::from($expect_vec);
5060
5061 assert_eq!(target_string_array, expect_string_array);
5062
5063 let target_large_string_array =
5064 cast_with_options(&target_interval_array, &DataType::LargeUtf8, &options)
5065 .unwrap()
5066 .as_any()
5067 .downcast_ref::<LargeStringArray>()
5068 .unwrap()
5069 .clone();
5070
5071 let expect_large_string_array = LargeStringArray::from($expect_vec);
5072
5073 assert_eq!(target_large_string_array, expect_large_string_array);
5074 };
5075 }
5076
5077 #[test]
5078 fn test_cast_string_to_interval_year_month() {
5079 test_safe_string_to_interval!(
5080 vec![
5081 Some("1 year 1 month"),
5082 Some("1.5 years 13 month"),
5083 Some("30 days"),
5084 Some("31 days"),
5085 Some("2 months 31 days"),
5086 Some("2 months 31 days 1 second"),
5087 Some("foobar"),
5088 ],
5089 IntervalUnit::YearMonth,
5090 IntervalYearMonthArray,
5091 vec![
5092 Some("1 years 1 mons"),
5093 Some("2 years 7 mons"),
5094 None,
5095 None,
5096 None,
5097 None,
5098 None,
5099 ]
5100 );
5101 }
5102
5103 #[test]
5104 fn test_cast_string_to_interval_day_time() {
5105 test_safe_string_to_interval!(
5106 vec![
5107 Some("1 year 1 month"),
5108 Some("1.5 years 13 month"),
5109 Some("30 days"),
5110 Some("1 day 2 second 3.5 milliseconds"),
5111 Some("foobar"),
5112 ],
5113 IntervalUnit::DayTime,
5114 IntervalDayTimeArray,
5115 vec![
5116 Some("390 days"),
5117 Some("930 days"),
5118 Some("30 days"),
5119 None,
5120 None,
5121 ]
5122 );
5123 }
5124
5125 #[test]
5126 fn test_cast_string_to_interval_month_day_nano() {
5127 test_safe_string_to_interval!(
5128 vec![
5129 Some("1 year 1 month 1 day"),
5130 None,
5131 Some("1.5 years 13 month 35 days 1.4 milliseconds"),
5132 Some("3 days"),
5133 Some("8 seconds"),
5134 None,
5135 Some("1 day 29800 milliseconds"),
5136 Some("3 months 1 second"),
5137 Some("6 minutes 120 second"),
5138 Some("2 years 39 months 9 days 19 hours 1 minute 83 seconds 399222 milliseconds"),
5139 Some("foobar"),
5140 ],
5141 IntervalUnit::MonthDayNano,
5142 IntervalMonthDayNanoArray,
5143 vec![
5144 Some("13 mons 1 days"),
5145 None,
5146 Some("31 mons 35 days 0.001400000 secs"),
5147 Some("3 days"),
5148 Some("8.000000000 secs"),
5149 None,
5150 Some("1 days 29.800000000 secs"),
5151 Some("3 mons 1.000000000 secs"),
5152 Some("8 mins"),
5153 Some("63 mons 9 days 19 hours 9 mins 2.222000000 secs"),
5154 None,
5155 ]
5156 );
5157 }
5158
5159 macro_rules! test_unsafe_string_to_interval_err {
5160 ($data_vec:expr, $interval_unit:expr, $error_msg:expr) => {
5161 let string_array = Arc::new(StringArray::from($data_vec.clone())) as ArrayRef;
5162 let options = CastOptions {
5163 safe: false,
5164 format_options: FormatOptions::default(),
5165 };
5166 let arrow_err = cast_with_options(
5167 &string_array.clone(),
5168 &DataType::Interval($interval_unit),
5169 &options,
5170 )
5171 .unwrap_err();
5172 assert_eq!($error_msg, arrow_err.to_string());
5173 };
5174 }
5175
5176 #[test]
5177 fn test_cast_string_to_interval_err() {
5178 test_unsafe_string_to_interval_err!(
5179 vec![Some("foobar")],
5180 IntervalUnit::YearMonth,
5181 r#"Parser error: Invalid input syntax for type interval: "foobar""#
5182 );
5183 test_unsafe_string_to_interval_err!(
5184 vec![Some("foobar")],
5185 IntervalUnit::DayTime,
5186 r#"Parser error: Invalid input syntax for type interval: "foobar""#
5187 );
5188 test_unsafe_string_to_interval_err!(
5189 vec![Some("foobar")],
5190 IntervalUnit::MonthDayNano,
5191 r#"Parser error: Invalid input syntax for type interval: "foobar""#
5192 );
5193 test_unsafe_string_to_interval_err!(
5194 vec![Some("2 months 31 days 1 second")],
5195 IntervalUnit::YearMonth,
5196 r#"Cast error: Cannot cast 2 months 31 days 1 second to IntervalYearMonth. Only year and month fields are allowed."#
5197 );
5198 test_unsafe_string_to_interval_err!(
5199 vec![Some("1 day 1.5 milliseconds")],
5200 IntervalUnit::DayTime,
5201 r#"Cast error: Cannot cast 1 day 1.5 milliseconds to IntervalDayTime because the nanos part isn't multiple of milliseconds"#
5202 );
5203
5204 test_unsafe_string_to_interval_err!(
5206 vec![Some(format!(
5207 "{} century {} year {} month",
5208 i64::MAX - 2,
5209 i64::MAX - 2,
5210 i64::MAX - 2
5211 ))],
5212 IntervalUnit::DayTime,
5213 format!(
5214 "Arithmetic overflow: Overflow happened on: {} * 100",
5215 i64::MAX - 2
5216 )
5217 );
5218 test_unsafe_string_to_interval_err!(
5219 vec![Some(format!(
5220 "{} year {} month {} day",
5221 i64::MAX - 2,
5222 i64::MAX - 2,
5223 i64::MAX - 2
5224 ))],
5225 IntervalUnit::MonthDayNano,
5226 format!(
5227 "Arithmetic overflow: Overflow happened on: {} * 12",
5228 i64::MAX - 2
5229 )
5230 );
5231 }
5232
5233 #[test]
5234 fn test_cast_binary_to_fixed_size_binary() {
5235 let bytes_1 = "Hiiii".as_bytes();
5236 let bytes_2 = "Hello".as_bytes();
5237
5238 let binary_data = vec![Some(bytes_1), Some(bytes_2), None];
5239 let a1 = Arc::new(BinaryArray::from(binary_data.clone())) as ArrayRef;
5240 let a2 = Arc::new(LargeBinaryArray::from(binary_data)) as ArrayRef;
5241
5242 let array_ref = cast(&a1, &DataType::FixedSizeBinary(5)).unwrap();
5243 let down_cast = array_ref
5244 .as_any()
5245 .downcast_ref::<FixedSizeBinaryArray>()
5246 .unwrap();
5247 assert_eq!(bytes_1, down_cast.value(0));
5248 assert_eq!(bytes_2, down_cast.value(1));
5249 assert!(down_cast.is_null(2));
5250
5251 let array_ref = cast(&a2, &DataType::FixedSizeBinary(5)).unwrap();
5252 let down_cast = array_ref
5253 .as_any()
5254 .downcast_ref::<FixedSizeBinaryArray>()
5255 .unwrap();
5256 assert_eq!(bytes_1, down_cast.value(0));
5257 assert_eq!(bytes_2, down_cast.value(1));
5258 assert!(down_cast.is_null(2));
5259
5260 let bytes_1 = "Hi".as_bytes();
5262 let bytes_2 = "Hello".as_bytes();
5263
5264 let binary_data = vec![Some(bytes_1), Some(bytes_2), None];
5265 let a1 = Arc::new(BinaryArray::from(binary_data.clone())) as ArrayRef;
5266 let a2 = Arc::new(LargeBinaryArray::from(binary_data)) as ArrayRef;
5267
5268 let array_ref = cast_with_options(
5269 &a1,
5270 &DataType::FixedSizeBinary(5),
5271 &CastOptions {
5272 safe: false,
5273 format_options: FormatOptions::default(),
5274 },
5275 );
5276 assert!(array_ref.is_err());
5277
5278 let array_ref = cast_with_options(
5279 &a2,
5280 &DataType::FixedSizeBinary(5),
5281 &CastOptions {
5282 safe: false,
5283 format_options: FormatOptions::default(),
5284 },
5285 );
5286 assert!(array_ref.is_err());
5287 }
5288
5289 #[test]
5290 fn test_fixed_size_binary_to_binary() {
5291 let bytes_1 = "Hiiii".as_bytes();
5292 let bytes_2 = "Hello".as_bytes();
5293
5294 let binary_data = vec![Some(bytes_1), Some(bytes_2), None];
5295 let a1 = Arc::new(FixedSizeBinaryArray::from(binary_data.clone())) as ArrayRef;
5296
5297 let array_ref = cast(&a1, &DataType::Binary).unwrap();
5298 let down_cast = array_ref.as_binary::<i32>();
5299 assert_eq!(bytes_1, down_cast.value(0));
5300 assert_eq!(bytes_2, down_cast.value(1));
5301 assert!(down_cast.is_null(2));
5302
5303 let array_ref = cast(&a1, &DataType::LargeBinary).unwrap();
5304 let down_cast = array_ref.as_binary::<i64>();
5305 assert_eq!(bytes_1, down_cast.value(0));
5306 assert_eq!(bytes_2, down_cast.value(1));
5307 assert!(down_cast.is_null(2));
5308
5309 let array_ref = cast(&a1, &DataType::BinaryView).unwrap();
5310 let down_cast = array_ref.as_binary_view();
5311 assert_eq!(bytes_1, down_cast.value(0));
5312 assert_eq!(bytes_2, down_cast.value(1));
5313 assert!(down_cast.is_null(2));
5314 }
5315
5316 #[test]
5317 fn test_fixed_size_binary_to_dictionary() {
5318 let bytes_1 = "Hiiii".as_bytes();
5319 let bytes_2 = "Hello".as_bytes();
5320
5321 let binary_data = vec![Some(bytes_1), Some(bytes_2), Some(bytes_1), None];
5322 let a1 = Arc::new(FixedSizeBinaryArray::from(binary_data.clone())) as ArrayRef;
5323
5324 let cast_type = DataType::Dictionary(
5325 Box::new(DataType::Int8),
5326 Box::new(DataType::FixedSizeBinary(5)),
5327 );
5328 let cast_array = cast(&a1, &cast_type).unwrap();
5329 assert_eq!(cast_array.data_type(), &cast_type);
5330 assert_eq!(
5331 array_to_strings(&cast_array),
5332 vec!["4869696969", "48656c6c6f", "4869696969", "null"]
5333 );
5334 let dict_array = cast_array
5336 .as_any()
5337 .downcast_ref::<DictionaryArray<Int8Type>>()
5338 .unwrap();
5339 assert_eq!(dict_array.values().len(), 2);
5340 }
5341
5342 #[test]
5343 fn test_binary_to_dictionary() {
5344 let mut builder = GenericBinaryBuilder::<i32>::new();
5345 builder.append_value(b"hello");
5346 builder.append_value(b"hiiii");
5347 builder.append_value(b"hiiii"); builder.append_null();
5349 builder.append_value(b"rustt");
5350
5351 let a1 = builder.finish();
5352
5353 let cast_type = DataType::Dictionary(
5354 Box::new(DataType::Int8),
5355 Box::new(DataType::FixedSizeBinary(5)),
5356 );
5357 let cast_array = cast(&a1, &cast_type).unwrap();
5358 assert_eq!(cast_array.data_type(), &cast_type);
5359 assert_eq!(
5360 array_to_strings(&cast_array),
5361 vec![
5362 "68656c6c6f",
5363 "6869696969",
5364 "6869696969",
5365 "null",
5366 "7275737474"
5367 ]
5368 );
5369 let dict_array = cast_array
5371 .as_any()
5372 .downcast_ref::<DictionaryArray<Int8Type>>()
5373 .unwrap();
5374 assert_eq!(dict_array.values().len(), 3);
5375 }
5376
5377 #[test]
5378 fn test_numeric_to_binary() {
5379 let a = Int16Array::from(vec![Some(1), Some(511), None]);
5380
5381 let array_ref = cast(&a, &DataType::Binary).unwrap();
5382 let down_cast = array_ref.as_binary::<i32>();
5383 assert_eq!(&1_i16.to_le_bytes(), down_cast.value(0));
5384 assert_eq!(&511_i16.to_le_bytes(), down_cast.value(1));
5385 assert!(down_cast.is_null(2));
5386
5387 let a = Int64Array::from(vec![Some(-1), Some(123456789), None]);
5388
5389 let array_ref = cast(&a, &DataType::Binary).unwrap();
5390 let down_cast = array_ref.as_binary::<i32>();
5391 assert_eq!(&(-1_i64).to_le_bytes(), down_cast.value(0));
5392 assert_eq!(&123456789_i64.to_le_bytes(), down_cast.value(1));
5393 assert!(down_cast.is_null(2));
5394 }
5395
5396 #[test]
5397 fn test_numeric_to_large_binary() {
5398 let a = Int16Array::from(vec![Some(1), Some(511), None]);
5399
5400 let array_ref = cast(&a, &DataType::LargeBinary).unwrap();
5401 let down_cast = array_ref.as_binary::<i64>();
5402 assert_eq!(&1_i16.to_le_bytes(), down_cast.value(0));
5403 assert_eq!(&511_i16.to_le_bytes(), down_cast.value(1));
5404 assert!(down_cast.is_null(2));
5405
5406 let a = Int64Array::from(vec![Some(-1), Some(123456789), None]);
5407
5408 let array_ref = cast(&a, &DataType::LargeBinary).unwrap();
5409 let down_cast = array_ref.as_binary::<i64>();
5410 assert_eq!(&(-1_i64).to_le_bytes(), down_cast.value(0));
5411 assert_eq!(&123456789_i64.to_le_bytes(), down_cast.value(1));
5412 assert!(down_cast.is_null(2));
5413 }
5414
5415 #[test]
5416 fn test_cast_date32_to_int32() {
5417 let array = Date32Array::from(vec![10000, 17890]);
5418 let b = cast(&array, &DataType::Int32).unwrap();
5419 let c = b.as_primitive::<Int32Type>();
5420 assert_eq!(10000, c.value(0));
5421 assert_eq!(17890, c.value(1));
5422 }
5423
5424 #[test]
5425 fn test_cast_int32_to_date32() {
5426 let array = Int32Array::from(vec![10000, 17890]);
5427 let b = cast(&array, &DataType::Date32).unwrap();
5428 let c = b.as_primitive::<Date32Type>();
5429 assert_eq!(10000, c.value(0));
5430 assert_eq!(17890, c.value(1));
5431 }
5432
5433 #[test]
5434 fn test_cast_timestamp_to_date32() {
5435 let array =
5436 TimestampMillisecondArray::from(vec![Some(864000000005), Some(1545696000001), None])
5437 .with_timezone("+00:00".to_string());
5438 let b = cast(&array, &DataType::Date32).unwrap();
5439 let c = b.as_primitive::<Date32Type>();
5440 assert_eq!(10000, c.value(0));
5441 assert_eq!(17890, c.value(1));
5442 assert!(c.is_null(2));
5443 }
5444 #[test]
5445 fn test_cast_timestamp_to_date32_zone() {
5446 let strings = StringArray::from_iter([
5447 Some("1970-01-01T00:00:01"),
5448 Some("1970-01-01T23:59:59"),
5449 None,
5450 Some("2020-03-01T02:00:23+00:00"),
5451 ]);
5452 let dt = DataType::Timestamp(TimeUnit::Millisecond, Some("-07:00".into()));
5453 let timestamps = cast(&strings, &dt).unwrap();
5454 let dates = cast(timestamps.as_ref(), &DataType::Date32).unwrap();
5455
5456 let c = dates.as_primitive::<Date32Type>();
5457 let expected = NaiveDate::from_ymd_opt(1970, 1, 1).unwrap();
5458 assert_eq!(c.value_as_date(0).unwrap(), expected);
5459 assert_eq!(c.value_as_date(1).unwrap(), expected);
5460 assert!(c.is_null(2));
5461 let expected = NaiveDate::from_ymd_opt(2020, 2, 29).unwrap();
5462 assert_eq!(c.value_as_date(3).unwrap(), expected);
5463 }
5464 #[test]
5465 fn test_cast_timestamp_to_date64() {
5466 let array =
5467 TimestampMillisecondArray::from(vec![Some(864000000005), Some(1545696000001), None]);
5468 let b = cast(&array, &DataType::Date64).unwrap();
5469 let c = b.as_primitive::<Date64Type>();
5470 assert_eq!(864000000005, c.value(0));
5471 assert_eq!(1545696000001, c.value(1));
5472 assert!(c.is_null(2));
5473
5474 let array = TimestampSecondArray::from(vec![Some(864000000005), Some(1545696000001)]);
5475 let b = cast(&array, &DataType::Date64).unwrap();
5476 let c = b.as_primitive::<Date64Type>();
5477 assert_eq!(864000000005000, c.value(0));
5478 assert_eq!(1545696000001000, c.value(1));
5479
5480 let array = TimestampSecondArray::from(vec![Some(i64::MAX)]);
5482 let b = cast(&array, &DataType::Date64).unwrap();
5483 assert!(b.is_null(0));
5484 let array = TimestampSecondArray::from(vec![Some(i64::MAX)]);
5486 let options = CastOptions {
5487 safe: false,
5488 format_options: FormatOptions::default(),
5489 };
5490 let b = cast_with_options(&array, &DataType::Date64, &options);
5491 assert!(b.is_err());
5492 }
5493
5494 #[test]
5495 fn test_cast_timestamp_to_time64() {
5496 let array = TimestampSecondArray::from(vec![Some(86405), Some(1), None])
5498 .with_timezone("+01:00".to_string());
5499 let b = cast(&array, &DataType::Time64(TimeUnit::Microsecond)).unwrap();
5500 let c = b.as_primitive::<Time64MicrosecondType>();
5501 assert_eq!(3605000000, c.value(0));
5502 assert_eq!(3601000000, c.value(1));
5503 assert!(c.is_null(2));
5504 let b = cast(&array, &DataType::Time64(TimeUnit::Nanosecond)).unwrap();
5505 let c = b.as_primitive::<Time64NanosecondType>();
5506 assert_eq!(3605000000000, c.value(0));
5507 assert_eq!(3601000000000, c.value(1));
5508 assert!(c.is_null(2));
5509
5510 let a = TimestampMillisecondArray::from(vec![Some(86405000), Some(1000), None])
5512 .with_timezone("+01:00".to_string());
5513 let array = Arc::new(a) as ArrayRef;
5514 let b = cast(&array, &DataType::Time64(TimeUnit::Microsecond)).unwrap();
5515 let c = b.as_primitive::<Time64MicrosecondType>();
5516 assert_eq!(3605000000, c.value(0));
5517 assert_eq!(3601000000, c.value(1));
5518 assert!(c.is_null(2));
5519 let b = cast(&array, &DataType::Time64(TimeUnit::Nanosecond)).unwrap();
5520 let c = b.as_primitive::<Time64NanosecondType>();
5521 assert_eq!(3605000000000, c.value(0));
5522 assert_eq!(3601000000000, c.value(1));
5523 assert!(c.is_null(2));
5524
5525 let a = TimestampMicrosecondArray::from(vec![Some(86405000000), Some(1000000), None])
5527 .with_timezone("+01:00".to_string());
5528 let array = Arc::new(a) as ArrayRef;
5529 let b = cast(&array, &DataType::Time64(TimeUnit::Microsecond)).unwrap();
5530 let c = b.as_primitive::<Time64MicrosecondType>();
5531 assert_eq!(3605000000, c.value(0));
5532 assert_eq!(3601000000, c.value(1));
5533 assert!(c.is_null(2));
5534 let b = cast(&array, &DataType::Time64(TimeUnit::Nanosecond)).unwrap();
5535 let c = b.as_primitive::<Time64NanosecondType>();
5536 assert_eq!(3605000000000, c.value(0));
5537 assert_eq!(3601000000000, c.value(1));
5538 assert!(c.is_null(2));
5539
5540 let a = TimestampNanosecondArray::from(vec![Some(86405000000000), Some(1000000000), None])
5542 .with_timezone("+01:00".to_string());
5543 let array = Arc::new(a) as ArrayRef;
5544 let b = cast(&array, &DataType::Time64(TimeUnit::Microsecond)).unwrap();
5545 let c = b.as_primitive::<Time64MicrosecondType>();
5546 assert_eq!(3605000000, c.value(0));
5547 assert_eq!(3601000000, c.value(1));
5548 assert!(c.is_null(2));
5549 let b = cast(&array, &DataType::Time64(TimeUnit::Nanosecond)).unwrap();
5550 let c = b.as_primitive::<Time64NanosecondType>();
5551 assert_eq!(3605000000000, c.value(0));
5552 assert_eq!(3601000000000, c.value(1));
5553 assert!(c.is_null(2));
5554
5555 let a =
5557 TimestampSecondArray::from(vec![Some(i64::MAX)]).with_timezone("+01:00".to_string());
5558 let array = Arc::new(a) as ArrayRef;
5559 let b = cast(&array, &DataType::Time64(TimeUnit::Microsecond));
5560 assert!(b.is_err());
5561 let b = cast(&array, &DataType::Time64(TimeUnit::Nanosecond));
5562 assert!(b.is_err());
5563 let b = cast(&array, &DataType::Time64(TimeUnit::Millisecond));
5564 assert!(b.is_err());
5565 }
5566
5567 #[test]
5568 fn test_cast_timestamp_to_time32() {
5569 let a = TimestampSecondArray::from(vec![Some(86405), Some(1), None])
5571 .with_timezone("+01:00".to_string());
5572 let array = Arc::new(a) as ArrayRef;
5573 let b = cast(&array, &DataType::Time32(TimeUnit::Second)).unwrap();
5574 let c = b.as_primitive::<Time32SecondType>();
5575 assert_eq!(3605, c.value(0));
5576 assert_eq!(3601, c.value(1));
5577 assert!(c.is_null(2));
5578 let b = cast(&array, &DataType::Time32(TimeUnit::Millisecond)).unwrap();
5579 let c = b.as_primitive::<Time32MillisecondType>();
5580 assert_eq!(3605000, c.value(0));
5581 assert_eq!(3601000, c.value(1));
5582 assert!(c.is_null(2));
5583
5584 let a = TimestampMillisecondArray::from(vec![Some(86405000), Some(1000), None])
5586 .with_timezone("+01:00".to_string());
5587 let array = Arc::new(a) as ArrayRef;
5588 let b = cast(&array, &DataType::Time32(TimeUnit::Second)).unwrap();
5589 let c = b.as_primitive::<Time32SecondType>();
5590 assert_eq!(3605, c.value(0));
5591 assert_eq!(3601, c.value(1));
5592 assert!(c.is_null(2));
5593 let b = cast(&array, &DataType::Time32(TimeUnit::Millisecond)).unwrap();
5594 let c = b.as_primitive::<Time32MillisecondType>();
5595 assert_eq!(3605000, c.value(0));
5596 assert_eq!(3601000, c.value(1));
5597 assert!(c.is_null(2));
5598
5599 let a = TimestampMicrosecondArray::from(vec![Some(86405000000), Some(1000000), None])
5601 .with_timezone("+01:00".to_string());
5602 let array = Arc::new(a) as ArrayRef;
5603 let b = cast(&array, &DataType::Time32(TimeUnit::Second)).unwrap();
5604 let c = b.as_primitive::<Time32SecondType>();
5605 assert_eq!(3605, c.value(0));
5606 assert_eq!(3601, c.value(1));
5607 assert!(c.is_null(2));
5608 let b = cast(&array, &DataType::Time32(TimeUnit::Millisecond)).unwrap();
5609 let c = b.as_primitive::<Time32MillisecondType>();
5610 assert_eq!(3605000, c.value(0));
5611 assert_eq!(3601000, c.value(1));
5612 assert!(c.is_null(2));
5613
5614 let a = TimestampNanosecondArray::from(vec![Some(86405000000000), Some(1000000000), None])
5616 .with_timezone("+01:00".to_string());
5617 let array = Arc::new(a) as ArrayRef;
5618 let b = cast(&array, &DataType::Time32(TimeUnit::Second)).unwrap();
5619 let c = b.as_primitive::<Time32SecondType>();
5620 assert_eq!(3605, c.value(0));
5621 assert_eq!(3601, c.value(1));
5622 assert!(c.is_null(2));
5623 let b = cast(&array, &DataType::Time32(TimeUnit::Millisecond)).unwrap();
5624 let c = b.as_primitive::<Time32MillisecondType>();
5625 assert_eq!(3605000, c.value(0));
5626 assert_eq!(3601000, c.value(1));
5627 assert!(c.is_null(2));
5628
5629 let a =
5631 TimestampSecondArray::from(vec![Some(i64::MAX)]).with_timezone("+01:00".to_string());
5632 let array = Arc::new(a) as ArrayRef;
5633 let b = cast(&array, &DataType::Time32(TimeUnit::Second));
5634 assert!(b.is_err());
5635 let b = cast(&array, &DataType::Time32(TimeUnit::Millisecond));
5636 assert!(b.is_err());
5637 }
5638
5639 #[test]
5641 fn test_cast_timestamp_with_timezone_1() {
5642 let string_array: Arc<dyn Array> = Arc::new(StringArray::from(vec![
5643 Some("2000-01-01T00:00:00.123456789"),
5644 Some("2010-01-01T00:00:00.123456789"),
5645 None,
5646 ]));
5647 let to_type = DataType::Timestamp(TimeUnit::Nanosecond, None);
5648 let timestamp_array = cast(&string_array, &to_type).unwrap();
5649
5650 let to_type = DataType::Timestamp(TimeUnit::Microsecond, Some("+0700".into()));
5651 let timestamp_array = cast(×tamp_array, &to_type).unwrap();
5652
5653 let string_array = cast(×tamp_array, &DataType::Utf8).unwrap();
5654 let result = string_array.as_string::<i32>();
5655 assert_eq!("2000-01-01T00:00:00.123456+07:00", result.value(0));
5656 assert_eq!("2010-01-01T00:00:00.123456+07:00", result.value(1));
5657 assert!(result.is_null(2));
5658 }
5659
5660 #[test]
5662 fn test_cast_timestamp_with_timezone_2() {
5663 let string_array: Arc<dyn Array> = Arc::new(StringArray::from(vec![
5664 Some("2000-01-01T07:00:00.123456789"),
5665 Some("2010-01-01T07:00:00.123456789"),
5666 None,
5667 ]));
5668 let to_type = DataType::Timestamp(TimeUnit::Millisecond, Some("+0700".into()));
5669 let timestamp_array = cast(&string_array, &to_type).unwrap();
5670
5671 let string_array = cast(×tamp_array, &DataType::Utf8).unwrap();
5673 let result = string_array.as_string::<i32>();
5674 assert_eq!("2000-01-01T07:00:00.123+07:00", result.value(0));
5675 assert_eq!("2010-01-01T07:00:00.123+07:00", result.value(1));
5676 assert!(result.is_null(2));
5677
5678 let to_type = DataType::Timestamp(TimeUnit::Nanosecond, None);
5679 let timestamp_array = cast(×tamp_array, &to_type).unwrap();
5680
5681 let string_array = cast(×tamp_array, &DataType::Utf8).unwrap();
5682 let result = string_array.as_string::<i32>();
5683 assert_eq!("2000-01-01T00:00:00.123", result.value(0));
5684 assert_eq!("2010-01-01T00:00:00.123", result.value(1));
5685 assert!(result.is_null(2));
5686 }
5687
5688 #[test]
5690 fn test_cast_timestamp_with_timezone_3() {
5691 let string_array: Arc<dyn Array> = Arc::new(StringArray::from(vec![
5692 Some("2000-01-01T07:00:00.123456789"),
5693 Some("2010-01-01T07:00:00.123456789"),
5694 None,
5695 ]));
5696 let to_type = DataType::Timestamp(TimeUnit::Microsecond, Some("+0700".into()));
5697 let timestamp_array = cast(&string_array, &to_type).unwrap();
5698
5699 let string_array = cast(×tamp_array, &DataType::Utf8).unwrap();
5701 let result = string_array.as_string::<i32>();
5702 assert_eq!("2000-01-01T07:00:00.123456+07:00", result.value(0));
5703 assert_eq!("2010-01-01T07:00:00.123456+07:00", result.value(1));
5704 assert!(result.is_null(2));
5705
5706 let to_type = DataType::Timestamp(TimeUnit::Second, Some("-08:00".into()));
5707 let timestamp_array = cast(×tamp_array, &to_type).unwrap();
5708
5709 let string_array = cast(×tamp_array, &DataType::Utf8).unwrap();
5710 let result = string_array.as_string::<i32>();
5711 assert_eq!("1999-12-31T16:00:00-08:00", result.value(0));
5712 assert_eq!("2009-12-31T16:00:00-08:00", result.value(1));
5713 assert!(result.is_null(2));
5714 }
5715
5716 #[test]
5717 fn test_cast_date64_to_timestamp() {
5718 let array = Date64Array::from(vec![Some(864000000005), Some(1545696000001), None]);
5719 let b = cast(&array, &DataType::Timestamp(TimeUnit::Second, None)).unwrap();
5720 let c = b.as_primitive::<TimestampSecondType>();
5721 assert_eq!(864000000, c.value(0));
5722 assert_eq!(1545696000, c.value(1));
5723 assert!(c.is_null(2));
5724 }
5725
5726 #[test]
5727 fn test_cast_date64_to_timestamp_ms() {
5728 let array = Date64Array::from(vec![Some(864000000005), Some(1545696000001), None]);
5729 let b = cast(&array, &DataType::Timestamp(TimeUnit::Millisecond, None)).unwrap();
5730 let c = b
5731 .as_any()
5732 .downcast_ref::<TimestampMillisecondArray>()
5733 .unwrap();
5734 assert_eq!(864000000005, c.value(0));
5735 assert_eq!(1545696000001, c.value(1));
5736 assert!(c.is_null(2));
5737 }
5738
5739 #[test]
5740 fn test_cast_date64_to_timestamp_us() {
5741 let array = Date64Array::from(vec![Some(864000000005), Some(1545696000001), None]);
5742 let b = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
5743 let c = b
5744 .as_any()
5745 .downcast_ref::<TimestampMicrosecondArray>()
5746 .unwrap();
5747 assert_eq!(864000000005000, c.value(0));
5748 assert_eq!(1545696000001000, c.value(1));
5749 assert!(c.is_null(2));
5750 }
5751
5752 #[test]
5753 fn test_cast_date64_to_timestamp_ns() {
5754 let array = Date64Array::from(vec![Some(864000000005), Some(1545696000001), None]);
5755 let b = cast(&array, &DataType::Timestamp(TimeUnit::Nanosecond, None)).unwrap();
5756 let c = b
5757 .as_any()
5758 .downcast_ref::<TimestampNanosecondArray>()
5759 .unwrap();
5760 assert_eq!(864000000005000000, c.value(0));
5761 assert_eq!(1545696000001000000, c.value(1));
5762 assert!(c.is_null(2));
5763 }
5764
5765 #[test]
5766 fn test_cast_timestamp_to_i64() {
5767 let array =
5768 TimestampMillisecondArray::from(vec![Some(864000000005), Some(1545696000001), None])
5769 .with_timezone("UTC".to_string());
5770 let b = cast(&array, &DataType::Int64).unwrap();
5771 let c = b.as_primitive::<Int64Type>();
5772 assert_eq!(&DataType::Int64, c.data_type());
5773 assert_eq!(864000000005, c.value(0));
5774 assert_eq!(1545696000001, c.value(1));
5775 assert!(c.is_null(2));
5776 }
5777
5778 #[test]
5779 fn test_cast_date32_to_string() {
5780 let array = Date32Array::from(vec![10000, 17890]);
5781 let b = cast(&array, &DataType::Utf8).unwrap();
5782 let c = b.as_any().downcast_ref::<StringArray>().unwrap();
5783 assert_eq!(&DataType::Utf8, c.data_type());
5784 assert_eq!("1997-05-19", c.value(0));
5785 assert_eq!("2018-12-25", c.value(1));
5786 }
5787
5788 #[test]
5789 fn test_cast_date64_to_string() {
5790 let array = Date64Array::from(vec![10000 * 86400000, 17890 * 86400000]);
5791 let b = cast(&array, &DataType::Utf8).unwrap();
5792 let c = b.as_any().downcast_ref::<StringArray>().unwrap();
5793 assert_eq!(&DataType::Utf8, c.data_type());
5794 assert_eq!("1997-05-19T00:00:00", c.value(0));
5795 assert_eq!("2018-12-25T00:00:00", c.value(1));
5796 }
5797
5798 macro_rules! assert_cast_timestamp_to_string {
5799 ($array:expr, $datatype:expr, $output_array_type: ty, $expected:expr) => {{
5800 let out = cast(&$array, &$datatype).unwrap();
5801 let actual = out
5802 .as_any()
5803 .downcast_ref::<$output_array_type>()
5804 .unwrap()
5805 .into_iter()
5806 .collect::<Vec<_>>();
5807 assert_eq!(actual, $expected);
5808 }};
5809 ($array:expr, $datatype:expr, $output_array_type: ty, $options:expr, $expected:expr) => {{
5810 let out = cast_with_options(&$array, &$datatype, &$options).unwrap();
5811 let actual = out
5812 .as_any()
5813 .downcast_ref::<$output_array_type>()
5814 .unwrap()
5815 .into_iter()
5816 .collect::<Vec<_>>();
5817 assert_eq!(actual, $expected);
5818 }};
5819 }
5820
5821 #[test]
5822 fn test_cast_date32_to_timestamp_and_timestamp_with_timezone() {
5823 let tz = "+0545"; let a = Date32Array::from(vec![Some(18628), None, None]); let array = Arc::new(a) as ArrayRef;
5826
5827 let b = cast(
5828 &array,
5829 &DataType::Timestamp(TimeUnit::Second, Some(tz.into())),
5830 )
5831 .unwrap();
5832 let c = b.as_primitive::<TimestampSecondType>();
5833 let string_array = cast(&c, &DataType::Utf8).unwrap();
5834 let result = string_array.as_string::<i32>();
5835 assert_eq!("2021-01-01T00:00:00+05:45", result.value(0));
5836
5837 let b = cast(&array, &DataType::Timestamp(TimeUnit::Second, None)).unwrap();
5838 let c = b.as_primitive::<TimestampSecondType>();
5839 let string_array = cast(&c, &DataType::Utf8).unwrap();
5840 let result = string_array.as_string::<i32>();
5841 assert_eq!("2021-01-01T00:00:00", result.value(0));
5842 }
5843
5844 #[test]
5845 fn test_cast_date32_to_timestamp_with_timezone() {
5846 let tz = "+0545"; let a = Date32Array::from(vec![Some(18628), Some(18993), None]); let array = Arc::new(a) as ArrayRef;
5849 let b = cast(
5850 &array,
5851 &DataType::Timestamp(TimeUnit::Second, Some(tz.into())),
5852 )
5853 .unwrap();
5854 let c = b.as_primitive::<TimestampSecondType>();
5855 assert_eq!(1609438500, c.value(0));
5856 assert_eq!(1640974500, c.value(1));
5857 assert!(c.is_null(2));
5858
5859 let string_array = cast(&c, &DataType::Utf8).unwrap();
5860 let result = string_array.as_string::<i32>();
5861 assert_eq!("2021-01-01T00:00:00+05:45", result.value(0));
5862 assert_eq!("2022-01-01T00:00:00+05:45", result.value(1));
5863 }
5864
5865 #[test]
5866 fn test_cast_date32_to_timestamp_with_timezone_ms() {
5867 let tz = "+0545"; let a = Date32Array::from(vec![Some(18628), Some(18993), None]); let array = Arc::new(a) as ArrayRef;
5870 let b = cast(
5871 &array,
5872 &DataType::Timestamp(TimeUnit::Millisecond, Some(tz.into())),
5873 )
5874 .unwrap();
5875 let c = b.as_primitive::<TimestampMillisecondType>();
5876 assert_eq!(1609438500000, c.value(0));
5877 assert_eq!(1640974500000, c.value(1));
5878 assert!(c.is_null(2));
5879
5880 let string_array = cast(&c, &DataType::Utf8).unwrap();
5881 let result = string_array.as_string::<i32>();
5882 assert_eq!("2021-01-01T00:00:00+05:45", result.value(0));
5883 assert_eq!("2022-01-01T00:00:00+05:45", result.value(1));
5884 }
5885
5886 #[test]
5887 fn test_cast_date32_to_timestamp_with_timezone_us() {
5888 let tz = "+0545"; let a = Date32Array::from(vec![Some(18628), Some(18993), None]); let array = Arc::new(a) as ArrayRef;
5891 let b = cast(
5892 &array,
5893 &DataType::Timestamp(TimeUnit::Microsecond, Some(tz.into())),
5894 )
5895 .unwrap();
5896 let c = b.as_primitive::<TimestampMicrosecondType>();
5897 assert_eq!(1609438500000000, c.value(0));
5898 assert_eq!(1640974500000000, c.value(1));
5899 assert!(c.is_null(2));
5900
5901 let string_array = cast(&c, &DataType::Utf8).unwrap();
5902 let result = string_array.as_string::<i32>();
5903 assert_eq!("2021-01-01T00:00:00+05:45", result.value(0));
5904 assert_eq!("2022-01-01T00:00:00+05:45", result.value(1));
5905 }
5906
5907 #[test]
5908 fn test_cast_date32_to_timestamp_with_timezone_ns() {
5909 let tz = "+0545"; let a = Date32Array::from(vec![Some(18628), Some(18993), None]); let array = Arc::new(a) as ArrayRef;
5912 let b = cast(
5913 &array,
5914 &DataType::Timestamp(TimeUnit::Nanosecond, Some(tz.into())),
5915 )
5916 .unwrap();
5917 let c = b.as_primitive::<TimestampNanosecondType>();
5918 assert_eq!(1609438500000000000, c.value(0));
5919 assert_eq!(1640974500000000000, c.value(1));
5920 assert!(c.is_null(2));
5921
5922 let string_array = cast(&c, &DataType::Utf8).unwrap();
5923 let result = string_array.as_string::<i32>();
5924 assert_eq!("2021-01-01T00:00:00+05:45", result.value(0));
5925 assert_eq!("2022-01-01T00:00:00+05:45", result.value(1));
5926 }
5927
5928 #[test]
5929 fn test_cast_date64_to_timestamp_with_timezone() {
5930 let array = Date64Array::from(vec![Some(864000000005), Some(1545696000001), None]);
5931 let tz = "+0545"; let b = cast(
5933 &array,
5934 &DataType::Timestamp(TimeUnit::Second, Some(tz.into())),
5935 )
5936 .unwrap();
5937
5938 let c = b.as_primitive::<TimestampSecondType>();
5939 assert_eq!(863979300, c.value(0));
5940 assert_eq!(1545675300, c.value(1));
5941 assert!(c.is_null(2));
5942
5943 let string_array = cast(&c, &DataType::Utf8).unwrap();
5944 let result = string_array.as_string::<i32>();
5945 assert_eq!("1997-05-19T00:00:00+05:45", result.value(0));
5946 assert_eq!("2018-12-25T00:00:00+05:45", result.value(1));
5947 }
5948
5949 #[test]
5950 fn test_cast_date64_to_timestamp_with_timezone_ms() {
5951 let array = Date64Array::from(vec![Some(864000000005), Some(1545696000001), None]);
5952 let tz = "+0545"; let b = cast(
5954 &array,
5955 &DataType::Timestamp(TimeUnit::Millisecond, Some(tz.into())),
5956 )
5957 .unwrap();
5958
5959 let c = b.as_primitive::<TimestampMillisecondType>();
5960 assert_eq!(863979300005, c.value(0));
5961 assert_eq!(1545675300001, c.value(1));
5962 assert!(c.is_null(2));
5963
5964 let string_array = cast(&c, &DataType::Utf8).unwrap();
5965 let result = string_array.as_string::<i32>();
5966 assert_eq!("1997-05-19T00:00:00.005+05:45", result.value(0));
5967 assert_eq!("2018-12-25T00:00:00.001+05:45", result.value(1));
5968 }
5969
5970 #[test]
5971 fn test_cast_date64_to_timestamp_with_timezone_us() {
5972 let array = Date64Array::from(vec![Some(864000000005), Some(1545696000001), None]);
5973 let tz = "+0545"; let b = cast(
5975 &array,
5976 &DataType::Timestamp(TimeUnit::Microsecond, Some(tz.into())),
5977 )
5978 .unwrap();
5979
5980 let c = b.as_primitive::<TimestampMicrosecondType>();
5981 assert_eq!(863979300005000, c.value(0));
5982 assert_eq!(1545675300001000, c.value(1));
5983 assert!(c.is_null(2));
5984
5985 let string_array = cast(&c, &DataType::Utf8).unwrap();
5986 let result = string_array.as_string::<i32>();
5987 assert_eq!("1997-05-19T00:00:00.005+05:45", result.value(0));
5988 assert_eq!("2018-12-25T00:00:00.001+05:45", result.value(1));
5989 }
5990
5991 #[test]
5992 fn test_cast_date64_to_timestamp_with_timezone_ns() {
5993 let array = Date64Array::from(vec![Some(864000000005), Some(1545696000001), None]);
5994 let tz = "+0545"; let b = cast(
5996 &array,
5997 &DataType::Timestamp(TimeUnit::Nanosecond, Some(tz.into())),
5998 )
5999 .unwrap();
6000
6001 let c = b.as_primitive::<TimestampNanosecondType>();
6002 assert_eq!(863979300005000000, c.value(0));
6003 assert_eq!(1545675300001000000, c.value(1));
6004 assert!(c.is_null(2));
6005
6006 let string_array = cast(&c, &DataType::Utf8).unwrap();
6007 let result = string_array.as_string::<i32>();
6008 assert_eq!("1997-05-19T00:00:00.005+05:45", result.value(0));
6009 assert_eq!("2018-12-25T00:00:00.001+05:45", result.value(1));
6010 }
6011
6012 #[test]
6013 fn test_cast_timestamp_to_strings() {
6014 let array =
6016 TimestampMillisecondArray::from(vec![Some(864000003005), Some(1545696002001), None]);
6017 let expected = vec![
6018 Some("1997-05-19T00:00:03.005"),
6019 Some("2018-12-25T00:00:02.001"),
6020 None,
6021 ];
6022
6023 assert_cast_timestamp_to_string!(array, DataType::Utf8View, StringViewArray, expected);
6024 assert_cast_timestamp_to_string!(array, DataType::Utf8, StringArray, expected);
6025 assert_cast_timestamp_to_string!(array, DataType::LargeUtf8, LargeStringArray, expected);
6026 }
6027
6028 #[test]
6029 fn test_cast_timestamp_to_strings_opt() {
6030 let ts_format = "%Y-%m-%d %H:%M:%S%.6f";
6031 let tz = "+0545"; let cast_options = CastOptions {
6033 safe: true,
6034 format_options: FormatOptions::default()
6035 .with_timestamp_format(Some(ts_format))
6036 .with_timestamp_tz_format(Some(ts_format)),
6037 };
6038
6039 let array_without_tz =
6041 TimestampMillisecondArray::from(vec![Some(864000003005), Some(1545696002001), None]);
6042 let expected = vec![
6043 Some("1997-05-19 00:00:03.005000"),
6044 Some("2018-12-25 00:00:02.001000"),
6045 None,
6046 ];
6047 assert_cast_timestamp_to_string!(
6048 array_without_tz,
6049 DataType::Utf8View,
6050 StringViewArray,
6051 cast_options,
6052 expected
6053 );
6054 assert_cast_timestamp_to_string!(
6055 array_without_tz,
6056 DataType::Utf8,
6057 StringArray,
6058 cast_options,
6059 expected
6060 );
6061 assert_cast_timestamp_to_string!(
6062 array_without_tz,
6063 DataType::LargeUtf8,
6064 LargeStringArray,
6065 cast_options,
6066 expected
6067 );
6068
6069 let array_with_tz =
6070 TimestampMillisecondArray::from(vec![Some(864000003005), Some(1545696002001), None])
6071 .with_timezone(tz.to_string());
6072 let expected = vec![
6073 Some("1997-05-19 05:45:03.005000"),
6074 Some("2018-12-25 05:45:02.001000"),
6075 None,
6076 ];
6077 assert_cast_timestamp_to_string!(
6078 array_with_tz,
6079 DataType::Utf8View,
6080 StringViewArray,
6081 cast_options,
6082 expected
6083 );
6084 assert_cast_timestamp_to_string!(
6085 array_with_tz,
6086 DataType::Utf8,
6087 StringArray,
6088 cast_options,
6089 expected
6090 );
6091 assert_cast_timestamp_to_string!(
6092 array_with_tz,
6093 DataType::LargeUtf8,
6094 LargeStringArray,
6095 cast_options,
6096 expected
6097 );
6098 }
6099
6100 #[test]
6101 fn test_cast_between_timestamps() {
6102 let array =
6103 TimestampMillisecondArray::from(vec![Some(864000003005), Some(1545696002001), None]);
6104 let b = cast(&array, &DataType::Timestamp(TimeUnit::Second, None)).unwrap();
6105 let c = b.as_primitive::<TimestampSecondType>();
6106 assert_eq!(864000003, c.value(0));
6107 assert_eq!(1545696002, c.value(1));
6108 assert!(c.is_null(2));
6109 }
6110
6111 #[test]
6112 fn test_cast_duration_to_i64() {
6113 let base = vec![5, 6, 7, 8, 100000000];
6114
6115 let duration_arrays = vec![
6116 Arc::new(DurationNanosecondArray::from(base.clone())) as ArrayRef,
6117 Arc::new(DurationMicrosecondArray::from(base.clone())) as ArrayRef,
6118 Arc::new(DurationMillisecondArray::from(base.clone())) as ArrayRef,
6119 Arc::new(DurationSecondArray::from(base.clone())) as ArrayRef,
6120 ];
6121
6122 for arr in duration_arrays {
6123 assert!(can_cast_types(arr.data_type(), &DataType::Int64));
6124 let result = cast(&arr, &DataType::Int64).unwrap();
6125 let result = result.as_primitive::<Int64Type>();
6126 assert_eq!(base.as_slice(), result.values());
6127 }
6128 }
6129
6130 #[test]
6131 fn test_cast_between_durations_and_numerics() {
6132 fn test_cast_between_durations<FromType, ToType>()
6133 where
6134 FromType: ArrowPrimitiveType<Native = i64>,
6135 ToType: ArrowPrimitiveType<Native = i64>,
6136 PrimitiveArray<FromType>: From<Vec<Option<i64>>>,
6137 {
6138 let from_unit = match FromType::DATA_TYPE {
6139 DataType::Duration(unit) => unit,
6140 _ => panic!("Expected a duration type"),
6141 };
6142 let to_unit = match ToType::DATA_TYPE {
6143 DataType::Duration(unit) => unit,
6144 _ => panic!("Expected a duration type"),
6145 };
6146 let from_size = time_unit_multiple(&from_unit);
6147 let to_size = time_unit_multiple(&to_unit);
6148
6149 let (v1_before, v2_before) = (8640003005, 1696002001);
6150 let (v1_after, v2_after) = if from_size >= to_size {
6151 (
6152 v1_before / (from_size / to_size),
6153 v2_before / (from_size / to_size),
6154 )
6155 } else {
6156 (
6157 v1_before * (to_size / from_size),
6158 v2_before * (to_size / from_size),
6159 )
6160 };
6161
6162 let array =
6163 PrimitiveArray::<FromType>::from(vec![Some(v1_before), Some(v2_before), None]);
6164 let b = cast(&array, &ToType::DATA_TYPE).unwrap();
6165 let c = b.as_primitive::<ToType>();
6166 assert_eq!(v1_after, c.value(0));
6167 assert_eq!(v2_after, c.value(1));
6168 assert!(c.is_null(2));
6169 }
6170
6171 test_cast_between_durations::<DurationSecondType, DurationMillisecondType>();
6173 test_cast_between_durations::<DurationSecondType, DurationMicrosecondType>();
6174 test_cast_between_durations::<DurationSecondType, DurationNanosecondType>();
6175 test_cast_between_durations::<DurationMillisecondType, DurationSecondType>();
6176 test_cast_between_durations::<DurationMillisecondType, DurationMicrosecondType>();
6177 test_cast_between_durations::<DurationMillisecondType, DurationNanosecondType>();
6178 test_cast_between_durations::<DurationMicrosecondType, DurationSecondType>();
6179 test_cast_between_durations::<DurationMicrosecondType, DurationMillisecondType>();
6180 test_cast_between_durations::<DurationMicrosecondType, DurationNanosecondType>();
6181 test_cast_between_durations::<DurationNanosecondType, DurationSecondType>();
6182 test_cast_between_durations::<DurationNanosecondType, DurationMillisecondType>();
6183 test_cast_between_durations::<DurationNanosecondType, DurationMicrosecondType>();
6184
6185 let array = DurationSecondArray::from(vec![
6187 Some(i64::MAX),
6188 Some(8640203410378005),
6189 Some(10241096),
6190 None,
6191 ]);
6192 let b = cast(&array, &DataType::Duration(TimeUnit::Nanosecond)).unwrap();
6193 let c = b.as_primitive::<DurationNanosecondType>();
6194 assert!(c.is_null(0));
6195 assert!(c.is_null(1));
6196 assert_eq!(10241096000000000, c.value(2));
6197 assert!(c.is_null(3));
6198
6199 let array = DurationSecondArray::from(vec![
6201 Some(i64::MAX),
6202 Some(8640203410378005),
6203 Some(10241096),
6204 None,
6205 ]);
6206 let b = cast(&array, &DataType::Int64).unwrap();
6207 let c = b.as_primitive::<Int64Type>();
6208 assert_eq!(i64::MAX, c.value(0));
6209 assert_eq!(8640203410378005, c.value(1));
6210 assert_eq!(10241096, c.value(2));
6211 assert!(c.is_null(3));
6212
6213 let b = cast(&array, &DataType::Int32).unwrap();
6214 let c = b.as_primitive::<Int32Type>();
6215 assert_eq!(0, c.value(0));
6216 assert_eq!(0, c.value(1));
6217 assert_eq!(10241096, c.value(2));
6218 assert!(c.is_null(3));
6219
6220 let array = Int32Array::from(vec![Some(i32::MAX), Some(802034103), Some(10241096), None]);
6222 let b = cast(&array, &DataType::Duration(TimeUnit::Second)).unwrap();
6223 let c = b.as_any().downcast_ref::<DurationSecondArray>().unwrap();
6224 assert_eq!(i32::MAX as i64, c.value(0));
6225 assert_eq!(802034103, c.value(1));
6226 assert_eq!(10241096, c.value(2));
6227 assert!(c.is_null(3));
6228 }
6229
6230 #[test]
6231 fn test_cast_to_strings() {
6232 let a = Int32Array::from(vec![1, 2, 3]);
6233 let out = cast(&a, &DataType::Utf8).unwrap();
6234 let out = out
6235 .as_any()
6236 .downcast_ref::<StringArray>()
6237 .unwrap()
6238 .into_iter()
6239 .collect::<Vec<_>>();
6240 assert_eq!(out, vec![Some("1"), Some("2"), Some("3")]);
6241 let out = cast(&a, &DataType::LargeUtf8).unwrap();
6242 let out = out
6243 .as_any()
6244 .downcast_ref::<LargeStringArray>()
6245 .unwrap()
6246 .into_iter()
6247 .collect::<Vec<_>>();
6248 assert_eq!(out, vec![Some("1"), Some("2"), Some("3")]);
6249 }
6250
6251 #[test]
6252 fn test_str_to_str_casts() {
6253 for data in [
6254 vec![Some("foo"), Some("bar"), Some("ham")],
6255 vec![Some("foo"), None, Some("bar")],
6256 ] {
6257 let a = LargeStringArray::from(data.clone());
6258 let to = cast(&a, &DataType::Utf8).unwrap();
6259 let expect = a
6260 .as_any()
6261 .downcast_ref::<LargeStringArray>()
6262 .unwrap()
6263 .into_iter()
6264 .collect::<Vec<_>>();
6265 let out = to
6266 .as_any()
6267 .downcast_ref::<StringArray>()
6268 .unwrap()
6269 .into_iter()
6270 .collect::<Vec<_>>();
6271 assert_eq!(expect, out);
6272
6273 let a = StringArray::from(data);
6274 let to = cast(&a, &DataType::LargeUtf8).unwrap();
6275 let expect = a
6276 .as_any()
6277 .downcast_ref::<StringArray>()
6278 .unwrap()
6279 .into_iter()
6280 .collect::<Vec<_>>();
6281 let out = to
6282 .as_any()
6283 .downcast_ref::<LargeStringArray>()
6284 .unwrap()
6285 .into_iter()
6286 .collect::<Vec<_>>();
6287 assert_eq!(expect, out);
6288 }
6289 }
6290
6291 const VIEW_TEST_DATA: [Option<&str>; 5] = [
6292 Some("hello"),
6293 Some("repeated"),
6294 None,
6295 Some("large payload over 12 bytes"),
6296 Some("repeated"),
6297 ];
6298
6299 #[test]
6300 fn test_string_view_to_binary_view() {
6301 let string_view_array = StringViewArray::from_iter(VIEW_TEST_DATA);
6302
6303 assert!(can_cast_types(
6304 string_view_array.data_type(),
6305 &DataType::BinaryView
6306 ));
6307
6308 let binary_view_array = cast(&string_view_array, &DataType::BinaryView).unwrap();
6309 assert_eq!(binary_view_array.data_type(), &DataType::BinaryView);
6310
6311 let expect_binary_view_array = BinaryViewArray::from_iter(VIEW_TEST_DATA);
6312 assert_eq!(binary_view_array.as_ref(), &expect_binary_view_array);
6313 }
6314
6315 #[test]
6316 fn test_binary_view_to_string_view() {
6317 let binary_view_array = BinaryViewArray::from_iter(VIEW_TEST_DATA);
6318
6319 assert!(can_cast_types(
6320 binary_view_array.data_type(),
6321 &DataType::Utf8View
6322 ));
6323
6324 let string_view_array = cast(&binary_view_array, &DataType::Utf8View).unwrap();
6325 assert_eq!(string_view_array.data_type(), &DataType::Utf8View);
6326
6327 let expect_string_view_array = StringViewArray::from_iter(VIEW_TEST_DATA);
6328 assert_eq!(string_view_array.as_ref(), &expect_string_view_array);
6329 }
6330
6331 #[test]
6332 fn test_string_to_view() {
6333 _test_string_to_view::<i32>();
6334 _test_string_to_view::<i64>();
6335 }
6336
6337 fn _test_string_to_view<O>()
6338 where
6339 O: OffsetSizeTrait,
6340 {
6341 let string_array = GenericStringArray::<O>::from_iter(VIEW_TEST_DATA);
6342
6343 assert!(can_cast_types(
6344 string_array.data_type(),
6345 &DataType::Utf8View
6346 ));
6347
6348 assert!(can_cast_types(
6349 string_array.data_type(),
6350 &DataType::BinaryView
6351 ));
6352
6353 let string_view_array = cast(&string_array, &DataType::Utf8View).unwrap();
6354 assert_eq!(string_view_array.data_type(), &DataType::Utf8View);
6355
6356 let binary_view_array = cast(&string_array, &DataType::BinaryView).unwrap();
6357 assert_eq!(binary_view_array.data_type(), &DataType::BinaryView);
6358
6359 let expect_string_view_array = StringViewArray::from_iter(VIEW_TEST_DATA);
6360 assert_eq!(string_view_array.as_ref(), &expect_string_view_array);
6361
6362 let expect_binary_view_array = BinaryViewArray::from_iter(VIEW_TEST_DATA);
6363 assert_eq!(binary_view_array.as_ref(), &expect_binary_view_array);
6364 }
6365
6366 #[test]
6367 fn test_bianry_to_view() {
6368 _test_binary_to_view::<i32>();
6369 _test_binary_to_view::<i64>();
6370 }
6371
6372 fn _test_binary_to_view<O>()
6373 where
6374 O: OffsetSizeTrait,
6375 {
6376 let binary_array = GenericBinaryArray::<O>::from_iter(VIEW_TEST_DATA);
6377
6378 assert!(can_cast_types(
6379 binary_array.data_type(),
6380 &DataType::Utf8View
6381 ));
6382
6383 assert!(can_cast_types(
6384 binary_array.data_type(),
6385 &DataType::BinaryView
6386 ));
6387
6388 let string_view_array = cast(&binary_array, &DataType::Utf8View).unwrap();
6389 assert_eq!(string_view_array.data_type(), &DataType::Utf8View);
6390
6391 let binary_view_array = cast(&binary_array, &DataType::BinaryView).unwrap();
6392 assert_eq!(binary_view_array.data_type(), &DataType::BinaryView);
6393
6394 let expect_string_view_array = StringViewArray::from_iter(VIEW_TEST_DATA);
6395 assert_eq!(string_view_array.as_ref(), &expect_string_view_array);
6396
6397 let expect_binary_view_array = BinaryViewArray::from_iter(VIEW_TEST_DATA);
6398 assert_eq!(binary_view_array.as_ref(), &expect_binary_view_array);
6399 }
6400
6401 #[test]
6402 fn test_dict_to_view() {
6403 let values = StringArray::from_iter(VIEW_TEST_DATA);
6404 let keys = Int8Array::from_iter([Some(1), Some(0), None, Some(3), None, Some(1), Some(4)]);
6405 let string_dict_array =
6406 DictionaryArray::<Int8Type>::try_new(keys, Arc::new(values)).unwrap();
6407 let typed_dict = string_dict_array.downcast_dict::<StringArray>().unwrap();
6408
6409 let string_view_array = {
6410 let mut builder = StringViewBuilder::new().with_fixed_block_size(8); for v in typed_dict.into_iter() {
6412 builder.append_option(v);
6413 }
6414 builder.finish()
6415 };
6416 let expected_string_array_type = string_view_array.data_type();
6417 let casted_string_array = cast(&string_dict_array, expected_string_array_type).unwrap();
6418 assert_eq!(casted_string_array.data_type(), expected_string_array_type);
6419 assert_eq!(casted_string_array.as_ref(), &string_view_array);
6420
6421 let binary_buffer = cast(&typed_dict.values(), &DataType::Binary).unwrap();
6422 let binary_dict_array =
6423 DictionaryArray::<Int8Type>::new(typed_dict.keys().clone(), binary_buffer);
6424 let typed_binary_dict = binary_dict_array.downcast_dict::<BinaryArray>().unwrap();
6425
6426 let binary_view_array = {
6427 let mut builder = BinaryViewBuilder::new().with_fixed_block_size(8); for v in typed_binary_dict.into_iter() {
6429 builder.append_option(v);
6430 }
6431 builder.finish()
6432 };
6433 let expected_binary_array_type = binary_view_array.data_type();
6434 let casted_binary_array = cast(&binary_dict_array, expected_binary_array_type).unwrap();
6435 assert_eq!(casted_binary_array.data_type(), expected_binary_array_type);
6436 assert_eq!(casted_binary_array.as_ref(), &binary_view_array);
6437 }
6438
6439 #[test]
6440 fn test_view_to_dict() {
6441 let string_view_array = StringViewArray::from_iter(VIEW_TEST_DATA);
6442 let string_dict_array: DictionaryArray<Int8Type> = VIEW_TEST_DATA.into_iter().collect();
6443 let casted_type = string_dict_array.data_type();
6444 let casted_dict_array = cast(&string_view_array, casted_type).unwrap();
6445 assert_eq!(casted_dict_array.data_type(), casted_type);
6446 assert_eq!(casted_dict_array.as_ref(), &string_dict_array);
6447
6448 let binary_view_array = BinaryViewArray::from_iter(VIEW_TEST_DATA);
6449 let binary_dict_array = string_dict_array.downcast_dict::<StringArray>().unwrap();
6450 let binary_buffer = cast(&binary_dict_array.values(), &DataType::Binary).unwrap();
6451 let binary_dict_array =
6452 DictionaryArray::<Int8Type>::new(binary_dict_array.keys().clone(), binary_buffer);
6453 let casted_type = binary_dict_array.data_type();
6454 let casted_binary_array = cast(&binary_view_array, casted_type).unwrap();
6455 assert_eq!(casted_binary_array.data_type(), casted_type);
6456 assert_eq!(casted_binary_array.as_ref(), &binary_dict_array);
6457 }
6458
6459 #[test]
6460 fn test_view_to_string() {
6461 _test_view_to_string::<i32>();
6462 _test_view_to_string::<i64>();
6463 }
6464
6465 fn _test_view_to_string<O>()
6466 where
6467 O: OffsetSizeTrait,
6468 {
6469 let string_view_array = {
6470 let mut builder = StringViewBuilder::new().with_fixed_block_size(8); for s in VIEW_TEST_DATA.iter() {
6472 builder.append_option(*s);
6473 }
6474 builder.finish()
6475 };
6476
6477 let binary_view_array = BinaryViewArray::from_iter(VIEW_TEST_DATA);
6478
6479 let expected_string_array = GenericStringArray::<O>::from_iter(VIEW_TEST_DATA);
6480 let expected_type = expected_string_array.data_type();
6481
6482 assert!(can_cast_types(string_view_array.data_type(), expected_type));
6483 assert!(can_cast_types(binary_view_array.data_type(), expected_type));
6484
6485 let string_view_casted_array = cast(&string_view_array, expected_type).unwrap();
6486 assert_eq!(string_view_casted_array.data_type(), expected_type);
6487 assert_eq!(string_view_casted_array.as_ref(), &expected_string_array);
6488
6489 let binary_view_casted_array = cast(&binary_view_array, expected_type).unwrap();
6490 assert_eq!(binary_view_casted_array.data_type(), expected_type);
6491 assert_eq!(binary_view_casted_array.as_ref(), &expected_string_array);
6492 }
6493
6494 #[test]
6495 fn test_view_to_binary() {
6496 _test_view_to_binary::<i32>();
6497 _test_view_to_binary::<i64>();
6498 }
6499
6500 fn _test_view_to_binary<O>()
6501 where
6502 O: OffsetSizeTrait,
6503 {
6504 let view_array = {
6505 let mut builder = BinaryViewBuilder::new().with_fixed_block_size(8); for s in VIEW_TEST_DATA.iter() {
6507 builder.append_option(*s);
6508 }
6509 builder.finish()
6510 };
6511
6512 let expected_binary_array = GenericBinaryArray::<O>::from_iter(VIEW_TEST_DATA);
6513 let expected_type = expected_binary_array.data_type();
6514
6515 assert!(can_cast_types(view_array.data_type(), expected_type));
6516
6517 let binary_array = cast(&view_array, expected_type).unwrap();
6518 assert_eq!(binary_array.data_type(), expected_type);
6519
6520 assert_eq!(binary_array.as_ref(), &expected_binary_array);
6521 }
6522
6523 #[test]
6524 fn test_cast_from_f64() {
6525 let f64_values: Vec<f64> = vec![
6526 i64::MIN as f64,
6527 i32::MIN as f64,
6528 i16::MIN as f64,
6529 i8::MIN as f64,
6530 0_f64,
6531 u8::MAX as f64,
6532 u16::MAX as f64,
6533 u32::MAX as f64,
6534 u64::MAX as f64,
6535 ];
6536 let f64_array: ArrayRef = Arc::new(Float64Array::from(f64_values));
6537
6538 let f64_expected = vec![
6539 -9223372036854776000.0,
6540 -2147483648.0,
6541 -32768.0,
6542 -128.0,
6543 0.0,
6544 255.0,
6545 65535.0,
6546 4294967295.0,
6547 18446744073709552000.0,
6548 ];
6549 assert_eq!(
6550 f64_expected,
6551 get_cast_values::<Float64Type>(&f64_array, &DataType::Float64)
6552 .iter()
6553 .map(|i| i.parse::<f64>().unwrap())
6554 .collect::<Vec<f64>>()
6555 );
6556
6557 let f32_expected = vec![
6558 -9223372000000000000.0,
6559 -2147483600.0,
6560 -32768.0,
6561 -128.0,
6562 0.0,
6563 255.0,
6564 65535.0,
6565 4294967300.0,
6566 18446744000000000000.0,
6567 ];
6568 assert_eq!(
6569 f32_expected,
6570 get_cast_values::<Float32Type>(&f64_array, &DataType::Float32)
6571 .iter()
6572 .map(|i| i.parse::<f32>().unwrap())
6573 .collect::<Vec<f32>>()
6574 );
6575
6576 let f16_expected = vec![
6577 f16::from_f64(-9223372000000000000.0),
6578 f16::from_f64(-2147483600.0),
6579 f16::from_f64(-32768.0),
6580 f16::from_f64(-128.0),
6581 f16::from_f64(0.0),
6582 f16::from_f64(255.0),
6583 f16::from_f64(65535.0),
6584 f16::from_f64(4294967300.0),
6585 f16::from_f64(18446744000000000000.0),
6586 ];
6587 assert_eq!(
6588 f16_expected,
6589 get_cast_values::<Float16Type>(&f64_array, &DataType::Float16)
6590 .iter()
6591 .map(|i| i.parse::<f16>().unwrap())
6592 .collect::<Vec<f16>>()
6593 );
6594
6595 let i64_expected = vec![
6596 "-9223372036854775808",
6597 "-2147483648",
6598 "-32768",
6599 "-128",
6600 "0",
6601 "255",
6602 "65535",
6603 "4294967295",
6604 "null",
6605 ];
6606 assert_eq!(
6607 i64_expected,
6608 get_cast_values::<Int64Type>(&f64_array, &DataType::Int64)
6609 );
6610
6611 let i32_expected = vec![
6612 "null",
6613 "-2147483648",
6614 "-32768",
6615 "-128",
6616 "0",
6617 "255",
6618 "65535",
6619 "null",
6620 "null",
6621 ];
6622 assert_eq!(
6623 i32_expected,
6624 get_cast_values::<Int32Type>(&f64_array, &DataType::Int32)
6625 );
6626
6627 let i16_expected = vec![
6628 "null", "null", "-32768", "-128", "0", "255", "null", "null", "null",
6629 ];
6630 assert_eq!(
6631 i16_expected,
6632 get_cast_values::<Int16Type>(&f64_array, &DataType::Int16)
6633 );
6634
6635 let i8_expected = vec![
6636 "null", "null", "null", "-128", "0", "null", "null", "null", "null",
6637 ];
6638 assert_eq!(
6639 i8_expected,
6640 get_cast_values::<Int8Type>(&f64_array, &DataType::Int8)
6641 );
6642
6643 let u64_expected = vec![
6644 "null",
6645 "null",
6646 "null",
6647 "null",
6648 "0",
6649 "255",
6650 "65535",
6651 "4294967295",
6652 "null",
6653 ];
6654 assert_eq!(
6655 u64_expected,
6656 get_cast_values::<UInt64Type>(&f64_array, &DataType::UInt64)
6657 );
6658
6659 let u32_expected = vec![
6660 "null",
6661 "null",
6662 "null",
6663 "null",
6664 "0",
6665 "255",
6666 "65535",
6667 "4294967295",
6668 "null",
6669 ];
6670 assert_eq!(
6671 u32_expected,
6672 get_cast_values::<UInt32Type>(&f64_array, &DataType::UInt32)
6673 );
6674
6675 let u16_expected = vec![
6676 "null", "null", "null", "null", "0", "255", "65535", "null", "null",
6677 ];
6678 assert_eq!(
6679 u16_expected,
6680 get_cast_values::<UInt16Type>(&f64_array, &DataType::UInt16)
6681 );
6682
6683 let u8_expected = vec![
6684 "null", "null", "null", "null", "0", "255", "null", "null", "null",
6685 ];
6686 assert_eq!(
6687 u8_expected,
6688 get_cast_values::<UInt8Type>(&f64_array, &DataType::UInt8)
6689 );
6690 }
6691
6692 #[test]
6693 fn test_cast_from_f32() {
6694 let f32_values: Vec<f32> = vec![
6695 i32::MIN as f32,
6696 i32::MIN as f32,
6697 i16::MIN as f32,
6698 i8::MIN as f32,
6699 0_f32,
6700 u8::MAX as f32,
6701 u16::MAX as f32,
6702 u32::MAX as f32,
6703 u32::MAX as f32,
6704 ];
6705 let f32_array: ArrayRef = Arc::new(Float32Array::from(f32_values));
6706
6707 let f64_expected = vec![
6708 "-2147483648.0",
6709 "-2147483648.0",
6710 "-32768.0",
6711 "-128.0",
6712 "0.0",
6713 "255.0",
6714 "65535.0",
6715 "4294967296.0",
6716 "4294967296.0",
6717 ];
6718 assert_eq!(
6719 f64_expected,
6720 get_cast_values::<Float64Type>(&f32_array, &DataType::Float64)
6721 );
6722
6723 let f32_expected = vec![
6724 "-2147483600.0",
6725 "-2147483600.0",
6726 "-32768.0",
6727 "-128.0",
6728 "0.0",
6729 "255.0",
6730 "65535.0",
6731 "4294967300.0",
6732 "4294967300.0",
6733 ];
6734 assert_eq!(
6735 f32_expected,
6736 get_cast_values::<Float32Type>(&f32_array, &DataType::Float32)
6737 );
6738
6739 let f16_expected = vec![
6740 "-inf", "-inf", "-32768.0", "-128.0", "0.0", "255.0", "inf", "inf", "inf",
6741 ];
6742 assert_eq!(
6743 f16_expected,
6744 get_cast_values::<Float16Type>(&f32_array, &DataType::Float16)
6745 );
6746
6747 let i64_expected = vec![
6748 "-2147483648",
6749 "-2147483648",
6750 "-32768",
6751 "-128",
6752 "0",
6753 "255",
6754 "65535",
6755 "4294967296",
6756 "4294967296",
6757 ];
6758 assert_eq!(
6759 i64_expected,
6760 get_cast_values::<Int64Type>(&f32_array, &DataType::Int64)
6761 );
6762
6763 let i32_expected = vec![
6764 "-2147483648",
6765 "-2147483648",
6766 "-32768",
6767 "-128",
6768 "0",
6769 "255",
6770 "65535",
6771 "null",
6772 "null",
6773 ];
6774 assert_eq!(
6775 i32_expected,
6776 get_cast_values::<Int32Type>(&f32_array, &DataType::Int32)
6777 );
6778
6779 let i16_expected = vec![
6780 "null", "null", "-32768", "-128", "0", "255", "null", "null", "null",
6781 ];
6782 assert_eq!(
6783 i16_expected,
6784 get_cast_values::<Int16Type>(&f32_array, &DataType::Int16)
6785 );
6786
6787 let i8_expected = vec![
6788 "null", "null", "null", "-128", "0", "null", "null", "null", "null",
6789 ];
6790 assert_eq!(
6791 i8_expected,
6792 get_cast_values::<Int8Type>(&f32_array, &DataType::Int8)
6793 );
6794
6795 let u64_expected = vec![
6796 "null",
6797 "null",
6798 "null",
6799 "null",
6800 "0",
6801 "255",
6802 "65535",
6803 "4294967296",
6804 "4294967296",
6805 ];
6806 assert_eq!(
6807 u64_expected,
6808 get_cast_values::<UInt64Type>(&f32_array, &DataType::UInt64)
6809 );
6810
6811 let u32_expected = vec![
6812 "null", "null", "null", "null", "0", "255", "65535", "null", "null",
6813 ];
6814 assert_eq!(
6815 u32_expected,
6816 get_cast_values::<UInt32Type>(&f32_array, &DataType::UInt32)
6817 );
6818
6819 let u16_expected = vec![
6820 "null", "null", "null", "null", "0", "255", "65535", "null", "null",
6821 ];
6822 assert_eq!(
6823 u16_expected,
6824 get_cast_values::<UInt16Type>(&f32_array, &DataType::UInt16)
6825 );
6826
6827 let u8_expected = vec![
6828 "null", "null", "null", "null", "0", "255", "null", "null", "null",
6829 ];
6830 assert_eq!(
6831 u8_expected,
6832 get_cast_values::<UInt8Type>(&f32_array, &DataType::UInt8)
6833 );
6834 }
6835
6836 #[test]
6837 fn test_cast_from_uint64() {
6838 let u64_values: Vec<u64> = vec![
6839 0,
6840 u8::MAX as u64,
6841 u16::MAX as u64,
6842 u32::MAX as u64,
6843 u64::MAX,
6844 ];
6845 let u64_array: ArrayRef = Arc::new(UInt64Array::from(u64_values));
6846
6847 let f64_expected = vec![0.0, 255.0, 65535.0, 4294967295.0, 18446744073709552000.0];
6848 assert_eq!(
6849 f64_expected,
6850 get_cast_values::<Float64Type>(&u64_array, &DataType::Float64)
6851 .iter()
6852 .map(|i| i.parse::<f64>().unwrap())
6853 .collect::<Vec<f64>>()
6854 );
6855
6856 let f32_expected = vec![0.0, 255.0, 65535.0, 4294967300.0, 18446744000000000000.0];
6857 assert_eq!(
6858 f32_expected,
6859 get_cast_values::<Float32Type>(&u64_array, &DataType::Float32)
6860 .iter()
6861 .map(|i| i.parse::<f32>().unwrap())
6862 .collect::<Vec<f32>>()
6863 );
6864
6865 let f16_expected = vec![
6866 f16::from_f64(0.0),
6867 f16::from_f64(255.0),
6868 f16::from_f64(65535.0),
6869 f16::from_f64(4294967300.0),
6870 f16::from_f64(18446744000000000000.0),
6871 ];
6872 assert_eq!(
6873 f16_expected,
6874 get_cast_values::<Float16Type>(&u64_array, &DataType::Float16)
6875 .iter()
6876 .map(|i| i.parse::<f16>().unwrap())
6877 .collect::<Vec<f16>>()
6878 );
6879
6880 let i64_expected = vec!["0", "255", "65535", "4294967295", "null"];
6881 assert_eq!(
6882 i64_expected,
6883 get_cast_values::<Int64Type>(&u64_array, &DataType::Int64)
6884 );
6885
6886 let i32_expected = vec!["0", "255", "65535", "null", "null"];
6887 assert_eq!(
6888 i32_expected,
6889 get_cast_values::<Int32Type>(&u64_array, &DataType::Int32)
6890 );
6891
6892 let i16_expected = vec!["0", "255", "null", "null", "null"];
6893 assert_eq!(
6894 i16_expected,
6895 get_cast_values::<Int16Type>(&u64_array, &DataType::Int16)
6896 );
6897
6898 let i8_expected = vec!["0", "null", "null", "null", "null"];
6899 assert_eq!(
6900 i8_expected,
6901 get_cast_values::<Int8Type>(&u64_array, &DataType::Int8)
6902 );
6903
6904 let u64_expected = vec!["0", "255", "65535", "4294967295", "18446744073709551615"];
6905 assert_eq!(
6906 u64_expected,
6907 get_cast_values::<UInt64Type>(&u64_array, &DataType::UInt64)
6908 );
6909
6910 let u32_expected = vec!["0", "255", "65535", "4294967295", "null"];
6911 assert_eq!(
6912 u32_expected,
6913 get_cast_values::<UInt32Type>(&u64_array, &DataType::UInt32)
6914 );
6915
6916 let u16_expected = vec!["0", "255", "65535", "null", "null"];
6917 assert_eq!(
6918 u16_expected,
6919 get_cast_values::<UInt16Type>(&u64_array, &DataType::UInt16)
6920 );
6921
6922 let u8_expected = vec!["0", "255", "null", "null", "null"];
6923 assert_eq!(
6924 u8_expected,
6925 get_cast_values::<UInt8Type>(&u64_array, &DataType::UInt8)
6926 );
6927 }
6928
6929 #[test]
6930 fn test_cast_from_uint32() {
6931 let u32_values: Vec<u32> = vec![0, u8::MAX as u32, u16::MAX as u32, u32::MAX];
6932 let u32_array: ArrayRef = Arc::new(UInt32Array::from(u32_values));
6933
6934 let f64_expected = vec!["0.0", "255.0", "65535.0", "4294967295.0"];
6935 assert_eq!(
6936 f64_expected,
6937 get_cast_values::<Float64Type>(&u32_array, &DataType::Float64)
6938 );
6939
6940 let f32_expected = vec!["0.0", "255.0", "65535.0", "4294967300.0"];
6941 assert_eq!(
6942 f32_expected,
6943 get_cast_values::<Float32Type>(&u32_array, &DataType::Float32)
6944 );
6945
6946 let f16_expected = vec!["0.0", "255.0", "inf", "inf"];
6947 assert_eq!(
6948 f16_expected,
6949 get_cast_values::<Float16Type>(&u32_array, &DataType::Float16)
6950 );
6951
6952 let i64_expected = vec!["0", "255", "65535", "4294967295"];
6953 assert_eq!(
6954 i64_expected,
6955 get_cast_values::<Int64Type>(&u32_array, &DataType::Int64)
6956 );
6957
6958 let i32_expected = vec!["0", "255", "65535", "null"];
6959 assert_eq!(
6960 i32_expected,
6961 get_cast_values::<Int32Type>(&u32_array, &DataType::Int32)
6962 );
6963
6964 let i16_expected = vec!["0", "255", "null", "null"];
6965 assert_eq!(
6966 i16_expected,
6967 get_cast_values::<Int16Type>(&u32_array, &DataType::Int16)
6968 );
6969
6970 let i8_expected = vec!["0", "null", "null", "null"];
6971 assert_eq!(
6972 i8_expected,
6973 get_cast_values::<Int8Type>(&u32_array, &DataType::Int8)
6974 );
6975
6976 let u64_expected = vec!["0", "255", "65535", "4294967295"];
6977 assert_eq!(
6978 u64_expected,
6979 get_cast_values::<UInt64Type>(&u32_array, &DataType::UInt64)
6980 );
6981
6982 let u32_expected = vec!["0", "255", "65535", "4294967295"];
6983 assert_eq!(
6984 u32_expected,
6985 get_cast_values::<UInt32Type>(&u32_array, &DataType::UInt32)
6986 );
6987
6988 let u16_expected = vec!["0", "255", "65535", "null"];
6989 assert_eq!(
6990 u16_expected,
6991 get_cast_values::<UInt16Type>(&u32_array, &DataType::UInt16)
6992 );
6993
6994 let u8_expected = vec!["0", "255", "null", "null"];
6995 assert_eq!(
6996 u8_expected,
6997 get_cast_values::<UInt8Type>(&u32_array, &DataType::UInt8)
6998 );
6999 }
7000
7001 #[test]
7002 fn test_cast_from_uint16() {
7003 let u16_values: Vec<u16> = vec![0, u8::MAX as u16, u16::MAX];
7004 let u16_array: ArrayRef = Arc::new(UInt16Array::from(u16_values));
7005
7006 let f64_expected = vec!["0.0", "255.0", "65535.0"];
7007 assert_eq!(
7008 f64_expected,
7009 get_cast_values::<Float64Type>(&u16_array, &DataType::Float64)
7010 );
7011
7012 let f32_expected = vec!["0.0", "255.0", "65535.0"];
7013 assert_eq!(
7014 f32_expected,
7015 get_cast_values::<Float32Type>(&u16_array, &DataType::Float32)
7016 );
7017
7018 let f16_expected = vec!["0.0", "255.0", "inf"];
7019 assert_eq!(
7020 f16_expected,
7021 get_cast_values::<Float16Type>(&u16_array, &DataType::Float16)
7022 );
7023
7024 let i64_expected = vec!["0", "255", "65535"];
7025 assert_eq!(
7026 i64_expected,
7027 get_cast_values::<Int64Type>(&u16_array, &DataType::Int64)
7028 );
7029
7030 let i32_expected = vec!["0", "255", "65535"];
7031 assert_eq!(
7032 i32_expected,
7033 get_cast_values::<Int32Type>(&u16_array, &DataType::Int32)
7034 );
7035
7036 let i16_expected = vec!["0", "255", "null"];
7037 assert_eq!(
7038 i16_expected,
7039 get_cast_values::<Int16Type>(&u16_array, &DataType::Int16)
7040 );
7041
7042 let i8_expected = vec!["0", "null", "null"];
7043 assert_eq!(
7044 i8_expected,
7045 get_cast_values::<Int8Type>(&u16_array, &DataType::Int8)
7046 );
7047
7048 let u64_expected = vec!["0", "255", "65535"];
7049 assert_eq!(
7050 u64_expected,
7051 get_cast_values::<UInt64Type>(&u16_array, &DataType::UInt64)
7052 );
7053
7054 let u32_expected = vec!["0", "255", "65535"];
7055 assert_eq!(
7056 u32_expected,
7057 get_cast_values::<UInt32Type>(&u16_array, &DataType::UInt32)
7058 );
7059
7060 let u16_expected = vec!["0", "255", "65535"];
7061 assert_eq!(
7062 u16_expected,
7063 get_cast_values::<UInt16Type>(&u16_array, &DataType::UInt16)
7064 );
7065
7066 let u8_expected = vec!["0", "255", "null"];
7067 assert_eq!(
7068 u8_expected,
7069 get_cast_values::<UInt8Type>(&u16_array, &DataType::UInt8)
7070 );
7071 }
7072
7073 #[test]
7074 fn test_cast_from_uint8() {
7075 let u8_values: Vec<u8> = vec![0, u8::MAX];
7076 let u8_array: ArrayRef = Arc::new(UInt8Array::from(u8_values));
7077
7078 let f64_expected = vec!["0.0", "255.0"];
7079 assert_eq!(
7080 f64_expected,
7081 get_cast_values::<Float64Type>(&u8_array, &DataType::Float64)
7082 );
7083
7084 let f32_expected = vec!["0.0", "255.0"];
7085 assert_eq!(
7086 f32_expected,
7087 get_cast_values::<Float32Type>(&u8_array, &DataType::Float32)
7088 );
7089
7090 let f16_expected = vec!["0.0", "255.0"];
7091 assert_eq!(
7092 f16_expected,
7093 get_cast_values::<Float16Type>(&u8_array, &DataType::Float16)
7094 );
7095
7096 let i64_expected = vec!["0", "255"];
7097 assert_eq!(
7098 i64_expected,
7099 get_cast_values::<Int64Type>(&u8_array, &DataType::Int64)
7100 );
7101
7102 let i32_expected = vec!["0", "255"];
7103 assert_eq!(
7104 i32_expected,
7105 get_cast_values::<Int32Type>(&u8_array, &DataType::Int32)
7106 );
7107
7108 let i16_expected = vec!["0", "255"];
7109 assert_eq!(
7110 i16_expected,
7111 get_cast_values::<Int16Type>(&u8_array, &DataType::Int16)
7112 );
7113
7114 let i8_expected = vec!["0", "null"];
7115 assert_eq!(
7116 i8_expected,
7117 get_cast_values::<Int8Type>(&u8_array, &DataType::Int8)
7118 );
7119
7120 let u64_expected = vec!["0", "255"];
7121 assert_eq!(
7122 u64_expected,
7123 get_cast_values::<UInt64Type>(&u8_array, &DataType::UInt64)
7124 );
7125
7126 let u32_expected = vec!["0", "255"];
7127 assert_eq!(
7128 u32_expected,
7129 get_cast_values::<UInt32Type>(&u8_array, &DataType::UInt32)
7130 );
7131
7132 let u16_expected = vec!["0", "255"];
7133 assert_eq!(
7134 u16_expected,
7135 get_cast_values::<UInt16Type>(&u8_array, &DataType::UInt16)
7136 );
7137
7138 let u8_expected = vec!["0", "255"];
7139 assert_eq!(
7140 u8_expected,
7141 get_cast_values::<UInt8Type>(&u8_array, &DataType::UInt8)
7142 );
7143 }
7144
7145 #[test]
7146 fn test_cast_from_int64() {
7147 let i64_values: Vec<i64> = vec![
7148 i64::MIN,
7149 i32::MIN as i64,
7150 i16::MIN as i64,
7151 i8::MIN as i64,
7152 0,
7153 i8::MAX as i64,
7154 i16::MAX as i64,
7155 i32::MAX as i64,
7156 i64::MAX,
7157 ];
7158 let i64_array: ArrayRef = Arc::new(Int64Array::from(i64_values));
7159
7160 let f64_expected = vec![
7161 -9223372036854776000.0,
7162 -2147483648.0,
7163 -32768.0,
7164 -128.0,
7165 0.0,
7166 127.0,
7167 32767.0,
7168 2147483647.0,
7169 9223372036854776000.0,
7170 ];
7171 assert_eq!(
7172 f64_expected,
7173 get_cast_values::<Float64Type>(&i64_array, &DataType::Float64)
7174 .iter()
7175 .map(|i| i.parse::<f64>().unwrap())
7176 .collect::<Vec<f64>>()
7177 );
7178
7179 let f32_expected = vec![
7180 -9223372000000000000.0,
7181 -2147483600.0,
7182 -32768.0,
7183 -128.0,
7184 0.0,
7185 127.0,
7186 32767.0,
7187 2147483600.0,
7188 9223372000000000000.0,
7189 ];
7190 assert_eq!(
7191 f32_expected,
7192 get_cast_values::<Float32Type>(&i64_array, &DataType::Float32)
7193 .iter()
7194 .map(|i| i.parse::<f32>().unwrap())
7195 .collect::<Vec<f32>>()
7196 );
7197
7198 let f16_expected = vec![
7199 f16::from_f64(-9223372000000000000.0),
7200 f16::from_f64(-2147483600.0),
7201 f16::from_f64(-32768.0),
7202 f16::from_f64(-128.0),
7203 f16::from_f64(0.0),
7204 f16::from_f64(127.0),
7205 f16::from_f64(32767.0),
7206 f16::from_f64(2147483600.0),
7207 f16::from_f64(9223372000000000000.0),
7208 ];
7209 assert_eq!(
7210 f16_expected,
7211 get_cast_values::<Float16Type>(&i64_array, &DataType::Float16)
7212 .iter()
7213 .map(|i| i.parse::<f16>().unwrap())
7214 .collect::<Vec<f16>>()
7215 );
7216
7217 let i64_expected = vec![
7218 "-9223372036854775808",
7219 "-2147483648",
7220 "-32768",
7221 "-128",
7222 "0",
7223 "127",
7224 "32767",
7225 "2147483647",
7226 "9223372036854775807",
7227 ];
7228 assert_eq!(
7229 i64_expected,
7230 get_cast_values::<Int64Type>(&i64_array, &DataType::Int64)
7231 );
7232
7233 let i32_expected = vec![
7234 "null",
7235 "-2147483648",
7236 "-32768",
7237 "-128",
7238 "0",
7239 "127",
7240 "32767",
7241 "2147483647",
7242 "null",
7243 ];
7244 assert_eq!(
7245 i32_expected,
7246 get_cast_values::<Int32Type>(&i64_array, &DataType::Int32)
7247 );
7248
7249 assert_eq!(
7250 i32_expected,
7251 get_cast_values::<Date32Type>(&i64_array, &DataType::Date32)
7252 );
7253
7254 let i16_expected = vec![
7255 "null", "null", "-32768", "-128", "0", "127", "32767", "null", "null",
7256 ];
7257 assert_eq!(
7258 i16_expected,
7259 get_cast_values::<Int16Type>(&i64_array, &DataType::Int16)
7260 );
7261
7262 let i8_expected = vec![
7263 "null", "null", "null", "-128", "0", "127", "null", "null", "null",
7264 ];
7265 assert_eq!(
7266 i8_expected,
7267 get_cast_values::<Int8Type>(&i64_array, &DataType::Int8)
7268 );
7269
7270 let u64_expected = vec![
7271 "null",
7272 "null",
7273 "null",
7274 "null",
7275 "0",
7276 "127",
7277 "32767",
7278 "2147483647",
7279 "9223372036854775807",
7280 ];
7281 assert_eq!(
7282 u64_expected,
7283 get_cast_values::<UInt64Type>(&i64_array, &DataType::UInt64)
7284 );
7285
7286 let u32_expected = vec![
7287 "null",
7288 "null",
7289 "null",
7290 "null",
7291 "0",
7292 "127",
7293 "32767",
7294 "2147483647",
7295 "null",
7296 ];
7297 assert_eq!(
7298 u32_expected,
7299 get_cast_values::<UInt32Type>(&i64_array, &DataType::UInt32)
7300 );
7301
7302 let u16_expected = vec![
7303 "null", "null", "null", "null", "0", "127", "32767", "null", "null",
7304 ];
7305 assert_eq!(
7306 u16_expected,
7307 get_cast_values::<UInt16Type>(&i64_array, &DataType::UInt16)
7308 );
7309
7310 let u8_expected = vec![
7311 "null", "null", "null", "null", "0", "127", "null", "null", "null",
7312 ];
7313 assert_eq!(
7314 u8_expected,
7315 get_cast_values::<UInt8Type>(&i64_array, &DataType::UInt8)
7316 );
7317 }
7318
7319 #[test]
7320 fn test_cast_from_int32() {
7321 let i32_values: Vec<i32> = vec![
7322 i32::MIN,
7323 i16::MIN as i32,
7324 i8::MIN as i32,
7325 0,
7326 i8::MAX as i32,
7327 i16::MAX as i32,
7328 i32::MAX,
7329 ];
7330 let i32_array: ArrayRef = Arc::new(Int32Array::from(i32_values));
7331
7332 let f64_expected = vec![
7333 "-2147483648.0",
7334 "-32768.0",
7335 "-128.0",
7336 "0.0",
7337 "127.0",
7338 "32767.0",
7339 "2147483647.0",
7340 ];
7341 assert_eq!(
7342 f64_expected,
7343 get_cast_values::<Float64Type>(&i32_array, &DataType::Float64)
7344 );
7345
7346 let f32_expected = vec![
7347 "-2147483600.0",
7348 "-32768.0",
7349 "-128.0",
7350 "0.0",
7351 "127.0",
7352 "32767.0",
7353 "2147483600.0",
7354 ];
7355 assert_eq!(
7356 f32_expected,
7357 get_cast_values::<Float32Type>(&i32_array, &DataType::Float32)
7358 );
7359
7360 let f16_expected = vec![
7361 f16::from_f64(-2147483600.0),
7362 f16::from_f64(-32768.0),
7363 f16::from_f64(-128.0),
7364 f16::from_f64(0.0),
7365 f16::from_f64(127.0),
7366 f16::from_f64(32767.0),
7367 f16::from_f64(2147483600.0),
7368 ];
7369 assert_eq!(
7370 f16_expected,
7371 get_cast_values::<Float16Type>(&i32_array, &DataType::Float16)
7372 .iter()
7373 .map(|i| i.parse::<f16>().unwrap())
7374 .collect::<Vec<f16>>()
7375 );
7376
7377 let i16_expected = vec!["null", "-32768", "-128", "0", "127", "32767", "null"];
7378 assert_eq!(
7379 i16_expected,
7380 get_cast_values::<Int16Type>(&i32_array, &DataType::Int16)
7381 );
7382
7383 let i8_expected = vec!["null", "null", "-128", "0", "127", "null", "null"];
7384 assert_eq!(
7385 i8_expected,
7386 get_cast_values::<Int8Type>(&i32_array, &DataType::Int8)
7387 );
7388
7389 let u64_expected = vec!["null", "null", "null", "0", "127", "32767", "2147483647"];
7390 assert_eq!(
7391 u64_expected,
7392 get_cast_values::<UInt64Type>(&i32_array, &DataType::UInt64)
7393 );
7394
7395 let u32_expected = vec!["null", "null", "null", "0", "127", "32767", "2147483647"];
7396 assert_eq!(
7397 u32_expected,
7398 get_cast_values::<UInt32Type>(&i32_array, &DataType::UInt32)
7399 );
7400
7401 let u16_expected = vec!["null", "null", "null", "0", "127", "32767", "null"];
7402 assert_eq!(
7403 u16_expected,
7404 get_cast_values::<UInt16Type>(&i32_array, &DataType::UInt16)
7405 );
7406
7407 let u8_expected = vec!["null", "null", "null", "0", "127", "null", "null"];
7408 assert_eq!(
7409 u8_expected,
7410 get_cast_values::<UInt8Type>(&i32_array, &DataType::UInt8)
7411 );
7412
7413 let i64_expected = vec![
7415 "-185542587187200000",
7416 "-2831155200000",
7417 "-11059200000",
7418 "0",
7419 "10972800000",
7420 "2831068800000",
7421 "185542587100800000",
7422 ];
7423 assert_eq!(
7424 i64_expected,
7425 get_cast_values::<Date64Type>(&i32_array, &DataType::Date64)
7426 );
7427 }
7428
7429 #[test]
7430 fn test_cast_from_int16() {
7431 let i16_values: Vec<i16> = vec![i16::MIN, i8::MIN as i16, 0, i8::MAX as i16, i16::MAX];
7432 let i16_array: ArrayRef = Arc::new(Int16Array::from(i16_values));
7433
7434 let f64_expected = vec!["-32768.0", "-128.0", "0.0", "127.0", "32767.0"];
7435 assert_eq!(
7436 f64_expected,
7437 get_cast_values::<Float64Type>(&i16_array, &DataType::Float64)
7438 );
7439
7440 let f32_expected = vec!["-32768.0", "-128.0", "0.0", "127.0", "32767.0"];
7441 assert_eq!(
7442 f32_expected,
7443 get_cast_values::<Float32Type>(&i16_array, &DataType::Float32)
7444 );
7445
7446 let f16_expected = vec![
7447 f16::from_f64(-32768.0),
7448 f16::from_f64(-128.0),
7449 f16::from_f64(0.0),
7450 f16::from_f64(127.0),
7451 f16::from_f64(32767.0),
7452 ];
7453 assert_eq!(
7454 f16_expected,
7455 get_cast_values::<Float16Type>(&i16_array, &DataType::Float16)
7456 .iter()
7457 .map(|i| i.parse::<f16>().unwrap())
7458 .collect::<Vec<f16>>()
7459 );
7460
7461 let i64_expected = vec!["-32768", "-128", "0", "127", "32767"];
7462 assert_eq!(
7463 i64_expected,
7464 get_cast_values::<Int64Type>(&i16_array, &DataType::Int64)
7465 );
7466
7467 let i32_expected = vec!["-32768", "-128", "0", "127", "32767"];
7468 assert_eq!(
7469 i32_expected,
7470 get_cast_values::<Int32Type>(&i16_array, &DataType::Int32)
7471 );
7472
7473 let i16_expected = vec!["-32768", "-128", "0", "127", "32767"];
7474 assert_eq!(
7475 i16_expected,
7476 get_cast_values::<Int16Type>(&i16_array, &DataType::Int16)
7477 );
7478
7479 let i8_expected = vec!["null", "-128", "0", "127", "null"];
7480 assert_eq!(
7481 i8_expected,
7482 get_cast_values::<Int8Type>(&i16_array, &DataType::Int8)
7483 );
7484
7485 let u64_expected = vec!["null", "null", "0", "127", "32767"];
7486 assert_eq!(
7487 u64_expected,
7488 get_cast_values::<UInt64Type>(&i16_array, &DataType::UInt64)
7489 );
7490
7491 let u32_expected = vec!["null", "null", "0", "127", "32767"];
7492 assert_eq!(
7493 u32_expected,
7494 get_cast_values::<UInt32Type>(&i16_array, &DataType::UInt32)
7495 );
7496
7497 let u16_expected = vec!["null", "null", "0", "127", "32767"];
7498 assert_eq!(
7499 u16_expected,
7500 get_cast_values::<UInt16Type>(&i16_array, &DataType::UInt16)
7501 );
7502
7503 let u8_expected = vec!["null", "null", "0", "127", "null"];
7504 assert_eq!(
7505 u8_expected,
7506 get_cast_values::<UInt8Type>(&i16_array, &DataType::UInt8)
7507 );
7508 }
7509
7510 #[test]
7511 fn test_cast_from_date32() {
7512 let i32_values: Vec<i32> = vec![
7513 i32::MIN,
7514 i16::MIN as i32,
7515 i8::MIN as i32,
7516 0,
7517 i8::MAX as i32,
7518 i16::MAX as i32,
7519 i32::MAX,
7520 ];
7521 let date32_array: ArrayRef = Arc::new(Date32Array::from(i32_values));
7522
7523 let i64_expected = vec![
7524 "-2147483648",
7525 "-32768",
7526 "-128",
7527 "0",
7528 "127",
7529 "32767",
7530 "2147483647",
7531 ];
7532 assert_eq!(
7533 i64_expected,
7534 get_cast_values::<Int64Type>(&date32_array, &DataType::Int64)
7535 );
7536 }
7537
7538 #[test]
7539 fn test_cast_from_int8() {
7540 let i8_values: Vec<i8> = vec![i8::MIN, 0, i8::MAX];
7541 let i8_array = Int8Array::from(i8_values);
7542
7543 let f64_expected = vec!["-128.0", "0.0", "127.0"];
7544 assert_eq!(
7545 f64_expected,
7546 get_cast_values::<Float64Type>(&i8_array, &DataType::Float64)
7547 );
7548
7549 let f32_expected = vec!["-128.0", "0.0", "127.0"];
7550 assert_eq!(
7551 f32_expected,
7552 get_cast_values::<Float32Type>(&i8_array, &DataType::Float32)
7553 );
7554
7555 let f16_expected = vec!["-128.0", "0.0", "127.0"];
7556 assert_eq!(
7557 f16_expected,
7558 get_cast_values::<Float16Type>(&i8_array, &DataType::Float16)
7559 );
7560
7561 let i64_expected = vec!["-128", "0", "127"];
7562 assert_eq!(
7563 i64_expected,
7564 get_cast_values::<Int64Type>(&i8_array, &DataType::Int64)
7565 );
7566
7567 let i32_expected = vec!["-128", "0", "127"];
7568 assert_eq!(
7569 i32_expected,
7570 get_cast_values::<Int32Type>(&i8_array, &DataType::Int32)
7571 );
7572
7573 let i16_expected = vec!["-128", "0", "127"];
7574 assert_eq!(
7575 i16_expected,
7576 get_cast_values::<Int16Type>(&i8_array, &DataType::Int16)
7577 );
7578
7579 let i8_expected = vec!["-128", "0", "127"];
7580 assert_eq!(
7581 i8_expected,
7582 get_cast_values::<Int8Type>(&i8_array, &DataType::Int8)
7583 );
7584
7585 let u64_expected = vec!["null", "0", "127"];
7586 assert_eq!(
7587 u64_expected,
7588 get_cast_values::<UInt64Type>(&i8_array, &DataType::UInt64)
7589 );
7590
7591 let u32_expected = vec!["null", "0", "127"];
7592 assert_eq!(
7593 u32_expected,
7594 get_cast_values::<UInt32Type>(&i8_array, &DataType::UInt32)
7595 );
7596
7597 let u16_expected = vec!["null", "0", "127"];
7598 assert_eq!(
7599 u16_expected,
7600 get_cast_values::<UInt16Type>(&i8_array, &DataType::UInt16)
7601 );
7602
7603 let u8_expected = vec!["null", "0", "127"];
7604 assert_eq!(
7605 u8_expected,
7606 get_cast_values::<UInt8Type>(&i8_array, &DataType::UInt8)
7607 );
7608 }
7609
7610 fn get_cast_values<T>(array: &dyn Array, dt: &DataType) -> Vec<String>
7612 where
7613 T: ArrowPrimitiveType,
7614 {
7615 let c = cast(array, dt).unwrap();
7616 let a = c.as_primitive::<T>();
7617 let mut v: Vec<String> = vec![];
7618 for i in 0..array.len() {
7619 if a.is_null(i) {
7620 v.push("null".to_string())
7621 } else {
7622 v.push(format!("{:?}", a.value(i)));
7623 }
7624 }
7625 v
7626 }
7627
7628 #[test]
7629 fn test_cast_utf8_dict() {
7630 use DataType::*;
7632
7633 let mut builder = StringDictionaryBuilder::<Int8Type>::new();
7634 builder.append("one").unwrap();
7635 builder.append_null();
7636 builder.append("three").unwrap();
7637 let array: ArrayRef = Arc::new(builder.finish());
7638
7639 let expected = vec!["one", "null", "three"];
7640
7641 let cast_type = Utf8;
7643 let cast_array = cast(&array, &cast_type).expect("cast to UTF-8 failed");
7644 assert_eq!(cast_array.data_type(), &cast_type);
7645 assert_eq!(array_to_strings(&cast_array), expected);
7646
7647 let cast_type = Dictionary(Box::new(Int16), Box::new(Utf8));
7650 let cast_array = cast(&array, &cast_type).expect("cast failed");
7651 assert_eq!(cast_array.data_type(), &cast_type);
7652 assert_eq!(array_to_strings(&cast_array), expected);
7653
7654 let cast_type = Dictionary(Box::new(Int32), Box::new(Utf8));
7655 let cast_array = cast(&array, &cast_type).expect("cast failed");
7656 assert_eq!(cast_array.data_type(), &cast_type);
7657 assert_eq!(array_to_strings(&cast_array), expected);
7658
7659 let cast_type = Dictionary(Box::new(Int64), Box::new(Utf8));
7660 let cast_array = cast(&array, &cast_type).expect("cast failed");
7661 assert_eq!(cast_array.data_type(), &cast_type);
7662 assert_eq!(array_to_strings(&cast_array), expected);
7663
7664 let cast_type = Dictionary(Box::new(UInt8), Box::new(Utf8));
7665 let cast_array = cast(&array, &cast_type).expect("cast failed");
7666 assert_eq!(cast_array.data_type(), &cast_type);
7667 assert_eq!(array_to_strings(&cast_array), expected);
7668
7669 let cast_type = Dictionary(Box::new(UInt16), Box::new(Utf8));
7670 let cast_array = cast(&array, &cast_type).expect("cast failed");
7671 assert_eq!(cast_array.data_type(), &cast_type);
7672 assert_eq!(array_to_strings(&cast_array), expected);
7673
7674 let cast_type = Dictionary(Box::new(UInt32), Box::new(Utf8));
7675 let cast_array = cast(&array, &cast_type).expect("cast failed");
7676 assert_eq!(cast_array.data_type(), &cast_type);
7677 assert_eq!(array_to_strings(&cast_array), expected);
7678
7679 let cast_type = Dictionary(Box::new(UInt64), Box::new(Utf8));
7680 let cast_array = cast(&array, &cast_type).expect("cast failed");
7681 assert_eq!(cast_array.data_type(), &cast_type);
7682 assert_eq!(array_to_strings(&cast_array), expected);
7683 }
7684
7685 #[test]
7686 fn test_cast_dict_to_dict_bad_index_value_primitive() {
7687 use DataType::*;
7688 let mut builder = PrimitiveDictionaryBuilder::<Int32Type, Int64Type>::new();
7693
7694 for i in 0..200 {
7698 builder.append(i).unwrap();
7699 }
7700 let array: ArrayRef = Arc::new(builder.finish());
7701
7702 let cast_type = Dictionary(Box::new(Int8), Box::new(Utf8));
7703 let res = cast(&array, &cast_type);
7704 assert!(res.is_err());
7705 let actual_error = format!("{res:?}");
7706 let expected_error = "Could not convert 72 dictionary indexes from Int32 to Int8";
7707 assert!(
7708 actual_error.contains(expected_error),
7709 "did not find expected error '{actual_error}' in actual error '{expected_error}'"
7710 );
7711 }
7712
7713 #[test]
7714 fn test_cast_dict_to_dict_bad_index_value_utf8() {
7715 use DataType::*;
7716 let mut builder = StringDictionaryBuilder::<Int32Type>::new();
7720
7721 for i in 0..200 {
7725 let val = format!("val{i}");
7726 builder.append(&val).unwrap();
7727 }
7728 let array = builder.finish();
7729
7730 let cast_type = Dictionary(Box::new(Int8), Box::new(Utf8));
7731 let res = cast(&array, &cast_type);
7732 assert!(res.is_err());
7733 let actual_error = format!("{res:?}");
7734 let expected_error = "Could not convert 72 dictionary indexes from Int32 to Int8";
7735 assert!(
7736 actual_error.contains(expected_error),
7737 "did not find expected error '{actual_error}' in actual error '{expected_error}'"
7738 );
7739 }
7740
7741 #[test]
7742 fn test_cast_primitive_dict() {
7743 use DataType::*;
7745
7746 let mut builder = PrimitiveDictionaryBuilder::<Int8Type, Int32Type>::new();
7747 builder.append(1).unwrap();
7748 builder.append_null();
7749 builder.append(3).unwrap();
7750 let array: ArrayRef = Arc::new(builder.finish());
7751
7752 let expected = vec!["1", "null", "3"];
7753
7754 let cast_array = cast(&array, &Utf8).expect("cast to UTF-8 failed");
7756 assert_eq!(array_to_strings(&cast_array), expected);
7757 assert_eq!(cast_array.data_type(), &Utf8);
7758
7759 let cast_array = cast(&array, &Int64).expect("cast to int64 failed");
7760 assert_eq!(array_to_strings(&cast_array), expected);
7761 assert_eq!(cast_array.data_type(), &Int64);
7762 }
7763
7764 #[test]
7765 fn test_cast_primitive_array_to_dict() {
7766 use DataType::*;
7767
7768 let mut builder = PrimitiveBuilder::<Int32Type>::new();
7769 builder.append_value(1);
7770 builder.append_null();
7771 builder.append_value(3);
7772 let array: ArrayRef = Arc::new(builder.finish());
7773
7774 let expected = vec!["1", "null", "3"];
7775
7776 let cast_type = Dictionary(Box::new(UInt8), Box::new(Int32));
7778 let cast_array = cast(&array, &cast_type).expect("cast failed");
7779 assert_eq!(cast_array.data_type(), &cast_type);
7780 assert_eq!(array_to_strings(&cast_array), expected);
7781
7782 let cast_type = Dictionary(Box::new(UInt8), Box::new(Int8));
7784 let cast_array = cast(&array, &cast_type).expect("cast failed");
7785 assert_eq!(cast_array.data_type(), &cast_type);
7786 assert_eq!(array_to_strings(&cast_array), expected);
7787 }
7788
7789 #[test]
7790 fn test_cast_time_array_to_dict() {
7791 use DataType::*;
7792
7793 let array = Arc::new(Date32Array::from(vec![Some(1000), None, Some(2000)])) as ArrayRef;
7794
7795 let expected = vec!["1972-09-27", "null", "1975-06-24"];
7796
7797 let cast_type = Dictionary(Box::new(UInt8), Box::new(Date32));
7798 let cast_array = cast(&array, &cast_type).expect("cast failed");
7799 assert_eq!(cast_array.data_type(), &cast_type);
7800 assert_eq!(array_to_strings(&cast_array), expected);
7801 }
7802
7803 #[test]
7804 fn test_cast_timestamp_array_to_dict() {
7805 use DataType::*;
7806
7807 let array = Arc::new(
7808 TimestampSecondArray::from(vec![Some(1000), None, Some(2000)]).with_timezone_utc(),
7809 ) as ArrayRef;
7810
7811 let expected = vec!["1970-01-01T00:16:40", "null", "1970-01-01T00:33:20"];
7812
7813 let cast_type = Dictionary(Box::new(UInt8), Box::new(Timestamp(TimeUnit::Second, None)));
7814 let cast_array = cast(&array, &cast_type).expect("cast failed");
7815 assert_eq!(cast_array.data_type(), &cast_type);
7816 assert_eq!(array_to_strings(&cast_array), expected);
7817 }
7818
7819 #[test]
7820 fn test_cast_string_array_to_dict() {
7821 use DataType::*;
7822
7823 let array = Arc::new(StringArray::from(vec![Some("one"), None, Some("three")])) as ArrayRef;
7824
7825 let expected = vec!["one", "null", "three"];
7826
7827 let cast_type = Dictionary(Box::new(UInt8), Box::new(Utf8));
7829 let cast_array = cast(&array, &cast_type).expect("cast failed");
7830 assert_eq!(cast_array.data_type(), &cast_type);
7831 assert_eq!(array_to_strings(&cast_array), expected);
7832 }
7833
7834 #[test]
7835 fn test_cast_null_array_to_from_decimal_array() {
7836 let data_type = DataType::Decimal128(12, 4);
7837 let array = new_null_array(&DataType::Null, 4);
7838 assert_eq!(array.data_type(), &DataType::Null);
7839 let cast_array = cast(&array, &data_type).expect("cast failed");
7840 assert_eq!(cast_array.data_type(), &data_type);
7841 for i in 0..4 {
7842 assert!(cast_array.is_null(i));
7843 }
7844
7845 let array = new_null_array(&data_type, 4);
7846 assert_eq!(array.data_type(), &data_type);
7847 let cast_array = cast(&array, &DataType::Null).expect("cast failed");
7848 assert_eq!(cast_array.data_type(), &DataType::Null);
7849 assert_eq!(cast_array.len(), 4);
7850 assert_eq!(cast_array.logical_nulls().unwrap().null_count(), 4);
7851 }
7852
7853 #[test]
7854 fn test_cast_null_array_from_and_to_primitive_array() {
7855 macro_rules! typed_test {
7856 ($ARR_TYPE:ident, $DATATYPE:ident, $TYPE:tt) => {{
7857 {
7858 let array = Arc::new(NullArray::new(6)) as ArrayRef;
7859 let expected = $ARR_TYPE::from(vec![None; 6]);
7860 let cast_type = DataType::$DATATYPE;
7861 let cast_array = cast(&array, &cast_type).expect("cast failed");
7862 let cast_array = cast_array.as_primitive::<$TYPE>();
7863 assert_eq!(cast_array.data_type(), &cast_type);
7864 assert_eq!(cast_array, &expected);
7865 }
7866 }};
7867 }
7868
7869 typed_test!(Int16Array, Int16, Int16Type);
7870 typed_test!(Int32Array, Int32, Int32Type);
7871 typed_test!(Int64Array, Int64, Int64Type);
7872
7873 typed_test!(UInt16Array, UInt16, UInt16Type);
7874 typed_test!(UInt32Array, UInt32, UInt32Type);
7875 typed_test!(UInt64Array, UInt64, UInt64Type);
7876
7877 typed_test!(Float32Array, Float32, Float32Type);
7878 typed_test!(Float64Array, Float64, Float64Type);
7879
7880 typed_test!(Date32Array, Date32, Date32Type);
7881 typed_test!(Date64Array, Date64, Date64Type);
7882 }
7883
7884 fn cast_from_null_to_other(data_type: &DataType) {
7885 {
7887 let array = new_null_array(&DataType::Null, 4);
7888 assert_eq!(array.data_type(), &DataType::Null);
7889 let cast_array = cast(&array, data_type).expect("cast failed");
7890 assert_eq!(cast_array.data_type(), data_type);
7891 for i in 0..4 {
7892 assert!(cast_array.is_null(i));
7893 }
7894 }
7895 }
7896
7897 #[test]
7898 fn test_cast_null_from_and_to_variable_sized() {
7899 cast_from_null_to_other(&DataType::Utf8);
7900 cast_from_null_to_other(&DataType::LargeUtf8);
7901 cast_from_null_to_other(&DataType::Binary);
7902 cast_from_null_to_other(&DataType::LargeBinary);
7903 }
7904
7905 #[test]
7906 fn test_cast_null_from_and_to_nested_type() {
7907 let data_type = DataType::Map(
7909 Arc::new(Field::new_struct(
7910 "entry",
7911 vec![
7912 Field::new("key", DataType::Utf8, false),
7913 Field::new("value", DataType::Int32, true),
7914 ],
7915 false,
7916 )),
7917 false,
7918 );
7919 cast_from_null_to_other(&data_type);
7920
7921 let data_type = DataType::List(Arc::new(Field::new_list_field(DataType::Int32, true)));
7923 cast_from_null_to_other(&data_type);
7924 let data_type = DataType::LargeList(Arc::new(Field::new_list_field(DataType::Int32, true)));
7925 cast_from_null_to_other(&data_type);
7926 let data_type =
7927 DataType::FixedSizeList(Arc::new(Field::new_list_field(DataType::Int32, true)), 4);
7928 cast_from_null_to_other(&data_type);
7929
7930 let values = vec![None, None, None, None] as Vec<Option<&str>>;
7932 let array: DictionaryArray<Int8Type> = values.into_iter().collect();
7933 let array = Arc::new(array) as ArrayRef;
7934 let data_type = array.data_type().to_owned();
7935 cast_from_null_to_other(&data_type);
7936
7937 let data_type = DataType::Struct(vec![Field::new("data", DataType::Int64, false)].into());
7939 cast_from_null_to_other(&data_type);
7940 }
7941
7942 fn array_to_strings(array: &ArrayRef) -> Vec<String> {
7944 let options = FormatOptions::new().with_null("null");
7945 let formatter = ArrayFormatter::try_new(array.as_ref(), &options).unwrap();
7946 (0..array.len())
7947 .map(|i| formatter.value(i).to_string())
7948 .collect()
7949 }
7950
7951 #[test]
7952 fn test_cast_utf8_to_date32() {
7953 use chrono::NaiveDate;
7954 let from_ymd = chrono::NaiveDate::from_ymd_opt;
7955 let since = chrono::NaiveDate::signed_duration_since;
7956
7957 let a = StringArray::from(vec![
7958 "2000-01-01", "2000-01-01T12:00:00", "2000-2-2", "2000-00-00", "2000", ]);
7964 let array = Arc::new(a) as ArrayRef;
7965 let b = cast(&array, &DataType::Date32).unwrap();
7966 let c = b.as_primitive::<Date32Type>();
7967
7968 let date_value = since(
7970 NaiveDate::from_ymd_opt(2000, 1, 1).unwrap(),
7971 from_ymd(1970, 1, 1).unwrap(),
7972 )
7973 .num_days() as i32;
7974 assert!(c.is_valid(0)); assert_eq!(date_value, c.value(0));
7976
7977 assert!(c.is_valid(1)); assert_eq!(date_value, c.value(1));
7979
7980 let date_value = since(
7981 NaiveDate::from_ymd_opt(2000, 2, 2).unwrap(),
7982 from_ymd(1970, 1, 1).unwrap(),
7983 )
7984 .num_days() as i32;
7985 assert!(c.is_valid(2)); assert_eq!(date_value, c.value(2));
7987
7988 assert!(!c.is_valid(3)); assert!(!c.is_valid(4)); }
7992
7993 #[test]
7994 fn test_cast_utf8_to_date64() {
7995 let a = StringArray::from(vec![
7996 "2000-01-01T12:00:00", "2020-12-15T12:34:56", "2020-2-2T12:34:56", "2000-00-00T12:00:00", "2000-01-01 12:00:00", "2000-01-01", ]);
8003 let array = Arc::new(a) as ArrayRef;
8004 let b = cast(&array, &DataType::Date64).unwrap();
8005 let c = b.as_primitive::<Date64Type>();
8006
8007 assert!(c.is_valid(0)); assert_eq!(946728000000, c.value(0));
8010 assert!(c.is_valid(1)); assert_eq!(1608035696000, c.value(1));
8012 assert!(!c.is_valid(2)); assert!(!c.is_valid(3)); assert!(c.is_valid(4)); assert_eq!(946728000000, c.value(4));
8017 assert!(c.is_valid(5)); assert_eq!(946684800000, c.value(5));
8019 }
8020
8021 #[test]
8022 fn test_can_cast_fsl_to_fsl() {
8023 let from_array = Arc::new(
8024 FixedSizeListArray::from_iter_primitive::<Float32Type, _, _>(
8025 [Some([Some(1.0), Some(2.0)]), None],
8026 2,
8027 ),
8028 ) as ArrayRef;
8029 let to_array = Arc::new(
8030 FixedSizeListArray::from_iter_primitive::<Float16Type, _, _>(
8031 [
8032 Some([Some(f16::from_f32(1.0)), Some(f16::from_f32(2.0))]),
8033 None,
8034 ],
8035 2,
8036 ),
8037 ) as ArrayRef;
8038
8039 assert!(can_cast_types(from_array.data_type(), to_array.data_type()));
8040 let actual = cast(&from_array, to_array.data_type()).unwrap();
8041 assert_eq!(actual.data_type(), to_array.data_type());
8042
8043 let invalid_target =
8044 DataType::FixedSizeList(Arc::new(Field::new_list_field(DataType::Binary, true)), 2);
8045 assert!(!can_cast_types(from_array.data_type(), &invalid_target));
8046
8047 let invalid_size =
8048 DataType::FixedSizeList(Arc::new(Field::new_list_field(DataType::Float16, true)), 5);
8049 assert!(!can_cast_types(from_array.data_type(), &invalid_size));
8050 }
8051
8052 #[test]
8053 fn test_can_cast_types_fixed_size_list_to_list() {
8054 let array1 = Arc::new(make_fixed_size_list_array()) as ArrayRef;
8056 assert!(can_cast_types(
8057 array1.data_type(),
8058 &DataType::List(Arc::new(Field::new("", DataType::Int32, false)))
8059 ));
8060
8061 let array2 = Arc::new(make_fixed_size_list_array_for_large_list()) as ArrayRef;
8063 assert!(can_cast_types(
8064 array2.data_type(),
8065 &DataType::LargeList(Arc::new(Field::new("", DataType::Int64, false)))
8066 ));
8067 }
8068
8069 #[test]
8070 fn test_cast_fixed_size_list_to_list() {
8071 let cases = [
8077 (
8079 Arc::new(FixedSizeListArray::from_iter_primitive::<Int32Type, _, _>(
8080 [[1, 1].map(Some), [2, 2].map(Some)].map(Some),
8081 2,
8082 )) as ArrayRef,
8083 Arc::new(ListArray::from_iter_primitive::<Int32Type, _, _>([
8084 Some([Some(1), Some(1)]),
8085 Some([Some(2), Some(2)]),
8086 ])) as ArrayRef,
8087 ),
8088 (
8090 Arc::new(FixedSizeListArray::from_iter_primitive::<Int32Type, _, _>(
8091 [None, Some([Some(2), Some(2)])],
8092 2,
8093 )) as ArrayRef,
8094 Arc::new(ListArray::from_iter_primitive::<Int32Type, _, _>([
8095 None,
8096 Some([Some(2), Some(2)]),
8097 ])) as ArrayRef,
8098 ),
8099 (
8101 Arc::new(FixedSizeListArray::from_iter_primitive::<Int32Type, _, _>(
8102 [[1, 1].map(Some), [2, 2].map(Some)].map(Some),
8103 2,
8104 )) as ArrayRef,
8105 Arc::new(LargeListArray::from_iter_primitive::<Int64Type, _, _>([
8106 Some([Some(1), Some(1)]),
8107 Some([Some(2), Some(2)]),
8108 ])) as ArrayRef,
8109 ),
8110 (
8112 Arc::new(FixedSizeListArray::from_iter_primitive::<Int32Type, _, _>(
8113 [None, Some([Some(2), Some(2)])],
8114 2,
8115 )) as ArrayRef,
8116 Arc::new(LargeListArray::from_iter_primitive::<Int64Type, _, _>([
8117 None,
8118 Some([Some(2), Some(2)]),
8119 ])) as ArrayRef,
8120 ),
8121 ];
8122
8123 for (array, expected) in cases {
8124 let array = Arc::new(array) as ArrayRef;
8125
8126 assert!(
8127 can_cast_types(array.data_type(), expected.data_type()),
8128 "can_cast_types claims we cannot cast {:?} to {:?}",
8129 array.data_type(),
8130 expected.data_type()
8131 );
8132
8133 let list_array = cast(&array, expected.data_type())
8134 .unwrap_or_else(|_| panic!("Failed to cast {array:?} to {expected:?}"));
8135 assert_eq!(
8136 list_array.as_ref(),
8137 &expected,
8138 "Incorrect result from casting {array:?} to {expected:?}",
8139 );
8140 }
8141 }
8142
8143 #[test]
8144 fn test_cast_utf8_to_list() {
8145 let array = Arc::new(StringArray::from(vec!["5"])) as ArrayRef;
8147 let field = Arc::new(Field::new("", DataType::Int32, false));
8148 let list_array = cast(&array, &DataType::List(field.clone())).unwrap();
8149 let actual = list_array.as_list_opt::<i32>().unwrap();
8150 let expect = ListArray::from_iter_primitive::<Int32Type, _, _>([Some([Some(5)])]);
8151 assert_eq!(&expect.value(0), &actual.value(0));
8152
8153 let list_array = cast(&array, &DataType::LargeList(field.clone())).unwrap();
8155 let actual = list_array.as_list_opt::<i64>().unwrap();
8156 let expect = LargeListArray::from_iter_primitive::<Int32Type, _, _>([Some([Some(5)])]);
8157 assert_eq!(&expect.value(0), &actual.value(0));
8158
8159 let list_array = cast(&array, &DataType::FixedSizeList(field.clone(), 1)).unwrap();
8161 let actual = list_array.as_fixed_size_list_opt().unwrap();
8162 let expect =
8163 FixedSizeListArray::from_iter_primitive::<Int32Type, _, _>([Some([Some(5)])], 1);
8164 assert_eq!(&expect.value(0), &actual.value(0));
8165 }
8166
8167 #[test]
8168 fn test_cast_single_element_fixed_size_list() {
8169 let from_array = Arc::new(FixedSizeListArray::from_iter_primitive::<Int16Type, _, _>(
8171 [(Some([Some(5)]))],
8172 1,
8173 )) as ArrayRef;
8174 let casted_array = cast(&from_array, &DataType::Int32).unwrap();
8175 let actual: &Int32Array = casted_array.as_primitive();
8176 let expected = Int32Array::from(vec![Some(5)]);
8177 assert_eq!(&expected, actual);
8178
8179 let from_array = Arc::new(FixedSizeListArray::from_iter_primitive::<Int16Type, _, _>(
8181 [(Some([Some(5)]))],
8182 1,
8183 )) as ArrayRef;
8184 let to_field = Arc::new(Field::new("dummy", DataType::Float32, false));
8185 let actual = cast(&from_array, &DataType::FixedSizeList(to_field.clone(), 1)).unwrap();
8186 let expected = Arc::new(FixedSizeListArray::new(
8187 to_field.clone(),
8188 1,
8189 Arc::new(Float32Array::from(vec![Some(5.0)])) as ArrayRef,
8190 None,
8191 )) as ArrayRef;
8192 assert_eq!(*expected, *actual);
8193
8194 let from_array = Arc::new(FixedSizeListArray::from_iter_primitive::<Int16Type, _, _>(
8196 [(Some([Some(5)]))],
8197 1,
8198 )) as ArrayRef;
8199 let to_field_inner = Arc::new(Field::new_list_field(DataType::Float32, false));
8200 let to_field = Arc::new(Field::new(
8201 "dummy",
8202 DataType::FixedSizeList(to_field_inner.clone(), 1),
8203 false,
8204 ));
8205 let actual = cast(&from_array, &DataType::FixedSizeList(to_field.clone(), 1)).unwrap();
8206 let expected = Arc::new(FixedSizeListArray::new(
8207 to_field.clone(),
8208 1,
8209 Arc::new(FixedSizeListArray::new(
8210 to_field_inner.clone(),
8211 1,
8212 Arc::new(Float32Array::from(vec![Some(5.0)])) as ArrayRef,
8213 None,
8214 )) as ArrayRef,
8215 None,
8216 )) as ArrayRef;
8217 assert_eq!(*expected, *actual);
8218
8219 let field = Arc::new(Field::new("dummy", DataType::Float32, false));
8221 let from_array = Arc::new(Int8Array::from(vec![Some(5)])) as ArrayRef;
8222 let casted_array = cast(&from_array, &DataType::FixedSizeList(field.clone(), 1)).unwrap();
8223 let actual = casted_array.as_fixed_size_list();
8224 let expected = Arc::new(FixedSizeListArray::new(
8225 field.clone(),
8226 1,
8227 Arc::new(Float32Array::from(vec![Some(5.0)])) as ArrayRef,
8228 None,
8229 )) as ArrayRef;
8230 assert_eq!(expected.as_ref(), actual);
8231
8232 let field = Arc::new(Field::new("nullable", DataType::Float32, true));
8234 let from_array = Arc::new(Int8Array::from(vec![None])) as ArrayRef;
8235 let casted_array = cast(&from_array, &DataType::FixedSizeList(field.clone(), 1)).unwrap();
8236 let actual = casted_array.as_fixed_size_list();
8237 let expected = Arc::new(FixedSizeListArray::new(
8238 field.clone(),
8239 1,
8240 Arc::new(Float32Array::from(vec![None])) as ArrayRef,
8241 None,
8242 )) as ArrayRef;
8243 assert_eq!(expected.as_ref(), actual);
8244 }
8245
8246 #[test]
8247 fn test_cast_list_containers() {
8248 let array = Arc::new(make_large_list_array()) as ArrayRef;
8250 let list_array = cast(
8251 &array,
8252 &DataType::List(Arc::new(Field::new("", DataType::Int32, false))),
8253 )
8254 .unwrap();
8255 let actual = list_array.as_any().downcast_ref::<ListArray>().unwrap();
8256 let expected = array.as_any().downcast_ref::<LargeListArray>().unwrap();
8257
8258 assert_eq!(&expected.value(0), &actual.value(0));
8259 assert_eq!(&expected.value(1), &actual.value(1));
8260 assert_eq!(&expected.value(2), &actual.value(2));
8261
8262 let array = Arc::new(make_list_array()) as ArrayRef;
8264 let large_list_array = cast(
8265 &array,
8266 &DataType::LargeList(Arc::new(Field::new("", DataType::Int32, false))),
8267 )
8268 .unwrap();
8269 let actual = large_list_array
8270 .as_any()
8271 .downcast_ref::<LargeListArray>()
8272 .unwrap();
8273 let expected = array.as_any().downcast_ref::<ListArray>().unwrap();
8274
8275 assert_eq!(&expected.value(0), &actual.value(0));
8276 assert_eq!(&expected.value(1), &actual.value(1));
8277 assert_eq!(&expected.value(2), &actual.value(2));
8278 }
8279
8280 #[test]
8281 fn test_cast_list_to_fsl() {
8282 let field = Arc::new(Field::new_list_field(DataType::Int32, true));
8290 let values = vec![
8291 Some(vec![Some(1), Some(2), Some(3)]),
8292 Some(vec![Some(4), Some(5), Some(6)]),
8293 ];
8294 let array = Arc::new(ListArray::from_iter_primitive::<Int32Type, _, _>(
8295 values.clone(),
8296 )) as ArrayRef;
8297 let expected = Arc::new(FixedSizeListArray::from_iter_primitive::<Int32Type, _, _>(
8298 values, 3,
8299 )) as ArrayRef;
8300 let actual = cast(array.as_ref(), &DataType::FixedSizeList(field.clone(), 3)).unwrap();
8301 assert_eq!(expected.as_ref(), actual.as_ref());
8302
8303 let cases = [
8306 (
8307 vec![1, 2, 3, 4, 5, 6],
8309 vec![3, 0, 3, 0],
8310 ),
8311 (
8312 vec![1, 2, 3, 0, 0, 4, 5, 6, 0],
8314 vec![3, 2, 3, 1],
8315 ),
8316 (
8317 vec![1, 2, 3, 0, 0, 0, 4, 5, 6, 0, 0, 0],
8319 vec![3, 3, 3, 3],
8320 ),
8321 (
8322 vec![1, 2, 3, 4, 5, 6, 0, 0, 0],
8324 vec![3, 0, 3, 3],
8325 ),
8326 ];
8327 let null_buffer = NullBuffer::from(vec![true, false, true, false]);
8328
8329 let expected = Arc::new(FixedSizeListArray::from_iter_primitive::<Int32Type, _, _>(
8330 vec![
8331 Some(vec![Some(1), Some(2), Some(3)]),
8332 None,
8333 Some(vec![Some(4), Some(5), Some(6)]),
8334 None,
8335 ],
8336 3,
8337 )) as ArrayRef;
8338
8339 for (values, lengths) in cases.iter() {
8340 let array = Arc::new(ListArray::new(
8341 field.clone(),
8342 OffsetBuffer::from_lengths(lengths.clone()),
8343 Arc::new(Int32Array::from(values.clone())),
8344 Some(null_buffer.clone()),
8345 )) as ArrayRef;
8346 let actual = cast(array.as_ref(), &DataType::FixedSizeList(field.clone(), 3)).unwrap();
8347 assert_eq!(expected.as_ref(), actual.as_ref());
8348 }
8349 }
8350
8351 #[test]
8352 fn test_cast_list_to_fsl_safety() {
8353 let values = vec![
8354 Some(vec![Some(1), Some(2), Some(3)]),
8355 Some(vec![Some(4), Some(5)]),
8356 Some(vec![Some(6), Some(7), Some(8), Some(9)]),
8357 Some(vec![Some(3), Some(4), Some(5)]),
8358 ];
8359 let array = Arc::new(ListArray::from_iter_primitive::<Int32Type, _, _>(
8360 values.clone(),
8361 )) as ArrayRef;
8362
8363 let res = cast_with_options(
8364 array.as_ref(),
8365 &DataType::FixedSizeList(Arc::new(Field::new_list_field(DataType::Int32, true)), 3),
8366 &CastOptions {
8367 safe: false,
8368 ..Default::default()
8369 },
8370 );
8371 assert!(res.is_err());
8372 assert!(format!("{res:?}")
8373 .contains("Cannot cast to FixedSizeList(3): value at index 1 has length 2"));
8374
8375 let res = cast(
8378 array.as_ref(),
8379 &DataType::FixedSizeList(Arc::new(Field::new_list_field(DataType::Int32, true)), 3),
8380 )
8381 .unwrap();
8382 let expected = Arc::new(FixedSizeListArray::from_iter_primitive::<Int32Type, _, _>(
8383 vec![
8384 Some(vec![Some(1), Some(2), Some(3)]),
8385 None, None, Some(vec![Some(3), Some(4), Some(5)]),
8388 ],
8389 3,
8390 )) as ArrayRef;
8391 assert_eq!(expected.as_ref(), res.as_ref());
8392
8393 let array = Arc::new(ListArray::from_iter_primitive::<Int32Type, _, _>(vec![
8396 Some(vec![Some(1), Some(2), Some(3)]),
8397 None,
8398 ])) as ArrayRef;
8399 let res = cast_with_options(
8400 array.as_ref(),
8401 &DataType::FixedSizeList(Arc::new(Field::new_list_field(DataType::Int32, true)), 3),
8402 &CastOptions {
8403 safe: false,
8404 ..Default::default()
8405 },
8406 )
8407 .unwrap();
8408 let expected = Arc::new(FixedSizeListArray::from_iter_primitive::<Int32Type, _, _>(
8409 vec![Some(vec![Some(1), Some(2), Some(3)]), None],
8410 3,
8411 )) as ArrayRef;
8412 assert_eq!(expected.as_ref(), res.as_ref());
8413 }
8414
8415 #[test]
8416 fn test_cast_large_list_to_fsl() {
8417 let values = vec![Some(vec![Some(1), Some(2)]), Some(vec![Some(3), Some(4)])];
8418 let array = Arc::new(LargeListArray::from_iter_primitive::<Int32Type, _, _>(
8419 values.clone(),
8420 )) as ArrayRef;
8421 let expected = Arc::new(FixedSizeListArray::from_iter_primitive::<Int32Type, _, _>(
8422 values, 2,
8423 )) as ArrayRef;
8424 let actual = cast(
8425 array.as_ref(),
8426 &DataType::FixedSizeList(Arc::new(Field::new_list_field(DataType::Int32, true)), 2),
8427 )
8428 .unwrap();
8429 assert_eq!(expected.as_ref(), actual.as_ref());
8430 }
8431
8432 #[test]
8433 fn test_cast_list_to_fsl_subcast() {
8434 let array = Arc::new(LargeListArray::from_iter_primitive::<Int32Type, _, _>(
8435 vec![
8436 Some(vec![Some(1), Some(2)]),
8437 Some(vec![Some(3), Some(i32::MAX)]),
8438 ],
8439 )) as ArrayRef;
8440 let expected = Arc::new(FixedSizeListArray::from_iter_primitive::<Int64Type, _, _>(
8441 vec![
8442 Some(vec![Some(1), Some(2)]),
8443 Some(vec![Some(3), Some(i32::MAX as i64)]),
8444 ],
8445 2,
8446 )) as ArrayRef;
8447 let actual = cast(
8448 array.as_ref(),
8449 &DataType::FixedSizeList(Arc::new(Field::new_list_field(DataType::Int64, true)), 2),
8450 )
8451 .unwrap();
8452 assert_eq!(expected.as_ref(), actual.as_ref());
8453
8454 let res = cast_with_options(
8455 array.as_ref(),
8456 &DataType::FixedSizeList(Arc::new(Field::new_list_field(DataType::Int16, true)), 2),
8457 &CastOptions {
8458 safe: false,
8459 ..Default::default()
8460 },
8461 );
8462 assert!(res.is_err());
8463 assert!(format!("{res:?}").contains("Can't cast value 2147483647 to type Int16"));
8464 }
8465
8466 #[test]
8467 fn test_cast_list_to_fsl_empty() {
8468 let field = Arc::new(Field::new_list_field(DataType::Int32, true));
8469 let array = new_empty_array(&DataType::List(field.clone()));
8470
8471 let target_type = DataType::FixedSizeList(field.clone(), 3);
8472 let expected = new_empty_array(&target_type);
8473
8474 let actual = cast(array.as_ref(), &target_type).unwrap();
8475 assert_eq!(expected.as_ref(), actual.as_ref());
8476 }
8477
8478 fn make_list_array() -> ListArray {
8479 let value_data = ArrayData::builder(DataType::Int32)
8481 .len(8)
8482 .add_buffer(Buffer::from_slice_ref([0, 1, 2, 3, 4, 5, 6, 7]))
8483 .build()
8484 .unwrap();
8485
8486 let value_offsets = Buffer::from_slice_ref([0, 3, 6, 8]);
8489
8490 let list_data_type = DataType::List(Arc::new(Field::new_list_field(DataType::Int32, true)));
8492 let list_data = ArrayData::builder(list_data_type)
8493 .len(3)
8494 .add_buffer(value_offsets)
8495 .add_child_data(value_data)
8496 .build()
8497 .unwrap();
8498 ListArray::from(list_data)
8499 }
8500
8501 fn make_large_list_array() -> LargeListArray {
8502 let value_data = ArrayData::builder(DataType::Int32)
8504 .len(8)
8505 .add_buffer(Buffer::from_slice_ref([0, 1, 2, 3, 4, 5, 6, 7]))
8506 .build()
8507 .unwrap();
8508
8509 let value_offsets = Buffer::from_slice_ref([0i64, 3, 6, 8]);
8512
8513 let list_data_type =
8515 DataType::LargeList(Arc::new(Field::new_list_field(DataType::Int32, true)));
8516 let list_data = ArrayData::builder(list_data_type)
8517 .len(3)
8518 .add_buffer(value_offsets)
8519 .add_child_data(value_data)
8520 .build()
8521 .unwrap();
8522 LargeListArray::from(list_data)
8523 }
8524
8525 fn make_fixed_size_list_array() -> FixedSizeListArray {
8526 let value_data = ArrayData::builder(DataType::Int32)
8528 .len(8)
8529 .add_buffer(Buffer::from_slice_ref([0, 1, 2, 3, 4, 5, 6, 7]))
8530 .build()
8531 .unwrap();
8532
8533 let list_data_type =
8534 DataType::FixedSizeList(Arc::new(Field::new_list_field(DataType::Int32, true)), 4);
8535 let list_data = ArrayData::builder(list_data_type)
8536 .len(2)
8537 .add_child_data(value_data)
8538 .build()
8539 .unwrap();
8540 FixedSizeListArray::from(list_data)
8541 }
8542
8543 fn make_fixed_size_list_array_for_large_list() -> FixedSizeListArray {
8544 let value_data = ArrayData::builder(DataType::Int64)
8546 .len(8)
8547 .add_buffer(Buffer::from_slice_ref([0i64, 1, 2, 3, 4, 5, 6, 7]))
8548 .build()
8549 .unwrap();
8550
8551 let list_data_type =
8552 DataType::FixedSizeList(Arc::new(Field::new_list_field(DataType::Int64, true)), 4);
8553 let list_data = ArrayData::builder(list_data_type)
8554 .len(2)
8555 .add_child_data(value_data)
8556 .build()
8557 .unwrap();
8558 FixedSizeListArray::from(list_data)
8559 }
8560
8561 #[test]
8562 fn test_cast_map_dont_allow_change_of_order() {
8563 let string_builder = StringBuilder::new();
8564 let value_builder = StringBuilder::new();
8565 let mut builder = MapBuilder::new(
8566 Some(MapFieldNames {
8567 entry: "entries".to_string(),
8568 key: "key".to_string(),
8569 value: "value".to_string(),
8570 }),
8571 string_builder,
8572 value_builder,
8573 );
8574
8575 builder.keys().append_value("0");
8576 builder.values().append_value("test_val_1");
8577 builder.append(true).unwrap();
8578 builder.keys().append_value("1");
8579 builder.values().append_value("test_val_2");
8580 builder.append(true).unwrap();
8581
8582 let array = builder.finish();
8584
8585 let new_ordered = true;
8586 let new_type = DataType::Map(
8587 Arc::new(Field::new(
8588 "entries",
8589 DataType::Struct(
8590 vec![
8591 Field::new("key", DataType::Utf8, false),
8592 Field::new("value", DataType::Utf8, false),
8593 ]
8594 .into(),
8595 ),
8596 false,
8597 )),
8598 new_ordered,
8599 );
8600
8601 let new_array_result = cast(&array, &new_type.clone());
8602 assert!(!can_cast_types(array.data_type(), &new_type));
8603 assert!(
8604 matches!(new_array_result, Err(ArrowError::CastError(t)) if t == r#"Casting from Map(Field { name: "entries", data_type: Struct([Field { name: "key", data_type: Utf8, nullable: false, dict_id: 0, dict_is_ordered: false, metadata: {} }, Field { name: "value", data_type: Utf8, nullable: true, dict_id: 0, dict_is_ordered: false, metadata: {} }]), nullable: false, dict_id: 0, dict_is_ordered: false, metadata: {} }, false) to Map(Field { name: "entries", data_type: Struct([Field { name: "key", data_type: Utf8, nullable: false, dict_id: 0, dict_is_ordered: false, metadata: {} }, Field { name: "value", data_type: Utf8, nullable: false, dict_id: 0, dict_is_ordered: false, metadata: {} }]), nullable: false, dict_id: 0, dict_is_ordered: false, metadata: {} }, true) not supported"#)
8605 );
8606 }
8607
8608 #[test]
8609 fn test_cast_map_dont_allow_when_container_cant_cast() {
8610 let string_builder = StringBuilder::new();
8611 let value_builder = IntervalDayTimeArray::builder(2);
8612 let mut builder = MapBuilder::new(
8613 Some(MapFieldNames {
8614 entry: "entries".to_string(),
8615 key: "key".to_string(),
8616 value: "value".to_string(),
8617 }),
8618 string_builder,
8619 value_builder,
8620 );
8621
8622 builder.keys().append_value("0");
8623 builder.values().append_value(IntervalDayTime::new(1, 1));
8624 builder.append(true).unwrap();
8625 builder.keys().append_value("1");
8626 builder.values().append_value(IntervalDayTime::new(2, 2));
8627 builder.append(true).unwrap();
8628
8629 let array = builder.finish();
8631
8632 let new_ordered = true;
8633 let new_type = DataType::Map(
8634 Arc::new(Field::new(
8635 "entries",
8636 DataType::Struct(
8637 vec![
8638 Field::new("key", DataType::Utf8, false),
8639 Field::new("value", DataType::Duration(TimeUnit::Second), false),
8640 ]
8641 .into(),
8642 ),
8643 false,
8644 )),
8645 new_ordered,
8646 );
8647
8648 let new_array_result = cast(&array, &new_type.clone());
8649 assert!(!can_cast_types(array.data_type(), &new_type));
8650 assert!(
8651 matches!(new_array_result, Err(ArrowError::CastError(t)) if t == r#"Casting from Map(Field { name: "entries", data_type: Struct([Field { name: "key", data_type: Utf8, nullable: false, dict_id: 0, dict_is_ordered: false, metadata: {} }, Field { name: "value", data_type: Interval(DayTime), nullable: true, dict_id: 0, dict_is_ordered: false, metadata: {} }]), nullable: false, dict_id: 0, dict_is_ordered: false, metadata: {} }, false) to Map(Field { name: "entries", data_type: Struct([Field { name: "key", data_type: Utf8, nullable: false, dict_id: 0, dict_is_ordered: false, metadata: {} }, Field { name: "value", data_type: Duration(Second), nullable: false, dict_id: 0, dict_is_ordered: false, metadata: {} }]), nullable: false, dict_id: 0, dict_is_ordered: false, metadata: {} }, true) not supported"#)
8652 );
8653 }
8654
8655 #[test]
8656 fn test_cast_map_field_names() {
8657 let string_builder = StringBuilder::new();
8658 let value_builder = StringBuilder::new();
8659 let mut builder = MapBuilder::new(
8660 Some(MapFieldNames {
8661 entry: "entries".to_string(),
8662 key: "key".to_string(),
8663 value: "value".to_string(),
8664 }),
8665 string_builder,
8666 value_builder,
8667 );
8668
8669 builder.keys().append_value("0");
8670 builder.values().append_value("test_val_1");
8671 builder.append(true).unwrap();
8672 builder.keys().append_value("1");
8673 builder.values().append_value("test_val_2");
8674 builder.append(true).unwrap();
8675 builder.append(false).unwrap();
8676
8677 let array = builder.finish();
8678
8679 let new_type = DataType::Map(
8680 Arc::new(Field::new(
8681 "entries_new",
8682 DataType::Struct(
8683 vec![
8684 Field::new("key_new", DataType::Utf8, false),
8685 Field::new("value_values", DataType::Utf8, false),
8686 ]
8687 .into(),
8688 ),
8689 false,
8690 )),
8691 false,
8692 );
8693
8694 assert_ne!(new_type, array.data_type().clone());
8695
8696 let new_array = cast(&array, &new_type.clone()).unwrap();
8697 assert_eq!(new_type, new_array.data_type().clone());
8698 let map_array = new_array.as_map();
8699
8700 assert_ne!(new_type, array.data_type().clone());
8701 assert_eq!(new_type, map_array.data_type().clone());
8702
8703 let key_string = map_array
8704 .keys()
8705 .as_any()
8706 .downcast_ref::<StringArray>()
8707 .unwrap()
8708 .into_iter()
8709 .flatten()
8710 .collect::<Vec<_>>();
8711 assert_eq!(&key_string, &vec!["0", "1"]);
8712
8713 let values_string_array = cast(map_array.values(), &DataType::Utf8).unwrap();
8714 let values_string = values_string_array
8715 .as_any()
8716 .downcast_ref::<StringArray>()
8717 .unwrap()
8718 .into_iter()
8719 .flatten()
8720 .collect::<Vec<_>>();
8721 assert_eq!(&values_string, &vec!["test_val_1", "test_val_2"]);
8722
8723 assert_eq!(
8724 map_array.nulls(),
8725 Some(&NullBuffer::from(vec![true, true, false]))
8726 );
8727 }
8728
8729 #[test]
8730 fn test_cast_map_contained_values() {
8731 let string_builder = StringBuilder::new();
8732 let value_builder = Int8Builder::new();
8733 let mut builder = MapBuilder::new(
8734 Some(MapFieldNames {
8735 entry: "entries".to_string(),
8736 key: "key".to_string(),
8737 value: "value".to_string(),
8738 }),
8739 string_builder,
8740 value_builder,
8741 );
8742
8743 builder.keys().append_value("0");
8744 builder.values().append_value(44);
8745 builder.append(true).unwrap();
8746 builder.keys().append_value("1");
8747 builder.values().append_value(22);
8748 builder.append(true).unwrap();
8749
8750 let array = builder.finish();
8751
8752 let new_type = DataType::Map(
8753 Arc::new(Field::new(
8754 "entries",
8755 DataType::Struct(
8756 vec![
8757 Field::new("key", DataType::Utf8, false),
8758 Field::new("value", DataType::Utf8, false),
8759 ]
8760 .into(),
8761 ),
8762 false,
8763 )),
8764 false,
8765 );
8766
8767 let new_array = cast(&array, &new_type.clone()).unwrap();
8768 assert_eq!(new_type, new_array.data_type().clone());
8769 let map_array = new_array.as_map();
8770
8771 assert_ne!(new_type, array.data_type().clone());
8772 assert_eq!(new_type, map_array.data_type().clone());
8773
8774 let key_string = map_array
8775 .keys()
8776 .as_any()
8777 .downcast_ref::<StringArray>()
8778 .unwrap()
8779 .into_iter()
8780 .flatten()
8781 .collect::<Vec<_>>();
8782 assert_eq!(&key_string, &vec!["0", "1"]);
8783
8784 let values_string_array = cast(map_array.values(), &DataType::Utf8).unwrap();
8785 let values_string = values_string_array
8786 .as_any()
8787 .downcast_ref::<StringArray>()
8788 .unwrap()
8789 .into_iter()
8790 .flatten()
8791 .collect::<Vec<_>>();
8792 assert_eq!(&values_string, &vec!["44", "22"]);
8793 }
8794
8795 #[test]
8796 fn test_utf8_cast_offsets() {
8797 let str_array = StringArray::from(vec!["a", "b", "c"]);
8799 let str_array = str_array.slice(1, 2);
8800
8801 let out = cast(&str_array, &DataType::LargeUtf8).unwrap();
8802
8803 let large_str_array = out.as_any().downcast_ref::<LargeStringArray>().unwrap();
8804 let strs = large_str_array.into_iter().flatten().collect::<Vec<_>>();
8805 assert_eq!(strs, &["b", "c"])
8806 }
8807
8808 #[test]
8809 fn test_list_cast_offsets() {
8810 let array1 = make_list_array().slice(1, 2);
8812 let array2 = Arc::new(make_list_array()) as ArrayRef;
8813
8814 let dt = DataType::LargeList(Arc::new(Field::new_list_field(DataType::Int32, true)));
8815 let out1 = cast(&array1, &dt).unwrap();
8816 let out2 = cast(&array2, &dt).unwrap();
8817
8818 assert_eq!(&out1, &out2.slice(1, 2))
8819 }
8820
8821 #[test]
8822 fn test_list_to_string() {
8823 let str_array = StringArray::from(vec!["a", "b", "c", "d", "e", "f", "g", "h"]);
8824 let value_offsets = Buffer::from_slice_ref([0, 3, 6, 8]);
8825 let value_data = str_array.into_data();
8826
8827 let list_data_type = DataType::List(Arc::new(Field::new_list_field(DataType::Utf8, true)));
8828 let list_data = ArrayData::builder(list_data_type)
8829 .len(3)
8830 .add_buffer(value_offsets)
8831 .add_child_data(value_data)
8832 .build()
8833 .unwrap();
8834 let array = Arc::new(ListArray::from(list_data)) as ArrayRef;
8835
8836 let out = cast(&array, &DataType::Utf8).unwrap();
8837 let out = out
8838 .as_any()
8839 .downcast_ref::<StringArray>()
8840 .unwrap()
8841 .into_iter()
8842 .flatten()
8843 .collect::<Vec<_>>();
8844 assert_eq!(&out, &vec!["[a, b, c]", "[d, e, f]", "[g, h]"]);
8845
8846 let out = cast(&array, &DataType::LargeUtf8).unwrap();
8847 let out = out
8848 .as_any()
8849 .downcast_ref::<LargeStringArray>()
8850 .unwrap()
8851 .into_iter()
8852 .flatten()
8853 .collect::<Vec<_>>();
8854 assert_eq!(&out, &vec!["[a, b, c]", "[d, e, f]", "[g, h]"]);
8855
8856 let array = Arc::new(make_list_array()) as ArrayRef;
8857 let out = cast(&array, &DataType::Utf8).unwrap();
8858 let out = out
8859 .as_any()
8860 .downcast_ref::<StringArray>()
8861 .unwrap()
8862 .into_iter()
8863 .flatten()
8864 .collect::<Vec<_>>();
8865 assert_eq!(&out, &vec!["[0, 1, 2]", "[3, 4, 5]", "[6, 7]"]);
8866
8867 let array = Arc::new(make_large_list_array()) as ArrayRef;
8868 let out = cast(&array, &DataType::LargeUtf8).unwrap();
8869 let out = out
8870 .as_any()
8871 .downcast_ref::<LargeStringArray>()
8872 .unwrap()
8873 .into_iter()
8874 .flatten()
8875 .collect::<Vec<_>>();
8876 assert_eq!(&out, &vec!["[0, 1, 2]", "[3, 4, 5]", "[6, 7]"]);
8877 }
8878
8879 #[test]
8880 fn test_cast_f64_to_decimal128() {
8881 let decimal_type = DataType::Decimal128(18, 2);
8884 let array = Float64Array::from(vec![
8885 Some(0.0699999999),
8886 Some(0.0659999999),
8887 Some(0.0650000000),
8888 Some(0.0649999999),
8889 ]);
8890 let array = Arc::new(array) as ArrayRef;
8891 generate_cast_test_case!(
8892 &array,
8893 Decimal128Array,
8894 &decimal_type,
8895 vec![
8896 Some(7_i128), Some(7_i128), Some(7_i128), Some(6_i128), ]
8901 );
8902
8903 let decimal_type = DataType::Decimal128(18, 3);
8904 let array = Float64Array::from(vec![
8905 Some(0.0699999999),
8906 Some(0.0659999999),
8907 Some(0.0650000000),
8908 Some(0.0649999999),
8909 ]);
8910 let array = Arc::new(array) as ArrayRef;
8911 generate_cast_test_case!(
8912 &array,
8913 Decimal128Array,
8914 &decimal_type,
8915 vec![
8916 Some(70_i128), Some(66_i128), Some(65_i128), Some(65_i128), ]
8921 );
8922 }
8923
8924 #[test]
8925 fn test_cast_numeric_to_decimal128_overflow() {
8926 let array = Int64Array::from(vec![i64::MAX]);
8927 let array = Arc::new(array) as ArrayRef;
8928 let casted_array = cast_with_options(
8929 &array,
8930 &DataType::Decimal128(38, 30),
8931 &CastOptions {
8932 safe: true,
8933 format_options: FormatOptions::default(),
8934 },
8935 );
8936 assert!(casted_array.is_ok());
8937 assert!(casted_array.unwrap().is_null(0));
8938
8939 let casted_array = cast_with_options(
8940 &array,
8941 &DataType::Decimal128(38, 30),
8942 &CastOptions {
8943 safe: false,
8944 format_options: FormatOptions::default(),
8945 },
8946 );
8947 assert!(casted_array.is_err());
8948 }
8949
8950 #[test]
8951 fn test_cast_numeric_to_decimal256_overflow() {
8952 let array = Int64Array::from(vec![i64::MAX]);
8953 let array = Arc::new(array) as ArrayRef;
8954 let casted_array = cast_with_options(
8955 &array,
8956 &DataType::Decimal256(76, 76),
8957 &CastOptions {
8958 safe: true,
8959 format_options: FormatOptions::default(),
8960 },
8961 );
8962 assert!(casted_array.is_ok());
8963 assert!(casted_array.unwrap().is_null(0));
8964
8965 let casted_array = cast_with_options(
8966 &array,
8967 &DataType::Decimal256(76, 76),
8968 &CastOptions {
8969 safe: false,
8970 format_options: FormatOptions::default(),
8971 },
8972 );
8973 assert!(casted_array.is_err());
8974 }
8975
8976 #[test]
8977 fn test_cast_floating_point_to_decimal128_precision_overflow() {
8978 let array = Float64Array::from(vec![1.1]);
8979 let array = Arc::new(array) as ArrayRef;
8980 let casted_array = cast_with_options(
8981 &array,
8982 &DataType::Decimal128(2, 2),
8983 &CastOptions {
8984 safe: true,
8985 format_options: FormatOptions::default(),
8986 },
8987 );
8988 assert!(casted_array.is_ok());
8989 assert!(casted_array.unwrap().is_null(0));
8990
8991 let casted_array = cast_with_options(
8992 &array,
8993 &DataType::Decimal128(2, 2),
8994 &CastOptions {
8995 safe: false,
8996 format_options: FormatOptions::default(),
8997 },
8998 );
8999 let err = casted_array.unwrap_err().to_string();
9000 let expected_error = "Invalid argument error: 110 is too large to store in a Decimal128 of precision 2. Max is 99";
9001 assert!(
9002 err.contains(expected_error),
9003 "did not find expected error '{expected_error}' in actual error '{err}'"
9004 );
9005 }
9006
9007 #[test]
9008 fn test_cast_floating_point_to_decimal256_precision_overflow() {
9009 let array = Float64Array::from(vec![1.1]);
9010 let array = Arc::new(array) as ArrayRef;
9011 let casted_array = cast_with_options(
9012 &array,
9013 &DataType::Decimal256(2, 2),
9014 &CastOptions {
9015 safe: true,
9016 format_options: FormatOptions::default(),
9017 },
9018 );
9019 assert!(casted_array.is_ok());
9020 assert!(casted_array.unwrap().is_null(0));
9021
9022 let casted_array = cast_with_options(
9023 &array,
9024 &DataType::Decimal256(2, 2),
9025 &CastOptions {
9026 safe: false,
9027 format_options: FormatOptions::default(),
9028 },
9029 );
9030 let err = casted_array.unwrap_err().to_string();
9031 let expected_error = "Invalid argument error: 110 is too large to store in a Decimal256 of precision 2. Max is 99";
9032 assert!(
9033 err.contains(expected_error),
9034 "did not find expected error '{expected_error}' in actual error '{err}'"
9035 );
9036 }
9037
9038 #[test]
9039 fn test_cast_floating_point_to_decimal128_overflow() {
9040 let array = Float64Array::from(vec![f64::MAX]);
9041 let array = Arc::new(array) as ArrayRef;
9042 let casted_array = cast_with_options(
9043 &array,
9044 &DataType::Decimal128(38, 30),
9045 &CastOptions {
9046 safe: true,
9047 format_options: FormatOptions::default(),
9048 },
9049 );
9050 assert!(casted_array.is_ok());
9051 assert!(casted_array.unwrap().is_null(0));
9052
9053 let casted_array = cast_with_options(
9054 &array,
9055 &DataType::Decimal128(38, 30),
9056 &CastOptions {
9057 safe: false,
9058 format_options: FormatOptions::default(),
9059 },
9060 );
9061 let err = casted_array.unwrap_err().to_string();
9062 let expected_error = "Cast error: Cannot cast to Decimal128(38, 30)";
9063 assert!(
9064 err.contains(expected_error),
9065 "did not find expected error '{expected_error}' in actual error '{err}'"
9066 );
9067 }
9068
9069 #[test]
9070 fn test_cast_floating_point_to_decimal256_overflow() {
9071 let array = Float64Array::from(vec![f64::MAX]);
9072 let array = Arc::new(array) as ArrayRef;
9073 let casted_array = cast_with_options(
9074 &array,
9075 &DataType::Decimal256(76, 50),
9076 &CastOptions {
9077 safe: true,
9078 format_options: FormatOptions::default(),
9079 },
9080 );
9081 assert!(casted_array.is_ok());
9082 assert!(casted_array.unwrap().is_null(0));
9083
9084 let casted_array = cast_with_options(
9085 &array,
9086 &DataType::Decimal256(76, 50),
9087 &CastOptions {
9088 safe: false,
9089 format_options: FormatOptions::default(),
9090 },
9091 );
9092 let err = casted_array.unwrap_err().to_string();
9093 let expected_error = "Cast error: Cannot cast to Decimal256(76, 50)";
9094 assert!(
9095 err.contains(expected_error),
9096 "did not find expected error '{expected_error}' in actual error '{err}'"
9097 );
9098 }
9099 #[test]
9100 fn test_cast_decimal256_to_f64_no_overflow() {
9101 let array = vec![Some(i256::MAX)];
9103 let array = create_decimal256_array(array, 76, 2).unwrap();
9104 let array = Arc::new(array) as ArrayRef;
9105
9106 let result = cast(&array, &DataType::Float64).unwrap();
9107 let result = result.as_primitive::<Float64Type>();
9108 assert!(result.value(0).is_finite());
9109 assert!(result.value(0) > 0.0); let array = vec![Some(i256::MIN)];
9113 let array = create_decimal256_array(array, 76, 2).unwrap();
9114 let array = Arc::new(array) as ArrayRef;
9115
9116 let result = cast(&array, &DataType::Float64).unwrap();
9117 let result = result.as_primitive::<Float64Type>();
9118 assert!(result.value(0).is_finite());
9119 assert!(result.value(0) < 0.0); }
9121
9122 #[test]
9123 fn test_cast_decimal128_to_decimal128_negative_scale() {
9124 let input_type = DataType::Decimal128(20, 0);
9125 let output_type = DataType::Decimal128(20, -1);
9126 assert!(can_cast_types(&input_type, &output_type));
9127 let array = vec![Some(1123450), Some(2123455), Some(3123456), None];
9128 let input_decimal_array = create_decimal128_array(array, 20, 0).unwrap();
9129 let array = Arc::new(input_decimal_array) as ArrayRef;
9130 generate_cast_test_case!(
9131 &array,
9132 Decimal128Array,
9133 &output_type,
9134 vec![
9135 Some(112345_i128),
9136 Some(212346_i128),
9137 Some(312346_i128),
9138 None
9139 ]
9140 );
9141
9142 let casted_array = cast(&array, &output_type).unwrap();
9143 let decimal_arr = casted_array.as_primitive::<Decimal128Type>();
9144
9145 assert_eq!("1123450", decimal_arr.value_as_string(0));
9146 assert_eq!("2123460", decimal_arr.value_as_string(1));
9147 assert_eq!("3123460", decimal_arr.value_as_string(2));
9148 }
9149
9150 #[test]
9151 fn decimal128_min_max_to_f64() {
9152 let min128 = i128::MIN;
9154 let max128 = i128::MAX;
9155 assert_eq!(min128 as f64, min128 as f64);
9156 assert_eq!(max128 as f64, max128 as f64);
9157 }
9158
9159 #[test]
9160 fn test_cast_numeric_to_decimal128_negative() {
9161 let decimal_type = DataType::Decimal128(38, -1);
9162 let array = Arc::new(Int32Array::from(vec![
9163 Some(1123456),
9164 Some(2123456),
9165 Some(3123456),
9166 ])) as ArrayRef;
9167
9168 let casted_array = cast(&array, &decimal_type).unwrap();
9169 let decimal_arr = casted_array.as_primitive::<Decimal128Type>();
9170
9171 assert_eq!("1123450", decimal_arr.value_as_string(0));
9172 assert_eq!("2123450", decimal_arr.value_as_string(1));
9173 assert_eq!("3123450", decimal_arr.value_as_string(2));
9174
9175 let array = Arc::new(Float32Array::from(vec![
9176 Some(1123.456),
9177 Some(2123.456),
9178 Some(3123.456),
9179 ])) as ArrayRef;
9180
9181 let casted_array = cast(&array, &decimal_type).unwrap();
9182 let decimal_arr = casted_array.as_primitive::<Decimal128Type>();
9183
9184 assert_eq!("1120", decimal_arr.value_as_string(0));
9185 assert_eq!("2120", decimal_arr.value_as_string(1));
9186 assert_eq!("3120", decimal_arr.value_as_string(2));
9187 }
9188
9189 #[test]
9190 fn test_cast_decimal128_to_decimal128_negative() {
9191 let input_type = DataType::Decimal128(10, -1);
9192 let output_type = DataType::Decimal128(10, -2);
9193 assert!(can_cast_types(&input_type, &output_type));
9194 let array = vec![Some(123)];
9195 let input_decimal_array = create_decimal128_array(array, 10, -1).unwrap();
9196 let array = Arc::new(input_decimal_array) as ArrayRef;
9197 generate_cast_test_case!(&array, Decimal128Array, &output_type, vec![Some(12_i128),]);
9198
9199 let casted_array = cast(&array, &output_type).unwrap();
9200 let decimal_arr = casted_array.as_primitive::<Decimal128Type>();
9201
9202 assert_eq!("1200", decimal_arr.value_as_string(0));
9203
9204 let array = vec![Some(125)];
9205 let input_decimal_array = create_decimal128_array(array, 10, -1).unwrap();
9206 let array = Arc::new(input_decimal_array) as ArrayRef;
9207 generate_cast_test_case!(&array, Decimal128Array, &output_type, vec![Some(13_i128),]);
9208
9209 let casted_array = cast(&array, &output_type).unwrap();
9210 let decimal_arr = casted_array.as_primitive::<Decimal128Type>();
9211
9212 assert_eq!("1300", decimal_arr.value_as_string(0));
9213 }
9214
9215 #[test]
9216 fn test_cast_decimal128_to_decimal256_negative() {
9217 let input_type = DataType::Decimal128(10, 3);
9218 let output_type = DataType::Decimal256(10, 5);
9219 assert!(can_cast_types(&input_type, &output_type));
9220 let array = vec![Some(123456), Some(-123456)];
9221 let input_decimal_array = create_decimal128_array(array, 10, 3).unwrap();
9222 let array = Arc::new(input_decimal_array) as ArrayRef;
9223
9224 let hundred = i256::from_i128(100);
9225 generate_cast_test_case!(
9226 &array,
9227 Decimal256Array,
9228 &output_type,
9229 vec![
9230 Some(i256::from_i128(123456).mul_wrapping(hundred)),
9231 Some(i256::from_i128(-123456).mul_wrapping(hundred))
9232 ]
9233 );
9234 }
9235
9236 #[test]
9237 fn test_parse_string_to_decimal() {
9238 assert_eq!(
9239 Decimal128Type::format_decimal(
9240 parse_string_to_decimal_native::<Decimal128Type>("123.45", 2).unwrap(),
9241 38,
9242 2,
9243 ),
9244 "123.45"
9245 );
9246 assert_eq!(
9247 Decimal128Type::format_decimal(
9248 parse_string_to_decimal_native::<Decimal128Type>("12345", 2).unwrap(),
9249 38,
9250 2,
9251 ),
9252 "12345.00"
9253 );
9254 assert_eq!(
9255 Decimal128Type::format_decimal(
9256 parse_string_to_decimal_native::<Decimal128Type>("0.12345", 2).unwrap(),
9257 38,
9258 2,
9259 ),
9260 "0.12"
9261 );
9262 assert_eq!(
9263 Decimal128Type::format_decimal(
9264 parse_string_to_decimal_native::<Decimal128Type>(".12345", 2).unwrap(),
9265 38,
9266 2,
9267 ),
9268 "0.12"
9269 );
9270 assert_eq!(
9271 Decimal128Type::format_decimal(
9272 parse_string_to_decimal_native::<Decimal128Type>(".1265", 2).unwrap(),
9273 38,
9274 2,
9275 ),
9276 "0.13"
9277 );
9278 assert_eq!(
9279 Decimal128Type::format_decimal(
9280 parse_string_to_decimal_native::<Decimal128Type>(".1265", 2).unwrap(),
9281 38,
9282 2,
9283 ),
9284 "0.13"
9285 );
9286
9287 assert_eq!(
9288 Decimal256Type::format_decimal(
9289 parse_string_to_decimal_native::<Decimal256Type>("123.45", 3).unwrap(),
9290 38,
9291 3,
9292 ),
9293 "123.450"
9294 );
9295 assert_eq!(
9296 Decimal256Type::format_decimal(
9297 parse_string_to_decimal_native::<Decimal256Type>("12345", 3).unwrap(),
9298 38,
9299 3,
9300 ),
9301 "12345.000"
9302 );
9303 assert_eq!(
9304 Decimal256Type::format_decimal(
9305 parse_string_to_decimal_native::<Decimal256Type>("0.12345", 3).unwrap(),
9306 38,
9307 3,
9308 ),
9309 "0.123"
9310 );
9311 assert_eq!(
9312 Decimal256Type::format_decimal(
9313 parse_string_to_decimal_native::<Decimal256Type>(".12345", 3).unwrap(),
9314 38,
9315 3,
9316 ),
9317 "0.123"
9318 );
9319 assert_eq!(
9320 Decimal256Type::format_decimal(
9321 parse_string_to_decimal_native::<Decimal256Type>(".1265", 3).unwrap(),
9322 38,
9323 3,
9324 ),
9325 "0.127"
9326 );
9327 }
9328
9329 fn test_cast_string_to_decimal(array: ArrayRef) {
9330 let output_type = DataType::Decimal128(38, 2);
9332 assert!(can_cast_types(array.data_type(), &output_type));
9333
9334 let casted_array = cast(&array, &output_type).unwrap();
9335 let decimal_arr = casted_array.as_primitive::<Decimal128Type>();
9336
9337 assert_eq!("123.45", decimal_arr.value_as_string(0));
9338 assert_eq!("1.23", decimal_arr.value_as_string(1));
9339 assert_eq!("0.12", decimal_arr.value_as_string(2));
9340 assert_eq!("0.13", decimal_arr.value_as_string(3));
9341 assert_eq!("1.26", decimal_arr.value_as_string(4));
9342 assert_eq!("12345.00", decimal_arr.value_as_string(5));
9343 assert_eq!("12345.00", decimal_arr.value_as_string(6));
9344 assert_eq!("0.12", decimal_arr.value_as_string(7));
9345 assert_eq!("12.23", decimal_arr.value_as_string(8));
9346 assert!(decimal_arr.is_null(9));
9347 assert_eq!("0.00", decimal_arr.value_as_string(10));
9348 assert_eq!("0.00", decimal_arr.value_as_string(11));
9349 assert!(decimal_arr.is_null(12));
9350 assert_eq!("-1.23", decimal_arr.value_as_string(13));
9351 assert_eq!("-1.24", decimal_arr.value_as_string(14));
9352 assert_eq!("0.00", decimal_arr.value_as_string(15));
9353 assert_eq!("-123.00", decimal_arr.value_as_string(16));
9354 assert_eq!("-123.23", decimal_arr.value_as_string(17));
9355 assert_eq!("-0.12", decimal_arr.value_as_string(18));
9356 assert_eq!("1.23", decimal_arr.value_as_string(19));
9357 assert_eq!("1.24", decimal_arr.value_as_string(20));
9358 assert_eq!("0.00", decimal_arr.value_as_string(21));
9359 assert_eq!("123.00", decimal_arr.value_as_string(22));
9360 assert_eq!("123.23", decimal_arr.value_as_string(23));
9361 assert_eq!("0.12", decimal_arr.value_as_string(24));
9362 assert!(decimal_arr.is_null(25));
9363 assert!(decimal_arr.is_null(26));
9364 assert!(decimal_arr.is_null(27));
9365 assert_eq!("0.00", decimal_arr.value_as_string(28));
9366 assert_eq!("0.00", decimal_arr.value_as_string(29));
9367 assert_eq!("12345.00", decimal_arr.value_as_string(30));
9368 assert_eq!(decimal_arr.len(), 31);
9369
9370 let output_type = DataType::Decimal256(76, 3);
9372 assert!(can_cast_types(array.data_type(), &output_type));
9373
9374 let casted_array = cast(&array, &output_type).unwrap();
9375 let decimal_arr = casted_array.as_primitive::<Decimal256Type>();
9376
9377 assert_eq!("123.450", decimal_arr.value_as_string(0));
9378 assert_eq!("1.235", decimal_arr.value_as_string(1));
9379 assert_eq!("0.123", decimal_arr.value_as_string(2));
9380 assert_eq!("0.127", decimal_arr.value_as_string(3));
9381 assert_eq!("1.263", decimal_arr.value_as_string(4));
9382 assert_eq!("12345.000", decimal_arr.value_as_string(5));
9383 assert_eq!("12345.000", decimal_arr.value_as_string(6));
9384 assert_eq!("0.123", decimal_arr.value_as_string(7));
9385 assert_eq!("12.234", decimal_arr.value_as_string(8));
9386 assert!(decimal_arr.is_null(9));
9387 assert_eq!("0.000", decimal_arr.value_as_string(10));
9388 assert_eq!("0.000", decimal_arr.value_as_string(11));
9389 assert!(decimal_arr.is_null(12));
9390 assert_eq!("-1.235", decimal_arr.value_as_string(13));
9391 assert_eq!("-1.236", decimal_arr.value_as_string(14));
9392 assert_eq!("0.000", decimal_arr.value_as_string(15));
9393 assert_eq!("-123.000", decimal_arr.value_as_string(16));
9394 assert_eq!("-123.234", decimal_arr.value_as_string(17));
9395 assert_eq!("-0.123", decimal_arr.value_as_string(18));
9396 assert_eq!("1.235", decimal_arr.value_as_string(19));
9397 assert_eq!("1.236", decimal_arr.value_as_string(20));
9398 assert_eq!("0.000", decimal_arr.value_as_string(21));
9399 assert_eq!("123.000", decimal_arr.value_as_string(22));
9400 assert_eq!("123.234", decimal_arr.value_as_string(23));
9401 assert_eq!("0.123", decimal_arr.value_as_string(24));
9402 assert!(decimal_arr.is_null(25));
9403 assert!(decimal_arr.is_null(26));
9404 assert!(decimal_arr.is_null(27));
9405 assert_eq!("0.000", decimal_arr.value_as_string(28));
9406 assert_eq!("0.000", decimal_arr.value_as_string(29));
9407 assert_eq!("12345.000", decimal_arr.value_as_string(30));
9408 assert_eq!(decimal_arr.len(), 31);
9409 }
9410
9411 #[test]
9412 fn test_cast_utf8_to_decimal() {
9413 let str_array = StringArray::from(vec![
9414 Some("123.45"),
9415 Some("1.2345"),
9416 Some("0.12345"),
9417 Some("0.1267"),
9418 Some("1.263"),
9419 Some("12345.0"),
9420 Some("12345"),
9421 Some("000.123"),
9422 Some("12.234000"),
9423 None,
9424 Some(""),
9425 Some(" "),
9426 None,
9427 Some("-1.23499999"),
9428 Some("-1.23599999"),
9429 Some("-0.00001"),
9430 Some("-123"),
9431 Some("-123.234000"),
9432 Some("-000.123"),
9433 Some("+1.23499999"),
9434 Some("+1.23599999"),
9435 Some("+0.00001"),
9436 Some("+123"),
9437 Some("+123.234000"),
9438 Some("+000.123"),
9439 Some("1.-23499999"),
9440 Some("-1.-23499999"),
9441 Some("--1.23499999"),
9442 Some("0"),
9443 Some("000.000"),
9444 Some("0000000000000000012345.000"),
9445 ]);
9446 let array = Arc::new(str_array) as ArrayRef;
9447
9448 test_cast_string_to_decimal(array);
9449
9450 let test_cases = [
9451 (None, None),
9452 (Some("0"), Some("0")),
9455 (Some("000.000"), Some("0")),
9456 (Some("12345"), Some("12345")),
9457 (Some("000000000000000000000000000012345"), Some("12345")),
9458 (Some("-123"), Some("-123")),
9459 (Some("+123"), Some("123")),
9460 ];
9461 let inputs = test_cases.iter().map(|entry| entry.0).collect::<Vec<_>>();
9462 let expected = test_cases.iter().map(|entry| entry.1).collect::<Vec<_>>();
9463
9464 let array = Arc::new(StringArray::from(inputs)) as ArrayRef;
9465 test_cast_string_to_decimal_scale_zero(array, &expected);
9466 }
9467
9468 #[test]
9469 fn test_cast_large_utf8_to_decimal() {
9470 let str_array = LargeStringArray::from(vec![
9471 Some("123.45"),
9472 Some("1.2345"),
9473 Some("0.12345"),
9474 Some("0.1267"),
9475 Some("1.263"),
9476 Some("12345.0"),
9477 Some("12345"),
9478 Some("000.123"),
9479 Some("12.234000"),
9480 None,
9481 Some(""),
9482 Some(" "),
9483 None,
9484 Some("-1.23499999"),
9485 Some("-1.23599999"),
9486 Some("-0.00001"),
9487 Some("-123"),
9488 Some("-123.234000"),
9489 Some("-000.123"),
9490 Some("+1.23499999"),
9491 Some("+1.23599999"),
9492 Some("+0.00001"),
9493 Some("+123"),
9494 Some("+123.234000"),
9495 Some("+000.123"),
9496 Some("1.-23499999"),
9497 Some("-1.-23499999"),
9498 Some("--1.23499999"),
9499 Some("0"),
9500 Some("000.000"),
9501 Some("0000000000000000012345.000"),
9502 ]);
9503 let array = Arc::new(str_array) as ArrayRef;
9504
9505 test_cast_string_to_decimal(array);
9506
9507 let test_cases = [
9508 (None, None),
9509 (Some(""), None),
9510 (Some(" "), None),
9511 (Some("0"), Some("0")),
9512 (Some("000.000"), Some("0")),
9513 (Some("12345"), Some("12345")),
9514 (Some("000000000000000000000000000012345"), Some("12345")),
9515 (Some("-123"), Some("-123")),
9516 (Some("+123"), Some("123")),
9517 ];
9518 let inputs = test_cases.iter().map(|entry| entry.0).collect::<Vec<_>>();
9519 let expected = test_cases.iter().map(|entry| entry.1).collect::<Vec<_>>();
9520
9521 let array = Arc::new(LargeStringArray::from(inputs)) as ArrayRef;
9522 test_cast_string_to_decimal_scale_zero(array, &expected);
9523 }
9524
9525 fn test_cast_string_to_decimal_scale_zero(
9526 array: ArrayRef,
9527 expected_as_string: &[Option<&str>],
9528 ) {
9529 let output_type = DataType::Decimal128(38, 0);
9531 assert!(can_cast_types(array.data_type(), &output_type));
9532 let casted_array = cast(&array, &output_type).unwrap();
9533 let decimal_arr = casted_array.as_primitive::<Decimal128Type>();
9534 assert_decimal_array_contents(decimal_arr, expected_as_string);
9535
9536 let output_type = DataType::Decimal256(76, 0);
9538 assert!(can_cast_types(array.data_type(), &output_type));
9539 let casted_array = cast(&array, &output_type).unwrap();
9540 let decimal_arr = casted_array.as_primitive::<Decimal256Type>();
9541 assert_decimal_array_contents(decimal_arr, expected_as_string);
9542 }
9543
9544 fn assert_decimal_array_contents<T>(
9545 array: &PrimitiveArray<T>,
9546 expected_as_string: &[Option<&str>],
9547 ) where
9548 T: DecimalType + ArrowPrimitiveType,
9549 {
9550 assert_eq!(array.len(), expected_as_string.len());
9551 for (i, expected) in expected_as_string.iter().enumerate() {
9552 let actual = if array.is_null(i) {
9553 None
9554 } else {
9555 Some(array.value_as_string(i))
9556 };
9557 let actual = actual.as_ref().map(|s| s.as_ref());
9558 assert_eq!(*expected, actual, "Expected at position {i}");
9559 }
9560 }
9561
9562 #[test]
9563 fn test_cast_invalid_utf8_to_decimal() {
9564 let str_array = StringArray::from(vec!["4.4.5", ". 0.123"]);
9565 let array = Arc::new(str_array) as ArrayRef;
9566
9567 let output_type = DataType::Decimal128(38, 2);
9569 let casted_array = cast(&array, &output_type).unwrap();
9570 assert!(casted_array.is_null(0));
9571 assert!(casted_array.is_null(1));
9572
9573 let output_type = DataType::Decimal256(76, 2);
9574 let casted_array = cast(&array, &output_type).unwrap();
9575 assert!(casted_array.is_null(0));
9576 assert!(casted_array.is_null(1));
9577
9578 let output_type = DataType::Decimal128(38, 2);
9580 let str_array = StringArray::from(vec!["4.4.5"]);
9581 let array = Arc::new(str_array) as ArrayRef;
9582 let option = CastOptions {
9583 safe: false,
9584 format_options: FormatOptions::default(),
9585 };
9586 let casted_err = cast_with_options(&array, &output_type, &option).unwrap_err();
9587 assert!(casted_err
9588 .to_string()
9589 .contains("Cannot cast string '4.4.5' to value of Decimal128(38, 10) type"));
9590
9591 let str_array = StringArray::from(vec![". 0.123"]);
9592 let array = Arc::new(str_array) as ArrayRef;
9593 let casted_err = cast_with_options(&array, &output_type, &option).unwrap_err();
9594 assert!(casted_err
9595 .to_string()
9596 .contains("Cannot cast string '. 0.123' to value of Decimal128(38, 10) type"));
9597 }
9598
9599 fn test_cast_string_to_decimal128_overflow(overflow_array: ArrayRef) {
9600 let output_type = DataType::Decimal128(38, 2);
9601 let casted_array = cast(&overflow_array, &output_type).unwrap();
9602 let decimal_arr = casted_array.as_primitive::<Decimal128Type>();
9603
9604 assert!(decimal_arr.is_null(0));
9605 assert!(decimal_arr.is_null(1));
9606 assert!(decimal_arr.is_null(2));
9607 assert_eq!(
9608 "999999999999999999999999999999999999.99",
9609 decimal_arr.value_as_string(3)
9610 );
9611 assert_eq!(
9612 "100000000000000000000000000000000000.00",
9613 decimal_arr.value_as_string(4)
9614 );
9615 }
9616
9617 #[test]
9618 fn test_cast_string_to_decimal128_precision_overflow() {
9619 let array = StringArray::from(vec!["1000".to_string()]);
9620 let array = Arc::new(array) as ArrayRef;
9621 let casted_array = cast_with_options(
9622 &array,
9623 &DataType::Decimal128(10, 8),
9624 &CastOptions {
9625 safe: true,
9626 format_options: FormatOptions::default(),
9627 },
9628 );
9629 assert!(casted_array.is_ok());
9630 assert!(casted_array.unwrap().is_null(0));
9631
9632 let err = cast_with_options(
9633 &array,
9634 &DataType::Decimal128(10, 8),
9635 &CastOptions {
9636 safe: false,
9637 format_options: FormatOptions::default(),
9638 },
9639 );
9640 assert_eq!("Invalid argument error: 100000000000 is too large to store in a Decimal128 of precision 10. Max is 9999999999", err.unwrap_err().to_string());
9641 }
9642
9643 #[test]
9644 fn test_cast_utf8_to_decimal128_overflow() {
9645 let overflow_str_array = StringArray::from(vec![
9646 i128::MAX.to_string(),
9647 i128::MIN.to_string(),
9648 "99999999999999999999999999999999999999".to_string(),
9649 "999999999999999999999999999999999999.99".to_string(),
9650 "99999999999999999999999999999999999.999".to_string(),
9651 ]);
9652 let overflow_array = Arc::new(overflow_str_array) as ArrayRef;
9653
9654 test_cast_string_to_decimal128_overflow(overflow_array);
9655 }
9656
9657 #[test]
9658 fn test_cast_large_utf8_to_decimal128_overflow() {
9659 let overflow_str_array = LargeStringArray::from(vec![
9660 i128::MAX.to_string(),
9661 i128::MIN.to_string(),
9662 "99999999999999999999999999999999999999".to_string(),
9663 "999999999999999999999999999999999999.99".to_string(),
9664 "99999999999999999999999999999999999.999".to_string(),
9665 ]);
9666 let overflow_array = Arc::new(overflow_str_array) as ArrayRef;
9667
9668 test_cast_string_to_decimal128_overflow(overflow_array);
9669 }
9670
9671 fn test_cast_string_to_decimal256_overflow(overflow_array: ArrayRef) {
9672 let output_type = DataType::Decimal256(76, 2);
9673 let casted_array = cast(&overflow_array, &output_type).unwrap();
9674 let decimal_arr = casted_array.as_primitive::<Decimal256Type>();
9675
9676 assert_eq!(
9677 "170141183460469231731687303715884105727.00",
9678 decimal_arr.value_as_string(0)
9679 );
9680 assert_eq!(
9681 "-170141183460469231731687303715884105728.00",
9682 decimal_arr.value_as_string(1)
9683 );
9684 assert_eq!(
9685 "99999999999999999999999999999999999999.00",
9686 decimal_arr.value_as_string(2)
9687 );
9688 assert_eq!(
9689 "999999999999999999999999999999999999.99",
9690 decimal_arr.value_as_string(3)
9691 );
9692 assert_eq!(
9693 "100000000000000000000000000000000000.00",
9694 decimal_arr.value_as_string(4)
9695 );
9696 assert!(decimal_arr.is_null(5));
9697 assert!(decimal_arr.is_null(6));
9698 }
9699
9700 #[test]
9701 fn test_cast_string_to_decimal256_precision_overflow() {
9702 let array = StringArray::from(vec!["1000".to_string()]);
9703 let array = Arc::new(array) as ArrayRef;
9704 let casted_array = cast_with_options(
9705 &array,
9706 &DataType::Decimal256(10, 8),
9707 &CastOptions {
9708 safe: true,
9709 format_options: FormatOptions::default(),
9710 },
9711 );
9712 assert!(casted_array.is_ok());
9713 assert!(casted_array.unwrap().is_null(0));
9714
9715 let err = cast_with_options(
9716 &array,
9717 &DataType::Decimal256(10, 8),
9718 &CastOptions {
9719 safe: false,
9720 format_options: FormatOptions::default(),
9721 },
9722 );
9723 assert_eq!("Invalid argument error: 100000000000 is too large to store in a Decimal256 of precision 10. Max is 9999999999", err.unwrap_err().to_string());
9724 }
9725
9726 #[test]
9727 fn test_cast_utf8_to_decimal256_overflow() {
9728 let overflow_str_array = StringArray::from(vec![
9729 i128::MAX.to_string(),
9730 i128::MIN.to_string(),
9731 "99999999999999999999999999999999999999".to_string(),
9732 "999999999999999999999999999999999999.99".to_string(),
9733 "99999999999999999999999999999999999.999".to_string(),
9734 i256::MAX.to_string(),
9735 i256::MIN.to_string(),
9736 ]);
9737 let overflow_array = Arc::new(overflow_str_array) as ArrayRef;
9738
9739 test_cast_string_to_decimal256_overflow(overflow_array);
9740 }
9741
9742 #[test]
9743 fn test_cast_large_utf8_to_decimal256_overflow() {
9744 let overflow_str_array = LargeStringArray::from(vec![
9745 i128::MAX.to_string(),
9746 i128::MIN.to_string(),
9747 "99999999999999999999999999999999999999".to_string(),
9748 "999999999999999999999999999999999999.99".to_string(),
9749 "99999999999999999999999999999999999.999".to_string(),
9750 i256::MAX.to_string(),
9751 i256::MIN.to_string(),
9752 ]);
9753 let overflow_array = Arc::new(overflow_str_array) as ArrayRef;
9754
9755 test_cast_string_to_decimal256_overflow(overflow_array);
9756 }
9757
9758 #[test]
9759 fn test_cast_outside_supported_range_for_nanoseconds() {
9760 const EXPECTED_ERROR_MESSAGE: &str = "The dates that can be represented as nanoseconds have to be between 1677-09-21T00:12:44.0 and 2262-04-11T23:47:16.854775804";
9761
9762 let array = StringArray::from(vec![Some("1650-01-01 01:01:01.000001")]);
9763
9764 let cast_options = CastOptions {
9765 safe: false,
9766 format_options: FormatOptions::default(),
9767 };
9768
9769 let result = cast_string_to_timestamp::<i32, TimestampNanosecondType>(
9770 &array,
9771 &None::<Arc<str>>,
9772 &cast_options,
9773 );
9774
9775 let err = result.unwrap_err();
9776 assert_eq!(
9777 err.to_string(),
9778 format!(
9779 "Cast error: Overflow converting {} to Nanosecond. {}",
9780 array.value(0),
9781 EXPECTED_ERROR_MESSAGE
9782 )
9783 );
9784 }
9785
9786 #[test]
9787 fn test_cast_date32_to_timestamp() {
9788 let a = Date32Array::from(vec![Some(18628), Some(18993), None]); let array = Arc::new(a) as ArrayRef;
9790 let b = cast(&array, &DataType::Timestamp(TimeUnit::Second, None)).unwrap();
9791 let c = b.as_primitive::<TimestampSecondType>();
9792 assert_eq!(1609459200, c.value(0));
9793 assert_eq!(1640995200, c.value(1));
9794 assert!(c.is_null(2));
9795 }
9796
9797 #[test]
9798 fn test_cast_date32_to_timestamp_ms() {
9799 let a = Date32Array::from(vec![Some(18628), Some(18993), None]); let array = Arc::new(a) as ArrayRef;
9801 let b = cast(&array, &DataType::Timestamp(TimeUnit::Millisecond, None)).unwrap();
9802 let c = b
9803 .as_any()
9804 .downcast_ref::<TimestampMillisecondArray>()
9805 .unwrap();
9806 assert_eq!(1609459200000, c.value(0));
9807 assert_eq!(1640995200000, c.value(1));
9808 assert!(c.is_null(2));
9809 }
9810
9811 #[test]
9812 fn test_cast_date32_to_timestamp_us() {
9813 let a = Date32Array::from(vec![Some(18628), Some(18993), None]); let array = Arc::new(a) as ArrayRef;
9815 let b = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
9816 let c = b
9817 .as_any()
9818 .downcast_ref::<TimestampMicrosecondArray>()
9819 .unwrap();
9820 assert_eq!(1609459200000000, c.value(0));
9821 assert_eq!(1640995200000000, c.value(1));
9822 assert!(c.is_null(2));
9823 }
9824
9825 #[test]
9826 fn test_cast_date32_to_timestamp_ns() {
9827 let a = Date32Array::from(vec![Some(18628), Some(18993), None]); let array = Arc::new(a) as ArrayRef;
9829 let b = cast(&array, &DataType::Timestamp(TimeUnit::Nanosecond, None)).unwrap();
9830 let c = b
9831 .as_any()
9832 .downcast_ref::<TimestampNanosecondArray>()
9833 .unwrap();
9834 assert_eq!(1609459200000000000, c.value(0));
9835 assert_eq!(1640995200000000000, c.value(1));
9836 assert!(c.is_null(2));
9837 }
9838
9839 #[test]
9840 fn test_timezone_cast() {
9841 let a = StringArray::from(vec![
9842 "2000-01-01T12:00:00", "2020-12-15T12:34:56", ]);
9845 let array = Arc::new(a) as ArrayRef;
9846 let b = cast(&array, &DataType::Timestamp(TimeUnit::Nanosecond, None)).unwrap();
9847 let v = b.as_primitive::<TimestampNanosecondType>();
9848
9849 assert_eq!(v.value(0), 946728000000000000);
9850 assert_eq!(v.value(1), 1608035696000000000);
9851
9852 let b = cast(
9853 &b,
9854 &DataType::Timestamp(TimeUnit::Nanosecond, Some("+00:00".into())),
9855 )
9856 .unwrap();
9857 let v = b.as_primitive::<TimestampNanosecondType>();
9858
9859 assert_eq!(v.value(0), 946728000000000000);
9860 assert_eq!(v.value(1), 1608035696000000000);
9861
9862 let b = cast(
9863 &b,
9864 &DataType::Timestamp(TimeUnit::Millisecond, Some("+02:00".into())),
9865 )
9866 .unwrap();
9867 let v = b.as_primitive::<TimestampMillisecondType>();
9868
9869 assert_eq!(v.value(0), 946728000000);
9870 assert_eq!(v.value(1), 1608035696000);
9871 }
9872
9873 #[test]
9874 fn test_cast_utf8_to_timestamp() {
9875 fn test_tz(tz: Arc<str>) {
9876 let valid = StringArray::from(vec![
9877 "2023-01-01 04:05:06.789000-08:00",
9878 "2023-01-01 04:05:06.789000-07:00",
9879 "2023-01-01 04:05:06.789 -0800",
9880 "2023-01-01 04:05:06.789 -08:00",
9881 "2023-01-01 040506 +0730",
9882 "2023-01-01 040506 +07:30",
9883 "2023-01-01 04:05:06.789",
9884 "2023-01-01 04:05:06",
9885 "2023-01-01",
9886 ]);
9887
9888 let array = Arc::new(valid) as ArrayRef;
9889 let b = cast_with_options(
9890 &array,
9891 &DataType::Timestamp(TimeUnit::Nanosecond, Some(tz.clone())),
9892 &CastOptions {
9893 safe: false,
9894 format_options: FormatOptions::default(),
9895 },
9896 )
9897 .unwrap();
9898
9899 let tz = tz.as_ref().parse().unwrap();
9900
9901 let as_tz =
9902 |v: i64| as_datetime_with_timezone::<TimestampNanosecondType>(v, tz).unwrap();
9903
9904 let as_utc = |v: &i64| as_tz(*v).naive_utc().to_string();
9905 let as_local = |v: &i64| as_tz(*v).naive_local().to_string();
9906
9907 let values = b.as_primitive::<TimestampNanosecondType>().values();
9908 let utc_results: Vec<_> = values.iter().map(as_utc).collect();
9909 let local_results: Vec<_> = values.iter().map(as_local).collect();
9910
9911 assert_eq!(
9913 &utc_results[..6],
9914 &[
9915 "2023-01-01 12:05:06.789".to_string(),
9916 "2023-01-01 11:05:06.789".to_string(),
9917 "2023-01-01 12:05:06.789".to_string(),
9918 "2023-01-01 12:05:06.789".to_string(),
9919 "2022-12-31 20:35:06".to_string(),
9920 "2022-12-31 20:35:06".to_string(),
9921 ]
9922 );
9923 assert_eq!(
9925 &local_results[6..],
9926 &[
9927 "2023-01-01 04:05:06.789".to_string(),
9928 "2023-01-01 04:05:06".to_string(),
9929 "2023-01-01 00:00:00".to_string()
9930 ]
9931 )
9932 }
9933
9934 test_tz("+00:00".into());
9935 test_tz("+02:00".into());
9936 }
9937
9938 #[test]
9939 fn test_cast_invalid_utf8() {
9940 let v1: &[u8] = b"\xFF invalid";
9941 let v2: &[u8] = b"\x00 Foo";
9942 let s = BinaryArray::from(vec![v1, v2]);
9943 let options = CastOptions {
9944 safe: true,
9945 format_options: FormatOptions::default(),
9946 };
9947 let array = cast_with_options(&s, &DataType::Utf8, &options).unwrap();
9948 let a = array.as_string::<i32>();
9949 a.to_data().validate_full().unwrap();
9950
9951 assert_eq!(a.null_count(), 1);
9952 assert_eq!(a.len(), 2);
9953 assert!(a.is_null(0));
9954 assert_eq!(a.value(0), "");
9955 assert_eq!(a.value(1), "\x00 Foo");
9956 }
9957
9958 #[test]
9959 fn test_cast_utf8_to_timestamptz() {
9960 let valid = StringArray::from(vec!["2023-01-01"]);
9961
9962 let array = Arc::new(valid) as ArrayRef;
9963 let b = cast(
9964 &array,
9965 &DataType::Timestamp(TimeUnit::Nanosecond, Some("+00:00".into())),
9966 )
9967 .unwrap();
9968
9969 let expect = DataType::Timestamp(TimeUnit::Nanosecond, Some("+00:00".into()));
9970
9971 assert_eq!(b.data_type(), &expect);
9972 let c = b
9973 .as_any()
9974 .downcast_ref::<TimestampNanosecondArray>()
9975 .unwrap();
9976 assert_eq!(1672531200000000000, c.value(0));
9977 }
9978
9979 #[test]
9980 fn test_cast_decimal_to_string() {
9981 assert!(can_cast_types(
9982 &DataType::Decimal32(9, 4),
9983 &DataType::Utf8View
9984 ));
9985 assert!(can_cast_types(
9986 &DataType::Decimal64(16, 4),
9987 &DataType::Utf8View
9988 ));
9989 assert!(can_cast_types(
9990 &DataType::Decimal128(10, 4),
9991 &DataType::Utf8View
9992 ));
9993 assert!(can_cast_types(
9994 &DataType::Decimal256(38, 10),
9995 &DataType::Utf8View
9996 ));
9997
9998 macro_rules! assert_decimal_values {
9999 ($array:expr) => {
10000 let c = $array;
10001 assert_eq!("1123.454", c.value(0));
10002 assert_eq!("2123.456", c.value(1));
10003 assert_eq!("-3123.453", c.value(2));
10004 assert_eq!("-3123.456", c.value(3));
10005 assert_eq!("0.000", c.value(4));
10006 assert_eq!("0.123", c.value(5));
10007 assert_eq!("1234.567", c.value(6));
10008 assert_eq!("-1234.567", c.value(7));
10009 assert!(c.is_null(8));
10010 };
10011 }
10012
10013 fn test_decimal_to_string<IN: ArrowPrimitiveType, OffsetSize: OffsetSizeTrait>(
10014 output_type: DataType,
10015 array: PrimitiveArray<IN>,
10016 ) {
10017 let b = cast(&array, &output_type).unwrap();
10018
10019 assert_eq!(b.data_type(), &output_type);
10020 match b.data_type() {
10021 DataType::Utf8View => {
10022 let c = b.as_string_view();
10023 assert_decimal_values!(c);
10024 }
10025 DataType::Utf8 | DataType::LargeUtf8 => {
10026 let c = b.as_string::<OffsetSize>();
10027 assert_decimal_values!(c);
10028 }
10029 _ => (),
10030 }
10031 }
10032
10033 let array32: Vec<Option<i32>> = vec![
10034 Some(1123454),
10035 Some(2123456),
10036 Some(-3123453),
10037 Some(-3123456),
10038 Some(0),
10039 Some(123),
10040 Some(123456789),
10041 Some(-123456789),
10042 None,
10043 ];
10044 let array64: Vec<Option<i64>> = array32.iter().map(|num| num.map(|x| x as i64)).collect();
10045 let array128: Vec<Option<i128>> =
10046 array64.iter().map(|num| num.map(|x| x as i128)).collect();
10047 let array256: Vec<Option<i256>> = array128
10048 .iter()
10049 .map(|num| num.map(i256::from_i128))
10050 .collect();
10051
10052 test_decimal_to_string::<Decimal32Type, i32>(
10053 DataType::Utf8View,
10054 create_decimal32_array(array32.clone(), 7, 3).unwrap(),
10055 );
10056 test_decimal_to_string::<Decimal32Type, i32>(
10057 DataType::Utf8,
10058 create_decimal32_array(array32.clone(), 7, 3).unwrap(),
10059 );
10060 test_decimal_to_string::<Decimal32Type, i64>(
10061 DataType::LargeUtf8,
10062 create_decimal32_array(array32, 7, 3).unwrap(),
10063 );
10064
10065 test_decimal_to_string::<Decimal64Type, i32>(
10066 DataType::Utf8View,
10067 create_decimal64_array(array64.clone(), 7, 3).unwrap(),
10068 );
10069 test_decimal_to_string::<Decimal64Type, i32>(
10070 DataType::Utf8,
10071 create_decimal64_array(array64.clone(), 7, 3).unwrap(),
10072 );
10073 test_decimal_to_string::<Decimal64Type, i64>(
10074 DataType::LargeUtf8,
10075 create_decimal64_array(array64, 7, 3).unwrap(),
10076 );
10077
10078 test_decimal_to_string::<Decimal128Type, i32>(
10079 DataType::Utf8View,
10080 create_decimal128_array(array128.clone(), 7, 3).unwrap(),
10081 );
10082 test_decimal_to_string::<Decimal128Type, i32>(
10083 DataType::Utf8,
10084 create_decimal128_array(array128.clone(), 7, 3).unwrap(),
10085 );
10086 test_decimal_to_string::<Decimal128Type, i64>(
10087 DataType::LargeUtf8,
10088 create_decimal128_array(array128, 7, 3).unwrap(),
10089 );
10090
10091 test_decimal_to_string::<Decimal256Type, i32>(
10092 DataType::Utf8View,
10093 create_decimal256_array(array256.clone(), 7, 3).unwrap(),
10094 );
10095 test_decimal_to_string::<Decimal256Type, i32>(
10096 DataType::Utf8,
10097 create_decimal256_array(array256.clone(), 7, 3).unwrap(),
10098 );
10099 test_decimal_to_string::<Decimal256Type, i64>(
10100 DataType::LargeUtf8,
10101 create_decimal256_array(array256, 7, 3).unwrap(),
10102 );
10103 }
10104
10105 #[test]
10106 fn test_cast_numeric_to_decimal128_precision_overflow() {
10107 let array = Int64Array::from(vec![1234567]);
10108 let array = Arc::new(array) as ArrayRef;
10109 let casted_array = cast_with_options(
10110 &array,
10111 &DataType::Decimal128(7, 3),
10112 &CastOptions {
10113 safe: true,
10114 format_options: FormatOptions::default(),
10115 },
10116 );
10117 assert!(casted_array.is_ok());
10118 assert!(casted_array.unwrap().is_null(0));
10119
10120 let err = cast_with_options(
10121 &array,
10122 &DataType::Decimal128(7, 3),
10123 &CastOptions {
10124 safe: false,
10125 format_options: FormatOptions::default(),
10126 },
10127 );
10128 assert_eq!("Invalid argument error: 1234567000 is too large to store in a Decimal128 of precision 7. Max is 9999999", err.unwrap_err().to_string());
10129 }
10130
10131 #[test]
10132 fn test_cast_numeric_to_decimal256_precision_overflow() {
10133 let array = Int64Array::from(vec![1234567]);
10134 let array = Arc::new(array) as ArrayRef;
10135 let casted_array = cast_with_options(
10136 &array,
10137 &DataType::Decimal256(7, 3),
10138 &CastOptions {
10139 safe: true,
10140 format_options: FormatOptions::default(),
10141 },
10142 );
10143 assert!(casted_array.is_ok());
10144 assert!(casted_array.unwrap().is_null(0));
10145
10146 let err = cast_with_options(
10147 &array,
10148 &DataType::Decimal256(7, 3),
10149 &CastOptions {
10150 safe: false,
10151 format_options: FormatOptions::default(),
10152 },
10153 );
10154 assert_eq!("Invalid argument error: 1234567000 is too large to store in a Decimal256 of precision 7. Max is 9999999", err.unwrap_err().to_string());
10155 }
10156
10157 fn cast_from_duration_to_interval<T: ArrowTemporalType<Native = i64>>(
10159 array: Vec<i64>,
10160 cast_options: &CastOptions,
10161 ) -> Result<PrimitiveArray<IntervalMonthDayNanoType>, ArrowError> {
10162 let array = PrimitiveArray::<T>::new(array.into(), None);
10163 let array = Arc::new(array) as ArrayRef;
10164 let interval = DataType::Interval(IntervalUnit::MonthDayNano);
10165 let out = cast_with_options(&array, &interval, cast_options)?;
10166 let out = out.as_primitive::<IntervalMonthDayNanoType>().clone();
10167 Ok(out)
10168 }
10169
10170 #[test]
10171 fn test_cast_from_duration_to_interval() {
10172 let array = vec![1234567];
10174 let casted_array =
10175 cast_from_duration_to_interval::<DurationSecondType>(array, &CastOptions::default())
10176 .unwrap();
10177 assert_eq!(
10178 casted_array.data_type(),
10179 &DataType::Interval(IntervalUnit::MonthDayNano)
10180 );
10181 assert_eq!(
10182 casted_array.value(0),
10183 IntervalMonthDayNano::new(0, 0, 1234567000000000)
10184 );
10185
10186 let array = vec![i64::MAX];
10187 let casted_array = cast_from_duration_to_interval::<DurationSecondType>(
10188 array.clone(),
10189 &CastOptions::default(),
10190 )
10191 .unwrap();
10192 assert!(!casted_array.is_valid(0));
10193
10194 let casted_array = cast_from_duration_to_interval::<DurationSecondType>(
10195 array,
10196 &CastOptions {
10197 safe: false,
10198 format_options: FormatOptions::default(),
10199 },
10200 );
10201 assert!(casted_array.is_err());
10202
10203 let array = vec![1234567];
10205 let casted_array = cast_from_duration_to_interval::<DurationMillisecondType>(
10206 array,
10207 &CastOptions::default(),
10208 )
10209 .unwrap();
10210 assert_eq!(
10211 casted_array.data_type(),
10212 &DataType::Interval(IntervalUnit::MonthDayNano)
10213 );
10214 assert_eq!(
10215 casted_array.value(0),
10216 IntervalMonthDayNano::new(0, 0, 1234567000000)
10217 );
10218
10219 let array = vec![i64::MAX];
10220 let casted_array = cast_from_duration_to_interval::<DurationMillisecondType>(
10221 array.clone(),
10222 &CastOptions::default(),
10223 )
10224 .unwrap();
10225 assert!(!casted_array.is_valid(0));
10226
10227 let casted_array = cast_from_duration_to_interval::<DurationMillisecondType>(
10228 array,
10229 &CastOptions {
10230 safe: false,
10231 format_options: FormatOptions::default(),
10232 },
10233 );
10234 assert!(casted_array.is_err());
10235
10236 let array = vec![1234567];
10238 let casted_array = cast_from_duration_to_interval::<DurationMicrosecondType>(
10239 array,
10240 &CastOptions::default(),
10241 )
10242 .unwrap();
10243 assert_eq!(
10244 casted_array.data_type(),
10245 &DataType::Interval(IntervalUnit::MonthDayNano)
10246 );
10247 assert_eq!(
10248 casted_array.value(0),
10249 IntervalMonthDayNano::new(0, 0, 1234567000)
10250 );
10251
10252 let array = vec![i64::MAX];
10253 let casted_array = cast_from_duration_to_interval::<DurationMicrosecondType>(
10254 array.clone(),
10255 &CastOptions::default(),
10256 )
10257 .unwrap();
10258 assert!(!casted_array.is_valid(0));
10259
10260 let casted_array = cast_from_duration_to_interval::<DurationMicrosecondType>(
10261 array,
10262 &CastOptions {
10263 safe: false,
10264 format_options: FormatOptions::default(),
10265 },
10266 );
10267 assert!(casted_array.is_err());
10268
10269 let array = vec![1234567];
10271 let casted_array = cast_from_duration_to_interval::<DurationNanosecondType>(
10272 array,
10273 &CastOptions::default(),
10274 )
10275 .unwrap();
10276 assert_eq!(
10277 casted_array.data_type(),
10278 &DataType::Interval(IntervalUnit::MonthDayNano)
10279 );
10280 assert_eq!(
10281 casted_array.value(0),
10282 IntervalMonthDayNano::new(0, 0, 1234567)
10283 );
10284
10285 let array = vec![i64::MAX];
10286 let casted_array = cast_from_duration_to_interval::<DurationNanosecondType>(
10287 array,
10288 &CastOptions {
10289 safe: false,
10290 format_options: FormatOptions::default(),
10291 },
10292 )
10293 .unwrap();
10294 assert_eq!(
10295 casted_array.value(0),
10296 IntervalMonthDayNano::new(0, 0, i64::MAX)
10297 );
10298 }
10299
10300 fn cast_from_interval_to_duration<T: ArrowTemporalType>(
10302 array: &IntervalMonthDayNanoArray,
10303 cast_options: &CastOptions,
10304 ) -> Result<PrimitiveArray<T>, ArrowError> {
10305 let casted_array = cast_with_options(&array, &T::DATA_TYPE, cast_options)?;
10306 casted_array
10307 .as_any()
10308 .downcast_ref::<PrimitiveArray<T>>()
10309 .ok_or_else(|| {
10310 ArrowError::ComputeError(format!("Failed to downcast to {}", T::DATA_TYPE))
10311 })
10312 .cloned()
10313 }
10314
10315 #[test]
10316 fn test_cast_from_interval_to_duration() {
10317 let nullable = CastOptions::default();
10318 let fallible = CastOptions {
10319 safe: false,
10320 format_options: FormatOptions::default(),
10321 };
10322 let v = IntervalMonthDayNano::new(0, 0, 1234567);
10323
10324 let array = vec![v].into();
10326 let casted_array: DurationSecondArray =
10327 cast_from_interval_to_duration(&array, &nullable).unwrap();
10328 assert_eq!(casted_array.value(0), 0);
10329
10330 let array = vec![IntervalMonthDayNano::MAX].into();
10331 let casted_array: DurationSecondArray =
10332 cast_from_interval_to_duration(&array, &nullable).unwrap();
10333 assert!(!casted_array.is_valid(0));
10334
10335 let res = cast_from_interval_to_duration::<DurationSecondType>(&array, &fallible);
10336 assert!(res.is_err());
10337
10338 let array = vec![v].into();
10340 let casted_array: DurationMillisecondArray =
10341 cast_from_interval_to_duration(&array, &nullable).unwrap();
10342 assert_eq!(casted_array.value(0), 1);
10343
10344 let array = vec![IntervalMonthDayNano::MAX].into();
10345 let casted_array: DurationMillisecondArray =
10346 cast_from_interval_to_duration(&array, &nullable).unwrap();
10347 assert!(!casted_array.is_valid(0));
10348
10349 let res = cast_from_interval_to_duration::<DurationMillisecondType>(&array, &fallible);
10350 assert!(res.is_err());
10351
10352 let array = vec![v].into();
10354 let casted_array: DurationMicrosecondArray =
10355 cast_from_interval_to_duration(&array, &nullable).unwrap();
10356 assert_eq!(casted_array.value(0), 1234);
10357
10358 let array = vec![IntervalMonthDayNano::MAX].into();
10359 let casted_array =
10360 cast_from_interval_to_duration::<DurationMicrosecondType>(&array, &nullable).unwrap();
10361 assert!(!casted_array.is_valid(0));
10362
10363 let casted_array =
10364 cast_from_interval_to_duration::<DurationMicrosecondType>(&array, &fallible);
10365 assert!(casted_array.is_err());
10366
10367 let array = vec![v].into();
10369 let casted_array: DurationNanosecondArray =
10370 cast_from_interval_to_duration(&array, &nullable).unwrap();
10371 assert_eq!(casted_array.value(0), 1234567);
10372
10373 let array = vec![IntervalMonthDayNano::MAX].into();
10374 let casted_array: DurationNanosecondArray =
10375 cast_from_interval_to_duration(&array, &nullable).unwrap();
10376 assert!(!casted_array.is_valid(0));
10377
10378 let casted_array =
10379 cast_from_interval_to_duration::<DurationNanosecondType>(&array, &fallible);
10380 assert!(casted_array.is_err());
10381
10382 let array = vec![
10383 IntervalMonthDayNanoType::make_value(0, 1, 0),
10384 IntervalMonthDayNanoType::make_value(-1, 0, 0),
10385 IntervalMonthDayNanoType::make_value(1, 1, 0),
10386 IntervalMonthDayNanoType::make_value(1, 0, 1),
10387 IntervalMonthDayNanoType::make_value(0, 0, -1),
10388 ]
10389 .into();
10390 let casted_array =
10391 cast_from_interval_to_duration::<DurationNanosecondType>(&array, &nullable).unwrap();
10392 assert!(!casted_array.is_valid(0));
10393 assert!(!casted_array.is_valid(1));
10394 assert!(!casted_array.is_valid(2));
10395 assert!(!casted_array.is_valid(3));
10396 assert!(casted_array.is_valid(4));
10397 assert_eq!(casted_array.value(4), -1);
10398 }
10399
10400 fn cast_from_interval_year_month_to_interval_month_day_nano(
10402 array: Vec<i32>,
10403 cast_options: &CastOptions,
10404 ) -> Result<PrimitiveArray<IntervalMonthDayNanoType>, ArrowError> {
10405 let array = PrimitiveArray::<IntervalYearMonthType>::from(array);
10406 let array = Arc::new(array) as ArrayRef;
10407 let casted_array = cast_with_options(
10408 &array,
10409 &DataType::Interval(IntervalUnit::MonthDayNano),
10410 cast_options,
10411 )?;
10412 casted_array
10413 .as_any()
10414 .downcast_ref::<IntervalMonthDayNanoArray>()
10415 .ok_or_else(|| {
10416 ArrowError::ComputeError(
10417 "Failed to downcast to IntervalMonthDayNanoArray".to_string(),
10418 )
10419 })
10420 .cloned()
10421 }
10422
10423 #[test]
10424 fn test_cast_from_interval_year_month_to_interval_month_day_nano() {
10425 let array = vec![1234567];
10427 let casted_array = cast_from_interval_year_month_to_interval_month_day_nano(
10428 array,
10429 &CastOptions::default(),
10430 )
10431 .unwrap();
10432 assert_eq!(
10433 casted_array.data_type(),
10434 &DataType::Interval(IntervalUnit::MonthDayNano)
10435 );
10436 assert_eq!(
10437 casted_array.value(0),
10438 IntervalMonthDayNano::new(1234567, 0, 0)
10439 );
10440 }
10441
10442 fn cast_from_interval_day_time_to_interval_month_day_nano(
10444 array: Vec<IntervalDayTime>,
10445 cast_options: &CastOptions,
10446 ) -> Result<PrimitiveArray<IntervalMonthDayNanoType>, ArrowError> {
10447 let array = PrimitiveArray::<IntervalDayTimeType>::from(array);
10448 let array = Arc::new(array) as ArrayRef;
10449 let casted_array = cast_with_options(
10450 &array,
10451 &DataType::Interval(IntervalUnit::MonthDayNano),
10452 cast_options,
10453 )?;
10454 Ok(casted_array
10455 .as_primitive::<IntervalMonthDayNanoType>()
10456 .clone())
10457 }
10458
10459 #[test]
10460 fn test_cast_from_interval_day_time_to_interval_month_day_nano() {
10461 let array = vec![IntervalDayTime::new(123, 0)];
10463 let casted_array =
10464 cast_from_interval_day_time_to_interval_month_day_nano(array, &CastOptions::default())
10465 .unwrap();
10466 assert_eq!(
10467 casted_array.data_type(),
10468 &DataType::Interval(IntervalUnit::MonthDayNano)
10469 );
10470 assert_eq!(casted_array.value(0), IntervalMonthDayNano::new(0, 123, 0));
10471 }
10472
10473 #[test]
10474 fn test_cast_below_unixtimestamp() {
10475 let valid = StringArray::from(vec![
10476 "1900-01-03 23:59:59",
10477 "1969-12-31 00:00:01",
10478 "1989-12-31 00:00:01",
10479 ]);
10480
10481 let array = Arc::new(valid) as ArrayRef;
10482 let casted_array = cast_with_options(
10483 &array,
10484 &DataType::Timestamp(TimeUnit::Nanosecond, Some("+00:00".into())),
10485 &CastOptions {
10486 safe: false,
10487 format_options: FormatOptions::default(),
10488 },
10489 )
10490 .unwrap();
10491
10492 let ts_array = casted_array
10493 .as_primitive::<TimestampNanosecondType>()
10494 .values()
10495 .iter()
10496 .map(|ts| ts / 1_000_000)
10497 .collect::<Vec<_>>();
10498
10499 let array = TimestampMillisecondArray::from(ts_array).with_timezone("+00:00".to_string());
10500 let casted_array = cast(&array, &DataType::Date32).unwrap();
10501 let date_array = casted_array.as_primitive::<Date32Type>();
10502 let casted_array = cast(&date_array, &DataType::Utf8).unwrap();
10503 let string_array = casted_array.as_string::<i32>();
10504 assert_eq!("1900-01-03", string_array.value(0));
10505 assert_eq!("1969-12-31", string_array.value(1));
10506 assert_eq!("1989-12-31", string_array.value(2));
10507 }
10508
10509 #[test]
10510 fn test_nested_list() {
10511 let mut list = ListBuilder::new(Int32Builder::new());
10512 list.append_value([Some(1), Some(2), Some(3)]);
10513 list.append_value([Some(4), None, Some(6)]);
10514 let list = list.finish();
10515
10516 let to_field = Field::new("nested", list.data_type().clone(), false);
10517 let to = DataType::List(Arc::new(to_field));
10518 let out = cast(&list, &to).unwrap();
10519 let opts = FormatOptions::default().with_null("null");
10520 let formatted = ArrayFormatter::try_new(out.as_ref(), &opts).unwrap();
10521
10522 assert_eq!(formatted.value(0).to_string(), "[[1], [2], [3]]");
10523 assert_eq!(formatted.value(1).to_string(), "[[4], [null], [6]]");
10524 }
10525
10526 #[test]
10527 fn test_nested_list_cast() {
10528 let mut builder = ListBuilder::new(ListBuilder::new(Int32Builder::new()));
10529 builder.append_value([Some([Some(1), Some(2), None]), None]);
10530 builder.append_value([None, Some([]), None]);
10531 builder.append_null();
10532 builder.append_value([Some([Some(2), Some(3)])]);
10533 let start = builder.finish();
10534
10535 let mut builder = LargeListBuilder::new(LargeListBuilder::new(Int8Builder::new()));
10536 builder.append_value([Some([Some(1), Some(2), None]), None]);
10537 builder.append_value([None, Some([]), None]);
10538 builder.append_null();
10539 builder.append_value([Some([Some(2), Some(3)])]);
10540 let expected = builder.finish();
10541
10542 let actual = cast(&start, expected.data_type()).unwrap();
10543 assert_eq!(actual.as_ref(), &expected);
10544 }
10545
10546 const CAST_OPTIONS: CastOptions<'static> = CastOptions {
10547 safe: true,
10548 format_options: FormatOptions::new(),
10549 };
10550
10551 #[test]
10552 #[allow(clippy::assertions_on_constants)]
10553 fn test_const_options() {
10554 assert!(CAST_OPTIONS.safe)
10555 }
10556
10557 #[test]
10558 fn test_list_format_options() {
10559 let options = CastOptions {
10560 safe: false,
10561 format_options: FormatOptions::default().with_null("null"),
10562 };
10563 let array = ListArray::from_iter_primitive::<Int32Type, _, _>(vec![
10564 Some(vec![Some(0), Some(1), Some(2)]),
10565 Some(vec![Some(0), None, Some(2)]),
10566 ]);
10567 let a = cast_with_options(&array, &DataType::Utf8, &options).unwrap();
10568 let r: Vec<_> = a.as_string::<i32>().iter().flatten().collect();
10569 assert_eq!(r, &["[0, 1, 2]", "[0, null, 2]"]);
10570 }
10571 #[test]
10572 fn test_cast_string_to_timestamp_invalid_tz() {
10573 let bad_timestamp = "2023-12-05T21:58:10.45ZZTOP";
10575 let array = StringArray::from(vec![Some(bad_timestamp)]);
10576
10577 let data_types = [
10578 DataType::Timestamp(TimeUnit::Second, None),
10579 DataType::Timestamp(TimeUnit::Millisecond, None),
10580 DataType::Timestamp(TimeUnit::Microsecond, None),
10581 DataType::Timestamp(TimeUnit::Nanosecond, None),
10582 ];
10583
10584 let cast_options = CastOptions {
10585 safe: false,
10586 ..Default::default()
10587 };
10588
10589 for dt in data_types {
10590 assert_eq!(
10591 cast_with_options(&array, &dt, &cast_options)
10592 .unwrap_err()
10593 .to_string(),
10594 "Parser error: Invalid timezone \"ZZTOP\": only offset based timezones supported without chrono-tz feature"
10595 );
10596 }
10597 }
10598 #[test]
10599 fn test_cast_struct_to_struct() {
10600 let struct_type = DataType::Struct(
10601 vec![
10602 Field::new("a", DataType::Boolean, false),
10603 Field::new("b", DataType::Int32, false),
10604 ]
10605 .into(),
10606 );
10607 let to_type = DataType::Struct(
10608 vec![
10609 Field::new("a", DataType::Utf8, false),
10610 Field::new("b", DataType::Utf8, false),
10611 ]
10612 .into(),
10613 );
10614 let boolean = Arc::new(BooleanArray::from(vec![false, false, true, true]));
10615 let int = Arc::new(Int32Array::from(vec![42, 28, 19, 31]));
10616 let struct_array = StructArray::from(vec![
10617 (
10618 Arc::new(Field::new("b", DataType::Boolean, false)),
10619 boolean.clone() as ArrayRef,
10620 ),
10621 (
10622 Arc::new(Field::new("c", DataType::Int32, false)),
10623 int.clone() as ArrayRef,
10624 ),
10625 ]);
10626 let casted_array = cast(&struct_array, &to_type).unwrap();
10627 let casted_array = casted_array.as_struct();
10628 assert_eq!(casted_array.data_type(), &to_type);
10629 let casted_boolean_array = casted_array
10630 .column(0)
10631 .as_string::<i32>()
10632 .into_iter()
10633 .flatten()
10634 .collect::<Vec<_>>();
10635 let casted_int_array = casted_array
10636 .column(1)
10637 .as_string::<i32>()
10638 .into_iter()
10639 .flatten()
10640 .collect::<Vec<_>>();
10641 assert_eq!(casted_boolean_array, vec!["false", "false", "true", "true"]);
10642 assert_eq!(casted_int_array, vec!["42", "28", "19", "31"]);
10643
10644 let to_type = DataType::Struct(
10646 vec![
10647 Field::new("a", DataType::Date32, false),
10648 Field::new("b", DataType::Utf8, false),
10649 ]
10650 .into(),
10651 );
10652 assert!(!can_cast_types(&struct_type, &to_type));
10653 let result = cast(&struct_array, &to_type);
10654 assert_eq!(
10655 "Cast error: Casting from Boolean to Date32 not supported",
10656 result.unwrap_err().to_string()
10657 );
10658 }
10659
10660 #[test]
10661 fn test_cast_struct_to_struct_nullability() {
10662 let boolean = Arc::new(BooleanArray::from(vec![false, false, true, true]));
10663 let int = Arc::new(Int32Array::from(vec![Some(42), None, Some(19), None]));
10664 let struct_array = StructArray::from(vec![
10665 (
10666 Arc::new(Field::new("b", DataType::Boolean, false)),
10667 boolean.clone() as ArrayRef,
10668 ),
10669 (
10670 Arc::new(Field::new("c", DataType::Int32, true)),
10671 int.clone() as ArrayRef,
10672 ),
10673 ]);
10674
10675 let to_type = DataType::Struct(
10677 vec![
10678 Field::new("a", DataType::Utf8, false),
10679 Field::new("b", DataType::Utf8, true),
10680 ]
10681 .into(),
10682 );
10683 cast(&struct_array, &to_type).expect("Cast nullable to nullable struct field should work");
10684
10685 let to_type = DataType::Struct(
10687 vec![
10688 Field::new("a", DataType::Utf8, false),
10689 Field::new("b", DataType::Utf8, false),
10690 ]
10691 .into(),
10692 );
10693 cast(&struct_array, &to_type)
10694 .expect_err("Cast nullable to non-nullable struct field should fail");
10695
10696 let boolean = Arc::new(BooleanArray::from(vec![false, false, true, true]));
10697 let int = Arc::new(Int32Array::from(vec![i32::MAX, 25, 1, 100]));
10698 let struct_array = StructArray::from(vec![
10699 (
10700 Arc::new(Field::new("b", DataType::Boolean, false)),
10701 boolean.clone() as ArrayRef,
10702 ),
10703 (
10704 Arc::new(Field::new("c", DataType::Int32, false)),
10705 int.clone() as ArrayRef,
10706 ),
10707 ]);
10708
10709 let to_type = DataType::Struct(
10711 vec![
10712 Field::new("a", DataType::Utf8, false),
10713 Field::new("b", DataType::Utf8, false),
10714 ]
10715 .into(),
10716 );
10717 cast(&struct_array, &to_type)
10718 .expect("Cast non-nullable to non-nullable struct field should work");
10719
10720 let to_type = DataType::Struct(
10722 vec![
10723 Field::new("a", DataType::Utf8, false),
10724 Field::new("b", DataType::Int8, false),
10725 ]
10726 .into(),
10727 );
10728 cast(&struct_array, &to_type).expect_err(
10729 "Cast non-nullable to non-nullable struct field returning null should fail",
10730 );
10731 }
10732
10733 #[test]
10734 fn test_cast_struct_to_non_struct() {
10735 let boolean = Arc::new(BooleanArray::from(vec![true, false]));
10736 let struct_array = StructArray::from(vec![(
10737 Arc::new(Field::new("a", DataType::Boolean, false)),
10738 boolean.clone() as ArrayRef,
10739 )]);
10740 let to_type = DataType::Utf8;
10741 let result = cast(&struct_array, &to_type);
10742 assert_eq!(
10743 r#"Cast error: Casting from Struct([Field { name: "a", data_type: Boolean, nullable: false, dict_id: 0, dict_is_ordered: false, metadata: {} }]) to Utf8 not supported"#,
10744 result.unwrap_err().to_string()
10745 );
10746 }
10747
10748 #[test]
10749 fn test_cast_non_struct_to_struct() {
10750 let array = StringArray::from(vec!["a", "b"]);
10751 let to_type = DataType::Struct(vec![Field::new("a", DataType::Boolean, false)].into());
10752 let result = cast(&array, &to_type);
10753 assert_eq!(
10754 r#"Cast error: Casting from Utf8 to Struct([Field { name: "a", data_type: Boolean, nullable: false, dict_id: 0, dict_is_ordered: false, metadata: {} }]) not supported"#,
10755 result.unwrap_err().to_string()
10756 );
10757 }
10758
10759 fn run_decimal_cast_test_case_between_multiple_types(t: DecimalCastTestConfig) {
10760 run_decimal_cast_test_case::<Decimal128Type, Decimal128Type>(t.clone());
10761 run_decimal_cast_test_case::<Decimal128Type, Decimal256Type>(t.clone());
10762 run_decimal_cast_test_case::<Decimal256Type, Decimal128Type>(t.clone());
10763 run_decimal_cast_test_case::<Decimal256Type, Decimal256Type>(t.clone());
10764 }
10765
10766 #[test]
10767 fn test_decimal_to_decimal_coverage() {
10768 let test_cases = [
10769 DecimalCastTestConfig {
10771 input_prec: 5,
10772 input_scale: 1,
10773 input_repr: 99999, output_prec: 10,
10775 output_scale: 6,
10776 expected_output_repr: Ok(9999900000), },
10778 DecimalCastTestConfig {
10780 input_prec: 5,
10781 input_scale: 1,
10782 input_repr: 99, output_prec: 7,
10784 output_scale: 6,
10785 expected_output_repr: Ok(9900000), },
10787 DecimalCastTestConfig {
10789 input_prec: 5,
10790 input_scale: 1,
10791 input_repr: 99999, output_prec: 7,
10793 output_scale: 6,
10794 expected_output_repr: Err("Invalid argument error: 9999900000 is too large to store in a {} of precision 7. Max is 9999999".to_string()) },
10796 DecimalCastTestConfig {
10798 input_prec: 5,
10799 input_scale: 3,
10800 input_repr: 99999, output_prec: 10,
10802 output_scale: 2,
10803 expected_output_repr: Ok(10000), },
10805 DecimalCastTestConfig {
10807 input_prec: 5,
10808 input_scale: 3,
10809 input_repr: 99994, output_prec: 10,
10811 output_scale: 2,
10812 expected_output_repr: Ok(9999), },
10814 DecimalCastTestConfig {
10816 input_prec: 5,
10817 input_scale: 3,
10818 input_repr: 99999, output_prec: 10,
10820 output_scale: 3,
10821 expected_output_repr: Ok(99999), },
10823 DecimalCastTestConfig {
10825 input_prec: 10,
10826 input_scale: 5,
10827 input_repr: 999999, output_prec: 8,
10829 output_scale: 7,
10830 expected_output_repr: Ok(99999900), },
10832 DecimalCastTestConfig {
10834 input_prec: 10,
10835 input_scale: 5,
10836 input_repr: 9999999, output_prec: 8,
10838 output_scale: 7,
10839 expected_output_repr: Err("Invalid argument error: 999999900 is too large to store in a {} of precision 8. Max is 99999999".to_string()) },
10841 DecimalCastTestConfig {
10843 input_prec: 7,
10844 input_scale: 4,
10845 input_repr: 9999999, output_prec: 6,
10847 output_scale: 2,
10848 expected_output_repr: Ok(100000),
10849 },
10850 DecimalCastTestConfig {
10852 input_prec: 10,
10853 input_scale: 5,
10854 input_repr: 12345678, output_prec: 8,
10856 output_scale: 3,
10857 expected_output_repr: Ok(123457), },
10859 DecimalCastTestConfig {
10861 input_prec: 10,
10862 input_scale: 5,
10863 input_repr: 9999999, output_prec: 4,
10865 output_scale: 3,
10866 expected_output_repr: Err("Invalid argument error: 100000 is too large to store in a {} of precision 4. Max is 9999".to_string()) },
10868 DecimalCastTestConfig {
10870 input_prec: 10,
10871 input_scale: 5,
10872 input_repr: 999999, output_prec: 6,
10874 output_scale: 5,
10875 expected_output_repr: Ok(999999), },
10877 DecimalCastTestConfig {
10879 input_prec: 10,
10880 input_scale: 5,
10881 input_repr: 9999999, output_prec: 6,
10883 output_scale: 5,
10884 expected_output_repr: Err("Invalid argument error: 9999999 is too large to store in a {} of precision 6. Max is 999999".to_string()) },
10886 DecimalCastTestConfig {
10888 input_prec: 7,
10889 input_scale: 4,
10890 input_repr: 12345, output_prec: 7,
10892 output_scale: 6,
10893 expected_output_repr: Ok(1234500), },
10895 DecimalCastTestConfig {
10897 input_prec: 7,
10898 input_scale: 4,
10899 input_repr: 123456, output_prec: 7,
10901 output_scale: 6,
10902 expected_output_repr: Err("Invalid argument error: 12345600 is too large to store in a {} of precision 7. Max is 9999999".to_string()) },
10904 DecimalCastTestConfig {
10906 input_prec: 7,
10907 input_scale: 5,
10908 input_repr: 1234567, output_prec: 7,
10910 output_scale: 4,
10911 expected_output_repr: Ok(123457), },
10913 DecimalCastTestConfig {
10915 input_prec: 7,
10916 input_scale: 5,
10917 input_repr: 9999999, output_prec: 7,
10919 output_scale: 5,
10920 expected_output_repr: Ok(9999999), },
10922 DecimalCastTestConfig {
10924 input_prec: 7,
10925 input_scale: 0,
10926 input_repr: 1234567, output_prec: 8,
10928 output_scale: 0,
10929 expected_output_repr: Ok(1234567), },
10931 DecimalCastTestConfig {
10933 input_prec: 7,
10934 input_scale: 0,
10935 input_repr: 1234567, output_prec: 6,
10937 output_scale: 0,
10938 expected_output_repr: Err("Invalid argument error: 1234567 is too large to store in a {} of precision 6. Max is 999999".to_string())
10939 },
10940 DecimalCastTestConfig {
10942 input_prec: 7,
10943 input_scale: 0,
10944 input_repr: 123456, output_prec: 6,
10946 output_scale: 0,
10947 expected_output_repr: Ok(123456), },
10949 ];
10950
10951 for t in test_cases {
10952 run_decimal_cast_test_case_between_multiple_types(t);
10953 }
10954 }
10955
10956 #[test]
10957 fn test_decimal_to_decimal_increase_scale_and_precision_unchecked() {
10958 let test_cases = [
10959 DecimalCastTestConfig {
10960 input_prec: 5,
10961 input_scale: 0,
10962 input_repr: 99999,
10963 output_prec: 10,
10964 output_scale: 5,
10965 expected_output_repr: Ok(9999900000),
10966 },
10967 DecimalCastTestConfig {
10968 input_prec: 5,
10969 input_scale: 0,
10970 input_repr: -99999,
10971 output_prec: 10,
10972 output_scale: 5,
10973 expected_output_repr: Ok(-9999900000),
10974 },
10975 DecimalCastTestConfig {
10976 input_prec: 5,
10977 input_scale: 2,
10978 input_repr: 99999,
10979 output_prec: 10,
10980 output_scale: 5,
10981 expected_output_repr: Ok(99999000),
10982 },
10983 DecimalCastTestConfig {
10984 input_prec: 5,
10985 input_scale: -2,
10986 input_repr: -99999,
10987 output_prec: 10,
10988 output_scale: 3,
10989 expected_output_repr: Ok(-9999900000),
10990 },
10991 DecimalCastTestConfig {
10992 input_prec: 5,
10993 input_scale: 3,
10994 input_repr: -12345,
10995 output_prec: 6,
10996 output_scale: 5,
10997 expected_output_repr: Err("Invalid argument error: -1234500 is too small to store in a {} of precision 6. Min is -999999".to_string())
10998 },
10999 ];
11000
11001 for t in test_cases {
11002 run_decimal_cast_test_case_between_multiple_types(t);
11003 }
11004 }
11005
11006 #[test]
11007 fn test_decimal_to_decimal_decrease_scale_and_precision_unchecked() {
11008 let test_cases = [
11009 DecimalCastTestConfig {
11010 input_prec: 5,
11011 input_scale: 0,
11012 input_repr: 99999,
11013 output_scale: -3,
11014 output_prec: 3,
11015 expected_output_repr: Ok(100),
11016 },
11017 DecimalCastTestConfig {
11018 input_prec: 5,
11019 input_scale: 0,
11020 input_repr: -99999,
11021 output_prec: 1,
11022 output_scale: -5,
11023 expected_output_repr: Ok(-1),
11024 },
11025 DecimalCastTestConfig {
11026 input_prec: 10,
11027 input_scale: 2,
11028 input_repr: 123456789,
11029 output_prec: 5,
11030 output_scale: -2,
11031 expected_output_repr: Ok(12346),
11032 },
11033 DecimalCastTestConfig {
11034 input_prec: 10,
11035 input_scale: 4,
11036 input_repr: -9876543210,
11037 output_prec: 7,
11038 output_scale: 0,
11039 expected_output_repr: Ok(-987654),
11040 },
11041 DecimalCastTestConfig {
11042 input_prec: 7,
11043 input_scale: 4,
11044 input_repr: 9999999,
11045 output_prec: 6,
11046 output_scale: 3,
11047 expected_output_repr:
11048 Err("Invalid argument error: 1000000 is too large to store in a {} of precision 6. Max is 999999".to_string()),
11049 },
11050 ];
11051 for t in test_cases {
11052 run_decimal_cast_test_case_between_multiple_types(t);
11053 }
11054 }
11055
11056 #[test]
11057 fn test_decimal_to_decimal_throw_error_on_precision_overflow_same_scale() {
11058 let array = vec![Some(123456789)];
11059 let array = create_decimal128_array(array, 24, 2).unwrap();
11060 let input_type = DataType::Decimal128(24, 2);
11061 let output_type = DataType::Decimal128(6, 2);
11062 assert!(can_cast_types(&input_type, &output_type));
11063
11064 let options = CastOptions {
11065 safe: false,
11066 ..Default::default()
11067 };
11068 let result = cast_with_options(&array, &output_type, &options);
11069 assert_eq!(result.unwrap_err().to_string(),
11070 "Invalid argument error: 123456789 is too large to store in a Decimal128 of precision 6. Max is 999999");
11071 }
11072
11073 #[test]
11074 fn test_decimal_to_decimal_same_scale() {
11075 let array = vec![Some(520)];
11076 let array = create_decimal128_array(array, 4, 2).unwrap();
11077 let input_type = DataType::Decimal128(4, 2);
11078 let output_type = DataType::Decimal128(3, 2);
11079 assert!(can_cast_types(&input_type, &output_type));
11080
11081 let options = CastOptions {
11082 safe: false,
11083 ..Default::default()
11084 };
11085 let result = cast_with_options(&array, &output_type, &options);
11086 assert_eq!(
11087 result.unwrap().as_primitive::<Decimal128Type>().value(0),
11088 520
11089 );
11090
11091 assert_eq!(
11093 &cast(
11094 &create_decimal128_array(vec![Some(0)], 3, 0).unwrap(),
11095 &DataType::Decimal128(2, 0)
11096 )
11097 .unwrap(),
11098 &(Arc::new(create_decimal128_array(vec![Some(0)], 2, 0).unwrap()) as ArrayRef)
11099 );
11100 }
11101
11102 #[test]
11103 fn test_decimal_to_decimal_throw_error_on_precision_overflow_lower_scale() {
11104 let array = vec![Some(123456789)];
11105 let array = create_decimal128_array(array, 24, 4).unwrap();
11106 let input_type = DataType::Decimal128(24, 4);
11107 let output_type = DataType::Decimal128(6, 2);
11108 assert!(can_cast_types(&input_type, &output_type));
11109
11110 let options = CastOptions {
11111 safe: false,
11112 ..Default::default()
11113 };
11114 let result = cast_with_options(&array, &output_type, &options);
11115 assert_eq!(result.unwrap_err().to_string(),
11116 "Invalid argument error: 1234568 is too large to store in a Decimal128 of precision 6. Max is 999999");
11117 }
11118
11119 #[test]
11120 fn test_decimal_to_decimal_throw_error_on_precision_overflow_greater_scale() {
11121 let array = vec![Some(123456789)];
11122 let array = create_decimal128_array(array, 24, 2).unwrap();
11123 let input_type = DataType::Decimal128(24, 2);
11124 let output_type = DataType::Decimal128(6, 3);
11125 assert!(can_cast_types(&input_type, &output_type));
11126
11127 let options = CastOptions {
11128 safe: false,
11129 ..Default::default()
11130 };
11131 let result = cast_with_options(&array, &output_type, &options);
11132 assert_eq!(result.unwrap_err().to_string(),
11133 "Invalid argument error: 1234567890 is too large to store in a Decimal128 of precision 6. Max is 999999");
11134 }
11135
11136 #[test]
11137 fn test_decimal_to_decimal_throw_error_on_precision_overflow_diff_type() {
11138 let array = vec![Some(123456789)];
11139 let array = create_decimal128_array(array, 24, 2).unwrap();
11140 let input_type = DataType::Decimal128(24, 2);
11141 let output_type = DataType::Decimal256(6, 2);
11142 assert!(can_cast_types(&input_type, &output_type));
11143
11144 let options = CastOptions {
11145 safe: false,
11146 ..Default::default()
11147 };
11148 let result = cast_with_options(&array, &output_type, &options);
11149 assert_eq!(result.unwrap_err().to_string(),
11150 "Invalid argument error: 123456789 is too large to store in a Decimal256 of precision 6. Max is 999999");
11151 }
11152
11153 #[test]
11154 fn test_first_none() {
11155 let array = Arc::new(ListArray::from_iter_primitive::<Int64Type, _, _>(vec![
11156 None,
11157 Some(vec![Some(1), Some(2)]),
11158 ])) as ArrayRef;
11159 let data_type =
11160 DataType::FixedSizeList(FieldRef::new(Field::new("item", DataType::Int64, true)), 2);
11161 let opt = CastOptions::default();
11162 let r = cast_with_options(&array, &data_type, &opt).unwrap();
11163
11164 let fixed_array = Arc::new(FixedSizeListArray::from_iter_primitive::<Int64Type, _, _>(
11165 vec![None, Some(vec![Some(1), Some(2)])],
11166 2,
11167 )) as ArrayRef;
11168 assert_eq!(*fixed_array, *r);
11169 }
11170
11171 #[test]
11172 fn test_first_last_none() {
11173 let array = Arc::new(ListArray::from_iter_primitive::<Int64Type, _, _>(vec![
11174 None,
11175 Some(vec![Some(1), Some(2)]),
11176 None,
11177 ])) as ArrayRef;
11178 let data_type =
11179 DataType::FixedSizeList(FieldRef::new(Field::new("item", DataType::Int64, true)), 2);
11180 let opt = CastOptions::default();
11181 let r = cast_with_options(&array, &data_type, &opt).unwrap();
11182
11183 let fixed_array = Arc::new(FixedSizeListArray::from_iter_primitive::<Int64Type, _, _>(
11184 vec![None, Some(vec![Some(1), Some(2)]), None],
11185 2,
11186 )) as ArrayRef;
11187 assert_eq!(*fixed_array, *r);
11188 }
11189}