remove utf8 scalar to_value

connortsui20 · connortsui20 · commit 323dfb5032b7 · 2026-02-06T15:00:11.000-05:00
Signed-off-by: Connor Tsui &lt;connor.tsui20@gmail.com&gt;
diff --git a/encodings/fsst/src/compute/compare.rs b/encodings/fsst/src/compute/compare.rs
@@ -97,7 +97,7 @@ fn compare_fsst_constant(
         DType::Utf8(_) => {
             let value = right
                 .as_utf8()
-                .to_value()
+                .value()
                 .vortex_expect("Expected non-null scalar");
             ByteBuffer::from(compressor.compress(value.as_bytes()))
         }
diff --git a/encodings/fsst/src/compute/mod.rs b/encodings/fsst/src/compute/mod.rs
@@ -40,10 +40,7 @@ impl TakeExecute for FSSTVTable {
                     .map_err(|_| vortex_err!("take for codes must return varbin array"))?,
                 fill_null(
                     &array.uncompressed_lengths().take(indices.to_array())?,
-                    &Scalar::new(
-                        array.uncompressed_lengths_dtype().clone(),
-                        &Scalar::zero_value(&array.uncompressed_lengths_dtype().clone()),
-                    ),
+                    &Scalar::zero_value(&array.uncompressed_lengths_dtype().clone()),
                 )?,
             )?
             .into_array(),
diff --git a/encodings/sparse/src/canonical.rs b/encodings/sparse/src/canonical.rs
@@ -97,7 +97,7 @@ pub(super) fn execute_sparse(array: &SparseArray) -> VortexResult<ArrayRef> {
             })
         }
         dtype @ DType::Utf8(..) => {
-            let fill_value = array.fill_scalar().as_utf8().to_value();
+            let fill_value = array.fill_scalar().as_utf8().value().cloned();
             let fill_value = fill_value.map(BufferString::into_inner);
             execute_varbin(array, dtype.clone(), fill_value)?
         }
diff --git a/fuzz/src/array/compare.rs b/fuzz/src/array/compare.rs
@@ -110,7 +110,7 @@ pub fn compare_canonical_array(array: &dyn Array, value: &Scalar, operator: Oper
             let utf8_value = value.as_utf8();
             compare_to(
                 iter.map(|v| v.map(|b| unsafe { str::from_utf8_unchecked(b) })),
-                utf8_value.value_ref().vortex_expect("nulls handled before"),
+                utf8_value.value().vortex_expect("nulls handled before"),
                 operator,
                 result_nullability,
             )
diff --git a/fuzz/src/array/fill_null.rs b/fuzz/src/array/fill_null.rs
@@ -176,7 +176,7 @@ fn fill_varbinview_array(
                 DType::Utf8(_) => {
                     let fill_str = fill_value
                         .as_utf8()
-                        .to_value()
+                        .value()
                         .vortex_expect("cannot have null fill value");
                     let strings: Vec<String> = (0..array.len())
                         .map(|i| {
@@ -185,7 +185,7 @@ fn fill_varbinview_array(
                                     .scalar_at(i)
                                     .vortex_expect("scalar_at")
                                     .as_utf8()
-                                    .to_value()
+                                    .value()
                                     .vortex_expect("cannot have null valid value")
                                     .to_string()
                             } else {
diff --git a/vortex-array/src/arrays/constant/vtable/canonical.rs b/vortex-array/src/arrays/constant/vtable/canonical.rs
@@ -113,7 +113,7 @@ pub(crate) fn constant_canonicalize(array: &ConstantArray) -> VortexResult<Canon
         DType::Utf8(_) => {
             let value = Utf8Scalar::try_from(scalar)
                 .vortex_expect("Must be a utf8 scalar")
-                .to_value();
+                .value();
             let const_value = value.as_ref().map(|v| v.as_bytes());
             Canonical::VarBinView(constant_canonical_byte_view(
                 const_value,
diff --git a/vortex-array/src/arrays/dict/take.rs b/vortex-array/src/arrays/dict/take.rs
@@ -155,7 +155,8 @@ pub(crate) fn propagate_take_stats(
                 source
                     .statistics()
                     .get(stat)
-                    .map(|v| (stat, v.map(|s| s.into_value()).into_inexact()))
+                    .and_then(|v| v.map(|s| s.into_value()).into_inexact().transpose())
+                    .map(|sv| (stat, sv))
             })
             .collect::<Vec<_>>();
         st.combine_sets(
diff --git a/vortex-array/src/arrays/varbin/compute/compare.rs b/vortex-array/src/arrays/varbin/compute/compare.rs
@@ -86,7 +86,7 @@ impl CompareKernel for VarBinVTable {
             let arrow_rhs: &dyn arrow_array::Datum = match rhs_const.dtype() {
                 DType::Utf8(_) => &rhs_const
                     .as_utf8()
-                    .to_value()
+                    .value()
                     .map(StringArray::new_scalar)
                     .unwrap_or_else(|| arrow_array::Scalar::new(StringArray::new_null(1))),
                 DType::Binary(_) => &rhs_const
diff --git a/vortex-array/src/builders/varbinview.rs b/vortex-array/src/builders/varbinview.rs
@@ -254,7 +254,7 @@ impl ArrayBuilder for VarBinViewBuilder {
         match self.dtype() {
             DType::Utf8(_) => {
                 let utf8_scalar = Utf8Scalar::try_from(scalar)?;
-                match utf8_scalar.to_value() {
+                match utf8_scalar.value() {
                     Some(value) => self.append_value(value),
                     None => self.append_null(),
                 }
diff --git a/vortex-array/src/expr/exprs/like.rs b/vortex-array/src/expr/exprs/like.rs
@@ -153,13 +153,13 @@ impl VTable for Like {
         let pat = expr.child(1).as_::<Literal>();
 
         // LIKE NULL is nonsensical, don't try to handle it
-        let pat_str = pat.as_utf8().to_value()?;
+        let pat_str = pat.as_utf8().value()?;
 
         let src = expr.child(0).clone();
         let src_min = src.stat_min(catalog)?;
         let src_max = src.stat_max(catalog)?;
 
-        match LikeVariant::from_str(&pat_str)? {
+        match LikeVariant::from_str(pat_str)? {
             LikeVariant::Exact(text) => {
                 // col LIKE 'exact' ==>  col.min > 'exact' || col.max < 'exact'
                 Some(or(gt(src_min, lit(text)), lt(src_max, lit(text))))
diff --git a/vortex-array/src/expr/stats/precision.rs b/vortex-array/src/expr/stats/precision.rs
@@ -40,7 +40,7 @@ where
 }
 
 impl<T> Precision<Option<T>> {
-    /// Transpose the `Option<Precision<T>>` into `Option<Precision<T>>`.
+    /// Transpose the `Precision<Option<T>>` into `Option<Precision<T>>`.
     pub fn transpose(self) -> Option<Precision<T>> {
         match self {
             Exact(Some(x)) => Some(Exact(x)),
diff --git a/vortex-datafusion/src/convert/scalars.rs b/vortex-datafusion/src/convert/scalars.rs
@@ -102,7 +102,7 @@ impl TryToDataFusion<ScalarValue> for Scalar {
                 }
             }
             // SAFETY: By construction Utf8 scalar values are utf8
-            DType::Utf8(_) => ScalarValue::Utf8(self.as_utf8().to_value().map(|s| unsafe {
+            DType::Utf8(_) => ScalarValue::Utf8(self.as_utf8().value().cloned().map(|s| unsafe {
                 String::from_utf8_unchecked(Vec::<u8>::from(s.into_inner().into_inner()))
             })),
             DType::Binary(_) => ScalarValue::Binary(
@@ -669,10 +669,7 @@ mod tests {
     #[case::large_utf8(ScalarValue::LargeUtf8(Some("test string".to_string())))]
     fn test_utf8_variants(#[case] variant: ScalarValue) {
         let result = Scalar::from_df(&variant);
-        assert_eq!(
-            result.as_utf8().value_ref().unwrap().as_str(),
-            "test string"
-        );
+        assert_eq!(result.as_utf8().value().unwrap().as_str(), "test string");
     }
 
     #[rstest]
diff --git a/vortex-duckdb/src/convert/scalar.rs b/vortex-duckdb/src/convert/scalar.rs
@@ -146,7 +146,7 @@ impl ToDuckDBScalar for BoolScalar<'_> {
 impl ToDuckDBScalar for Utf8Scalar<'_> {
     /// Converts a UTF-8 string scalar to a DuckDB VARCHAR value.
     fn try_to_duckdb_scalar(&self) -> VortexResult<Value> {
-        Ok(match self.value_ref() {
+        Ok(match self.value() {
             Some(value) => Value::from(value.as_str()),
             None => Value::null(&LogicalType::varchar()),
         })
diff --git a/vortex-ffi/src/array.rs b/vortex-ffi/src/array.rs
@@ -159,7 +159,7 @@ pub unsafe extern "C-unwind" fn vx_array_get_utf8(
         .scalar_at(index as usize)
         .vortex_expect("scalar_at failed");
     let utf8_scalar = value.as_utf8();
-    if let Some(buffer) = utf8_scalar.value_ref() {
+    if let Some(buffer) = utf8_scalar.value() {
         vx_string::new(Arc::from(buffer.as_str()))
     } else {
         ptr::null()
diff --git a/vortex-jni/src/array.rs b/vortex-jni/src/array.rs
@@ -422,7 +422,7 @@ pub extern "system" fn Java_dev_vortex_jni_NativeArrayMethods_getUTF8<'local>(
     let array_ref = unsafe { NativeArray::from_ptr(array_ptr) };
     try_or_throw(&mut env, |env| {
         let value = array_ref.inner.scalar_at(index as usize)?;
-        match value.as_utf8().value_ref() {
+        match value.as_utf8().value() {
             None => Ok(JObject::null().into_raw()),
             Some(buf_str) => Ok(env.new_string(buf_str.as_str())?.into_raw()),
         }
diff --git a/vortex-layout/src/layouts/zoned/builder.rs b/vortex-layout/src/layouts/zoned/builder.rs
@@ -218,7 +218,8 @@ impl ScalarTruncation for Utf8Scalar<'_> {
     }
 
     fn into_scalar(self) -> Scalar {
-        self.to_value()
+        self.value()
+            .cloned()
             .map(|b| Scalar::utf8(b, self.dtype().nullability()))
             .unwrap_or_else(|| Scalar::null(self.dtype().clone()))
     }
diff --git a/vortex-python/src/scalar/into_py.rs b/vortex-python/src/scalar/into_py.rs
@@ -64,7 +64,13 @@ impl<'py> IntoPyObject<'py> for PyVortex<&'_ Scalar> {
                     Some(value) => decimal_value_to_py(py, decimal_type.scale(), value),
                 }
             }
-            DType::Utf8(_) => self.0.as_utf8().to_value().map(PyVortex).into_pyobject(py),
+            DType::Utf8(_) => self
+                .0
+                .as_utf8()
+                .value()
+                .cloned()
+                .map(PyVortex)
+                .into_pyobject(py),
             DType::Binary(_) => self
                 .0
                 .as_binary()
diff --git a/vortex-scalar/src/arrow.rs b/vortex-scalar/src/arrow.rs
@@ -108,7 +108,7 @@ impl TryFrom<&Scalar> for Arc<dyn Datum> {
                 ))),
             },
             DType::Utf8(_) => {
-                value_to_arrow_scalar!(value.as_utf8().to_value(), StringViewArray)
+                value_to_arrow_scalar!(value.as_utf8().value(), StringViewArray)
             }
             DType::Binary(_) => {
                 value_to_arrow_scalar!(value.as_binary().to_value(), BinaryViewArray)
diff --git a/vortex-scalar/src/convert/from_scalar.rs b/vortex-scalar/src/convert/from_scalar.rs
@@ -217,7 +217,7 @@ impl<'a> TryFrom<&'a Scalar> for Option<BufferString> {
     type Error = VortexError;
 
     fn try_from(scalar: &'a Scalar) -> Result<Self, Self::Error> {
-        Ok(Utf8Scalar::try_from(scalar)?.to_value())
+        Ok(Utf8Scalar::try_from(scalar)?.value().cloned())
     }
 }
 
diff --git a/vortex-scalar/src/list.rs b/vortex-scalar/src/list.rs
@@ -573,10 +573,10 @@ mod tests {
         assert_eq!(list.len(), 2);
 
         let elem0 = list.element(0).unwrap();
-        assert_eq!(elem0.as_utf8().to_value().unwrap().as_str(), "hello");
+        assert_eq!(elem0.as_utf8().value().unwrap().as_str(), "hello");
 
         let elem1 = list.element(1).unwrap();
-        assert_eq!(elem1.as_utf8().to_value().unwrap().as_str(), "world");
+        assert_eq!(elem1.as_utf8().value().unwrap().as_str(), "world");
     }
 
     #[test]
diff --git a/vortex-scalar/src/struct_.rs b/vortex-scalar/src/struct_.rs
@@ -414,7 +414,7 @@ mod tests {
         let field_b = scalar.as_struct().field("b");
         assert!(field_b.is_some());
         assert_eq!(
-            field_b.unwrap().as_utf8().to_value().unwrap(),
+            field_b.unwrap().as_utf8().value().cloned().unwrap(),
             "world".into()
         );
 
@@ -438,7 +438,7 @@ mod tests {
             .collect::<Vec<_>>();
         assert_eq!(fields.len(), 2);
         assert_eq!(fields[0].as_primitive().typed_value::<i32>().unwrap(), 100);
-        assert_eq!(fields[1].as_utf8().to_value().unwrap(), "test".into());
+        assert_eq!(fields[1].as_utf8().value().cloned().unwrap(), "test".into());
     }
 
     #[test]
@@ -550,7 +550,7 @@ mod tests {
 
         let fields = projected_struct.fields_iter().unwrap().collect::<Vec<_>>();
         assert_eq!(fields.len(), 1);
-        assert_eq!(fields[0].as_utf8().to_value().unwrap().as_str(), "hello");
+        assert_eq!(fields[0].as_utf8().value().unwrap().as_str(), "hello");
     }
 
     #[test]
diff --git a/vortex-scalar/src/tests/nested.rs b/vortex-scalar/src/tests/nested.rs
@@ -226,7 +226,13 @@ mod tests {
             Some(100)
         );
         assert_eq!(
-            first.field("b").unwrap().as_utf8().to_value().unwrap(),
+            first
+                .field("b")
+                .unwrap()
+                .as_utf8()
+                .value()
+                .cloned()
+                .unwrap(),
             "first".into()
         );
     }
@@ -277,7 +283,7 @@ mod tests {
                 .field("name")
                 .unwrap()
                 .as_utf8()
-                .value_ref()
+                .value()
                 .unwrap()
                 .as_str(),
             "test_struct"
@@ -1150,30 +1156,15 @@ mod tests {
 
         let list = string_list.as_list();
         assert_eq!(
-            list.element(0)
-                .unwrap()
-                .as_utf8()
-                .value_ref()
-                .unwrap()
-                .as_str(),
+            list.element(0).unwrap().as_utf8().value().unwrap().as_str(),
             "hello"
         );
         assert_eq!(
-            list.element(1)
-                .unwrap()
-                .as_utf8()
-                .value_ref()
-                .unwrap()
-                .as_str(),
+            list.element(1).unwrap().as_utf8().value().unwrap().as_str(),
             "world"
         );
         assert_eq!(
-            list.element(2)
-                .unwrap()
-                .as_utf8()
-                .value_ref()
-                .unwrap()
-                .as_str(),
+            list.element(2).unwrap().as_utf8().value().unwrap().as_str(),
             "test"
         );
     }
@@ -1414,7 +1405,7 @@ mod tests {
                 .field("key")
                 .unwrap()
                 .as_utf8()
-                .value_ref()
+                .value()
                 .unwrap()
                 .as_str(),
             "first"
@@ -1476,7 +1467,7 @@ mod tests {
                 .element(0)
                 .unwrap()
                 .as_utf8()
-                .value_ref()
+                .value()
                 .unwrap()
                 .as_str(),
             "rust"
diff --git a/vortex-scalar/src/tests/round_trip.rs b/vortex-scalar/src/tests/round_trip.rs
@@ -99,7 +99,7 @@ mod tests {
         // Test Utf8Scalar
         let utf8_scalar = Scalar::utf8("hello".to_string(), Nullability::NonNullable);
         let utf8_specialized = Utf8Scalar::try_from(&utf8_scalar).unwrap();
-        assert_eq!(utf8_specialized.value_ref().unwrap().as_str(), "hello");
+        assert_eq!(utf8_specialized.value().unwrap().as_str(), "hello");
 
         // Test BinaryScalar
         let binary_scalar = Scalar::binary(vec![1, 2, 3, 4], Nullability::NonNullable);
diff --git a/vortex-scalar/src/utf8.rs b/vortex-scalar/src/utf8.rs

Original file line number	Diff line number	Diff line change
`@@ -97,7 +97,7 @@ fn compare_fsst_constant(`
`97`	`97`	`DType::Utf8(_) => {`
`98`	`98`	`let value = right`
`99`	`99`	`.as_utf8()`
`100`		`- .to_value()`
	`100`	`+ .value()`
`101`	`101`	`.vortex_expect("Expected non-null scalar");`
`102`	`102`	`ByteBuffer::from(compressor.compress(value.as_bytes()))`
`103`	`103`	`}`
Original file line number	Diff line number	Diff line change
`@@ -97,7 +97,7 @@ pub(super) fn execute_sparse(array: &SparseArray) -> VortexResult<ArrayRef> {`
`97`	`97`	`})`
`98`	`98`	`}`
`99`	`99`	`dtype @ DType::Utf8(..) => {`
`100`		`- let fill_value = array.fill_scalar().as_utf8().to_value();`
	`100`	`+ let fill_value = array.fill_scalar().as_utf8().value().cloned();`
`101`	`101`	`let fill_value = fill_value.map(BufferString::into_inner);`
`102`	`102`	`execute_varbin(array, dtype.clone(), fill_value)?`
`103`	`103`	`}`
Original file line number	Diff line number	Diff line change
`@@ -110,7 +110,7 @@ pub fn compare_canonical_array(array: &dyn Array, value: &Scalar, operator: Oper`
`110`	`110`	`let utf8_value = value.as_utf8();`
`111`	`111`	`compare_to(`
`112`	`112`	`iter.map(\|v\| v.map(\|b\| unsafe { str::from_utf8_unchecked(b) })),`
`113`		`- utf8_value.value_ref().vortex_expect("nulls handled before"),`
	`113`	`+ utf8_value.value().vortex_expect("nulls handled before"),`
`114`	`114`	`operator,`
`115`	`115`	`result_nullability,`
`116`	`116`	`)`
Original file line number	Diff line number	Diff line change
`@@ -254,7 +254,7 @@ impl ArrayBuilder for VarBinViewBuilder {`
`254`	`254`	`match self.dtype() {`
`255`	`255`	`DType::Utf8(_) => {`
`256`	`256`	`let utf8_scalar = Utf8Scalar::try_from(scalar)?;`
`257`		`- match utf8_scalar.to_value() {`
	`257`	`+ match utf8_scalar.value() {`
`258`	`258`	`Some(value) => self.append_value(value),`
`259`	`259`	`None => self.append_null(),`
`260`	`260`	`}`