feat(array): cast bool and primitive values to Utf8

Cargo.toml

@@ -176,6 +176,7 @@ indicatif = "0.18.0"
 insta = "1.43"
 inventory = "0.3.20"
 itertools = "0.14.0"
+itoa = "1.0.18"
 jiff = "0.2.28"
 jni = { version = "0.22.0" }
 kanal = "0.1.1"
@@ -238,6 +239,7 @@ rstest = "0.26.1"
 rstest_reuse = "0.7.0"
 rustc-hash = "2.1.1"
 rustix = { version = "1.1", features = ["fs"] }
+ryu = "1.0.23"
 serde = "1.0.221"
 serde_json = "1.0.138"
 serde_test = "1.0.176"

vortex-array/Cargo.toml

@@ -36,6 +36,7 @@ half = { workspace = true, features = ["num-traits"] }
 humansize = { workspace = true }
 inventory = { workspace = true }
 itertools = { workspace = true }
+itoa = { workspace = true }
 jiff = { workspace = true }
 memchr = { workspace = true }
 num-traits = { workspace = true }
@@ -53,6 +54,7 @@ regex-syntax = { workspace = true }
 rstest = { workspace = true, optional = true }
 rstest_reuse = { workspace = true, optional = true }
 rustc-hash = { workspace = true }
+ryu = { workspace = true }
 serde = { workspace = true, optional = true, features = ["derive", "rc"] }
 simdutf8 = { workspace = true }
 smallvec = { workspace = true }

vortex-array/src/arrays/bool/compute/cast.rs

@@ -5,6 +5,7 @@ use num_traits::One;
 use num_traits::Zero;
 use vortex_buffer::BufferMut;
 use vortex_error::VortexResult;
+use vortex_mask::Mask;
 
 use crate::ArrayRef;
 use crate::ExecutionCtx;
@@ -14,6 +15,8 @@ use crate::arrays::Bool;
 use crate::arrays::BoolArray;
 use crate::arrays::PrimitiveArray;
 use crate::arrays::bool::BoolArrayExt;
+use crate::builders::ArrayBuilder;
+use crate::builders::VarBinViewBuilder;
 use crate::dtype::DType;
 use crate::match_each_native_ptype;
 use crate::scalar_fn::fns::cast::CastKernel;
@@ -53,6 +56,36 @@ impl CastKernel for Bool {
             ));
         }
 
+        if let DType::Utf8(new_nullability) = dtype {
+            let len = array.len();
+            let new_validity = array
+                .validity()?
+                .cast_nullability(*new_nullability, len, ctx)?;
+            let mask = new_validity.execute_mask(len, ctx)?;
+            let mut builder = VarBinViewBuilder::with_capacity(dtype.clone(), len);
+
+            match &mask {
+                Mask::AllTrue(_) => {
+                    for value in array.to_bit_buffer().iter() {
+                        builder.append_value(if value { "true" } else { "false" });
+                    }
+                }
+                Mask::AllFalse(_) => builder.append_nulls(len),
+                Mask::Values(validity) => {
+                    let bits = array.to_bit_buffer();
+                    for (value, valid) in bits.iter().zip(validity.bit_buffer().iter()) {
+                        if valid {
+                            builder.append_value(if value { "true" } else { "false" });
+                        } else {
+                            builder.append_null();
+                        }
+                    }
+                }
+            }
+
+            return Ok(Some(builder.finish_into_varbinview().into_array()));
+        }
+
         let DType::Primitive(new_ptype, new_nullability) = dtype else {
             return Ok(None);
         };
@@ -79,12 +112,15 @@ mod tests {
     use std::sync::LazyLock;
 
     use rstest::rstest;
+    use vortex_error::VortexResult;
     use vortex_session::VortexSession;
 
     use crate::Canonical;
     use crate::IntoArray;
     use crate::VortexSessionExecute;
     use crate::arrays::BoolArray;
+    use crate::arrays::VarBinViewArray;
+    use crate::assert_arrays_eq;
     use crate::builtins::ArrayBuiltins;
     use crate::compute::conformance::cast::test_cast_conformance;
     use crate::dtype::DType;
@@ -117,6 +153,81 @@ mod tests {
         assert!(result.is_err(), "Expected error, got: {result:?}");
     }
 
+    #[test]
+    fn cast_bool_to_utf8() -> VortexResult<()> {
+        let mut ctx = SESSION.create_execution_ctx();
+        let actual = BoolArray::from_iter([true, false, true])
+            .into_array()
+            .cast(DType::Utf8(Nullability::NonNullable))?;
+        let expected = VarBinViewArray::from_iter_str(["true", "false", "true"]);
+
+        assert_arrays_eq!(actual, expected, &mut ctx);
+        Ok(())
+    }
+
+    #[test]
+    fn cast_nullable_bool_to_utf8() -> VortexResult<()> {
+        let mut ctx = SESSION.create_execution_ctx();
+        let actual = BoolArray::from_iter([Some(true), None, Some(false)])
+            .into_array()
+            .cast(DType::Utf8(Nullability::Nullable))?;
+        let expected = VarBinViewArray::from_iter_nullable_str([Some("true"), None, Some("false")]);
+
+        assert_arrays_eq!(actual, expected, &mut ctx);
+        Ok(())
+    }
+
+    #[test]
+    fn cast_all_null_bool_to_utf8() -> VortexResult<()> {
+        let mut ctx = SESSION.create_execution_ctx();
+        let actual = BoolArray::from_iter([None, None])
+            .into_array()
+            .cast(DType::Utf8(Nullability::Nullable))?;
+        let expected = VarBinViewArray::from_iter_nullable_str([None::<&str>, None]);
+
+        assert_arrays_eq!(actual, expected, &mut ctx);
+        Ok(())
+    }
+
+    #[test]
+    fn cast_nullable_bool_with_null_to_non_nullable_utf8_fails() -> VortexResult<()> {
+        let mut ctx = SESSION.create_execution_ctx();
+        let result = BoolArray::from_iter([Some(true), None])
+            .into_array()
+            .cast(DType::Utf8(Nullability::NonNullable))?
+            .execute::<Canonical>(&mut ctx);
+
+        assert!(result.is_err(), "Expected error, got: {result:?}");
+        Ok(())
+    }
+
+    #[test]
+    fn cast_all_valid_nullable_bool_to_non_nullable_utf8() -> VortexResult<()> {
+        let mut ctx = SESSION.create_execution_ctx();
+        let actual = BoolArray::from_iter([Some(true), Some(false)])
+            .into_array()
+            .cast(DType::Utf8(Nullability::NonNullable))?;
+        let expected = VarBinViewArray::from_iter_str(["true", "false"]);
+
+        assert_arrays_eq!(actual, expected, &mut ctx);
+        Ok(())
+    }
+
+    #[test]
+    fn cast_bool_to_binary_is_unsupported() {
+        let mut ctx = SESSION.create_execution_ctx();
+        let result = BoolArray::from_iter([true, false])
+            .into_array()
+            .cast(DType::Binary(Nullability::NonNullable))
+            .and_then(|array| {
+                array
+                    .execute::<Canonical>(&mut ctx)
+                    .map(|canonical| canonical.into_array())
+            });
+
+        assert!(result.is_err(), "Expected error, got: {result:?}");
+    }
+
     #[rstest]
     #[case(BoolArray::from_iter(vec![true, false, true, true, false]))]
     #[case(BoolArray::from_iter(vec![Some(true), Some(false), None, Some(true), None]))]

vortex-array/src/arrays/constant/compute/cast.rs

@@ -23,6 +23,7 @@ impl CastReduce for Constant {
 #[cfg(test)]
 mod tests {
     use rstest::rstest;
+    use vortex_error::VortexResult;
 
     use crate::IntoArray;
     use crate::VortexSessionExecute;
@@ -33,6 +34,7 @@ mod tests {
     use crate::dtype::DType;
     use crate::dtype::DecimalDType;
     use crate::dtype::Nullability;
+    use crate::dtype::PType;
     use crate::scalar::DecimalValue;
     use crate::scalar::Scalar;
 
@@ -65,4 +67,42 @@ mod tests {
             Some(DecimalValue::I128(4200))
         );
     }
+
+    #[rstest]
+    #[case(
+        Scalar::from(true),
+        DType::Primitive(PType::I32, Nullability::NonNullable),
+        Scalar::primitive(1i32, Nullability::NonNullable)
+    )]
+    #[case(
+        Scalar::from(false),
+        DType::Utf8(Nullability::Nullable),
+        Scalar::utf8("false", Nullability::Nullable)
+    )]
+    #[case(
+        Scalar::from(-42i64),
+        DType::Utf8(Nullability::NonNullable),
+        Scalar::utf8("-42", Nullability::NonNullable)
+    )]
+    #[case(
+        Scalar::from(100.0f64),
+        DType::Utf8(Nullability::NonNullable),
+        Scalar::utf8("100.0", Nullability::NonNullable)
+    )]
+    #[case(
+        Scalar::null(DType::Primitive(PType::I64, Nullability::Nullable)),
+        DType::Utf8(Nullability::Nullable),
+        Scalar::null(DType::Utf8(Nullability::Nullable))
+    )]
+    fn test_cast_bool_and_primitive_constants(
+        #[case] source: Scalar,
+        #[case] target: DType,
+        #[case] expected: Scalar,
+    ) -> VortexResult<()> {
+        let casted = ConstantArray::new(source, 5).into_array().cast(target)?;
+
+        assert_eq!(casted.len(), 5);
+        assert_eq!(casted.as_constant(), Some(expected));
+        Ok(())
+    }
 }