remove Scalar::new

Signed-off-by: Connor Tsui <connor.tsui20@gmail.com>

Author: connortsui20

Cargo.lock

@@ -46,9 +46,9 @@ impl CompareKernel for DecimalBytePartsVTable {
             .vortex_expect("checked for null in entry func");
 
         match decimal_value_wrapper_to_primitive(rhs_decimal, lhs.msp.as_primitive_typed().ptype())
-            .map(|value| Scalar::new(scalar_type.clone(), Some(value)))
         {
-            Ok(encoded_scalar) => {
+            Ok(value) => {
+                let encoded_scalar = Scalar::try_new(scalar_type, Some(value))?;
                 let encoded_const = ConstantArray::new(encoded_scalar, rhs.len());
                 compare(&lhs.msp, &encoded_const.to_array(), operator).map(Some)
             }
@@ -166,7 +166,7 @@ mod tests {
         .unwrap()
         .to_array();
         let rhs = ConstantArray::new(
-            Scalar::new(dtype, Some(DecimalValue::I64(400).into())),
+            Scalar::try_new(dtype, Some(DecimalValue::I64(400).into())).unwrap(),
             lhs.len(),
         );
 
@@ -218,10 +218,11 @@ mod tests {
         .to_array();
         // This cannot be converted to a i32.
         let rhs = ConstantArray::new(
-            Scalar::new(
+            Scalar::try_new(
                 dtype.clone(),
                 Some(DecimalValue::I128(-9999999999999965304).into()),
-            ),
+            )
+            .unwrap(),
             lhs.len(),
         );
 
@@ -239,7 +240,7 @@ mod tests {
 
         // This cannot be converted to a i32.
         let rhs = ConstantArray::new(
-            Scalar::new(dtype, Some(DecimalValue::I128(9999999999999965304).into())),
+            Scalar::try_new(dtype, Some(DecimalValue::I128(9999999999999965304).into())).unwrap(),
             lhs.len(),
         );
 

encodings/decimal-byte-parts/src/decimal_byte_parts/compute/compare.rs

@@ -270,10 +270,10 @@ impl OperationsVTable<DecimalBytePartsVTable> for DecimalBytePartsVTable {
         let primitive_scalar = scalar.as_primitive();
         // TODO(joe): extend this to support multiple parts.
         let value = primitive_scalar.as_::<i64>().vortex_expect("non-null");
-        Ok(Scalar::new(
+        Scalar::try_new(
             array.dtype.clone(),
             Some(ScalarValue::Decimal(DecimalValue::I64(value))),
-        ))
+        )
     }
 }
 
@@ -325,14 +325,15 @@ mod tests {
 
         assert_eq!(Scalar::null(dtype.clone()), array.scalar_at(0).unwrap());
         assert_eq!(
-            Scalar::new(
+            Scalar::try_new(
                 dtype.clone(),
                 Some(ScalarValue::Decimal(DecimalValue::I64(200)))
-            ),
+            )
+            .unwrap(),
             array.scalar_at(1).unwrap()
         );
         assert_eq!(
-            Scalar::new(dtype, Some(ScalarValue::Decimal(DecimalValue::I64(400)))),
+            Scalar::try_new(dtype, Some(ScalarValue::Decimal(DecimalValue::I64(400)))).unwrap(),
             array.scalar_at(2).unwrap()
         );
     }

encodings/decimal-byte-parts/src/decimal_byte_parts/mod.rs

@@ -96,7 +96,7 @@ impl VTable for FoRVTable {
 
         let encoded = children.get(0, dtype, len)?;
         let scalar_value = ScalarValue::from_proto_bytes(metadata, dtype)?;
-        let reference = Scalar::new(dtype.clone(), Some(scalar_value));
+        let reference = Scalar::try_new(dtype.clone(), Some(scalar_value))?;
 
         FoRArray::try_new(encoded, reference)
     }

encodings/fastlanes/src/for/vtable/mod.rs

@@ -27,7 +27,7 @@ impl OperationsVTable<RLEVTable> for RLEVTable {
             .values()
             .scalar_at(value_idx_offset + chunk_relative_idx)?;
 
-        Ok(Scalar::new(array.dtype().clone(), scalar.into_value()))
+        Scalar::try_new(array.dtype().clone(), scalar.into_value())
     }
 }
 

encodings/fastlanes/src/rle/vtable/operations.rs

@@ -347,10 +347,10 @@ impl BaseArrayVTable<SequenceVTable> for SequenceVTable {
 
 impl OperationsVTable<SequenceVTable> for SequenceVTable {
     fn scalar_at(array: &SequenceArray, index: usize) -> VortexResult<Scalar> {
-        Ok(Scalar::new(
+        Scalar::try_new(
             array.dtype().clone(),
             Some(ScalarValue::Primitive(array.index_value(index))),
-        ))
+        )
     }
 }
 
@@ -415,7 +415,7 @@ mod tests {
 
         assert_eq!(
             scalar,
-            Scalar::new(scalar.dtype().clone(), Some(ScalarValue::from(8i64)))
+            Scalar::try_new(scalar.dtype().clone(), Some(ScalarValue::from(8i64))).unwrap()
         )
     }
 

encodings/sequence/src/array.rs

@@ -48,14 +48,14 @@ impl CastKernel for SequenceVTable {
         // For type changes, we need to cast the base and multiplier
         if array.ptype() != *target_ptype {
             // Create scalars from PValues and cast them
-            let base_scalar = Scalar::new(
+            let base_scalar = Scalar::try_new(
                 DType::Primitive(array.ptype(), Nullability::NonNullable),
                 Some(ScalarValue::Primitive(array.base())),
-            );
-            let multiplier_scalar = Scalar::new(
+            )?;
+            let multiplier_scalar = Scalar::try_new(
                 DType::Primitive(array.ptype(), Nullability::NonNullable),
                 Some(ScalarValue::Primitive(array.multiplier())),
-            );
+            )?;
 
             let new_base_scalar =
                 base_scalar.cast(&DType::Primitive(*target_ptype, Nullability::NonNullable))?;

encodings/sequence/src/compute/cast.rs

@@ -349,10 +349,11 @@ mod tests {
     fn test_sequence_gte_constant() -> VortexResult<()> {
         let seq = SequenceArray::typed_new(0i64, 1, NonNullable, 10)?.to_array();
         let constant = ConstantArray::new(
-            Scalar::new(
+            Scalar::try_new(
                 DType::Primitive(PType::I64, Nullability::Nullable),
                 Some(5i64.into()),
-            ),
+            )
+            .unwrap(),
             10,
         )
         .to_array();

encodings/sequence/src/kernel.rs

@@ -452,7 +452,8 @@ impl<V: VTable> Array for ArrayAdapter<V> {
                         stat,
                         Stat::IsConstant | Stat::IsSorted | Stat::IsStrictSorted
                     ) && value.as_ref().as_exact().is_some_and(|v| {
-                        Scalar::new(DType::Bool(Nullability::NonNullable), Some(v.clone()))
+                        Scalar::try_new(DType::Bool(Nullability::NonNullable), Some(v.clone()))
+                            .vortex_expect("A stat that was expected to be a boolean stat was not")
                             .as_bool()
                             .value()
                             .unwrap_or_default()

vortex-array/src/array/mod.rs

@@ -35,7 +35,7 @@ impl SumKernel for ConstantVTable {
             .ok_or_else(|| vortex_err!("Sum not supported for dtype {}", array.dtype()))?;
 
         let sum_value = sum_scalar(array.scalar(), array.len(), accumulator)?;
-        Ok(Scalar::new(sum_dtype, sum_value))
+        Scalar::try_new(sum_dtype, sum_value)
     }
 }