@@ -50,27 +50,55 @@ impl TryToDataFusion<ScalarValue> for Scalar {
5050 let precision = decimal_type. precision ( ) ;
5151 let scale = decimal_type. scale ( ) ;
5252
53- if precision <= i128:: MAX_PRECISION {
53+ if precision <= i32:: MAX_PRECISION {
54+ match dscalar. decimal_value ( ) {
55+ None => ScalarValue :: Decimal32 ( None , precision, scale) ,
56+ Some ( value) => match value. cast :: < i32 > ( ) {
57+ Some ( v32) => ScalarValue :: Decimal32 ( Some ( v32) , precision, scale) ,
58+ None => {
59+ vortex_bail ! (
60+ "invalid ScalarValue {value} for decimal with precision {precision}" ,
61+ )
62+ }
63+ } ,
64+ }
65+ } else if precision <= i64:: MAX_PRECISION {
66+ match dscalar. decimal_value ( ) {
67+ None => ScalarValue :: Decimal64 ( None , precision, scale) ,
68+ Some ( value) => match value. cast :: < i64 > ( ) {
69+ Some ( v64) => ScalarValue :: Decimal64 ( Some ( v64) , precision, scale) ,
70+ None => {
71+ vortex_bail ! (
72+ "invalid ScalarValue {value} for decimal with precision {precision}" ,
73+ )
74+ }
75+ } ,
76+ }
77+ } else if precision <= i128:: MAX_PRECISION {
5478 match dscalar. decimal_value ( ) {
5579 None => ScalarValue :: Decimal128 ( None , precision, scale) ,
56- Some ( DecimalValue :: I128 ( v128) ) => {
57- ScalarValue :: Decimal128 ( Some ( v128) , precision, scale)
58- }
59- _ => vortex_bail ! (
60- "invalid ScalarValue for decimal with precision {}" ,
61- precision
62- ) ,
80+ Some ( value) => match value. cast :: < i128 > ( ) {
81+ Some ( v128) => ScalarValue :: Decimal128 ( Some ( v128) , precision, scale) ,
82+ None => {
83+ vortex_bail ! (
84+ "invalid ScalarValue {value} for decimal with precision {precision}" ,
85+ )
86+ }
87+ } ,
6388 }
6489 } else {
6590 match dscalar. decimal_value ( ) {
6691 None => ScalarValue :: Decimal256 ( None , precision, scale) ,
67- Some ( DecimalValue :: I256 ( v256) ) => {
68- ScalarValue :: Decimal256 ( Some ( v256. into ( ) ) , precision, scale)
69- }
70- _ => vortex_bail ! (
71- "invalid ScalarValue for decimal with precision {}" ,
72- precision
73- ) ,
92+ Some ( value) => match value. cast :: < i256 > ( ) {
93+ Some ( v256) => {
94+ ScalarValue :: Decimal256 ( Some ( v256. into ( ) ) , precision, scale)
95+ }
96+ None => {
97+ vortex_bail ! (
98+ "invalid ScalarValue {value} for decimal with precision {precision}" ,
99+ )
100+ }
101+ } ,
74102 }
75103 }
76104 }
@@ -220,6 +248,32 @@ impl FromDataFusion<ScalarValue> for Scalar {
220248 . unwrap_or_else ( vortex:: scalar:: ScalarValue :: null) ,
221249 )
222250 }
251+ ScalarValue :: Decimal32 ( decimal, precision, scale) => {
252+ let decimal_dtype = DecimalDType :: new ( * precision, * scale) ;
253+ let nullable = Nullability :: Nullable ;
254+ if let Some ( value) = decimal {
255+ Scalar :: decimal (
256+ DecimalValue :: I32 ( * value) ,
257+ decimal_dtype,
258+ Nullability :: Nullable ,
259+ )
260+ } else {
261+ Scalar :: null ( DType :: Decimal ( decimal_dtype, nullable) )
262+ }
263+ }
264+ ScalarValue :: Decimal64 ( decimal, precision, scale) => {
265+ let decimal_dtype = DecimalDType :: new ( * precision, * scale) ;
266+ let nullable = Nullability :: Nullable ;
267+ if let Some ( value) = decimal {
268+ Scalar :: decimal (
269+ DecimalValue :: I64 ( * value) ,
270+ decimal_dtype,
271+ Nullability :: Nullable ,
272+ )
273+ } else {
274+ Scalar :: null ( DType :: Decimal ( decimal_dtype, nullable) )
275+ }
276+ }
223277 ScalarValue :: Decimal128 ( decimal, precision, scale) => {
224278 let decimal_dtype = DecimalDType :: new ( * precision, * scale) ;
225279 let nullable = Nullability :: Nullable ;
@@ -366,17 +420,41 @@ mod tests {
366420 }
367421
368422 #[ rstest]
423+ #[ case:: decimal32_some(
424+ Scalar :: decimal(
425+ DecimalValue :: I32 ( 1234 ) ,
426+ DecimalDType :: new( 5 , 2 ) ,
427+ Nullability :: NonNullable
428+ ) ,
429+ ScalarValue :: Decimal32 ( Some ( 1234 ) , 5 , 2 )
430+ ) ]
431+ #[ case:: decimal32_null(
432+ Scalar :: null( DType :: Decimal ( DecimalDType :: new( 5 , 2 ) , Nullability :: Nullable ) ) ,
433+ ScalarValue :: Decimal32 ( None , 5 , 2 )
434+ ) ]
435+ #[ case:: decimal64_some(
436+ Scalar :: decimal(
437+ DecimalValue :: I64 ( 12345 ) ,
438+ DecimalDType :: new( 10 , 2 ) ,
439+ Nullability :: NonNullable
440+ ) ,
441+ ScalarValue :: Decimal64 ( Some ( 12345 ) , 10 , 2 )
442+ ) ]
443+ #[ case:: decimal64_null(
444+ Scalar :: null( DType :: Decimal ( DecimalDType :: new( 10 , 2 ) , Nullability :: Nullable ) ) ,
445+ ScalarValue :: Decimal64 ( None , 10 , 2 )
446+ ) ]
369447 #[ case:: decimal128_some(
370448 Scalar :: decimal(
371449 DecimalValue :: I128 ( 12345 ) ,
372- DecimalDType :: new( 10 , 2 ) ,
450+ DecimalDType :: new( 20 , 2 ) ,
373451 Nullability :: NonNullable
374452 ) ,
375- ScalarValue :: Decimal128 ( Some ( 12345 ) , 10 , 2 )
453+ ScalarValue :: Decimal128 ( Some ( 12345 ) , 20 , 2 )
376454 ) ]
377455 #[ case:: decimal128_null(
378- Scalar :: null( DType :: Decimal ( DecimalDType :: new( 10 , 2 ) , Nullability :: Nullable ) ) ,
379- ScalarValue :: Decimal128 ( None , 10 , 2 )
456+ Scalar :: null( DType :: Decimal ( DecimalDType :: new( 20 , 2 ) , Nullability :: Nullable ) ) ,
457+ ScalarValue :: Decimal128 ( None , 20 , 2 )
380458 ) ]
381459 #[ case:: decimal256_some(
382460 Scalar :: decimal(
@@ -575,8 +653,16 @@ mod tests {
575653 ScalarValue :: Binary ( None )
576654 ) ]
577655 #[ case:: null_decimal128(
656+ Scalar :: null( DType :: Decimal ( DecimalDType :: new( 20 , 2 ) , Nullability :: Nullable ) ) ,
657+ ScalarValue :: Decimal128 ( None , 20 , 2 )
658+ ) ]
659+ #[ case:: null_decimal64(
578660 Scalar :: null( DType :: Decimal ( DecimalDType :: new( 10 , 2 ) , Nullability :: Nullable ) ) ,
579- ScalarValue :: Decimal128 ( None , 10 , 2 )
661+ ScalarValue :: Decimal64 ( None , 10 , 2 )
662+ ) ]
663+ #[ case:: null_decimal32(
664+ Scalar :: null( DType :: Decimal ( DecimalDType :: new( 5 , 2 ) , Nullability :: Nullable ) ) ,
665+ ScalarValue :: Decimal32 ( None , 5 , 2 )
580666 ) ]
581667 fn test_null_handling ( #[ case] vortex_null : Scalar , #[ case] expected_df_null : ScalarValue ) {
582668 // Test Vortex -> DataFusion
0 commit comments