add cast infra

Signed-off-by: Connor Tsui <[email protected]>

Author: connortsui20

vortex-compute/src/cast/binaryview.rs

@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_dtype::DType;
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+use vortex_vector::Scalar;
+use vortex_vector::ScalarOps;
+use vortex_vector::Vector;
+use vortex_vector::VectorOps;
+use vortex_vector::binaryview::BinaryViewScalar;
+use vortex_vector::binaryview::BinaryViewType;
+use vortex_vector::binaryview::BinaryViewVector;
+
+use crate::cast::Cast;
+use crate::cast::try_cast_scalar_common;
+use crate::cast::try_cast_vector_common;
+
+impl<T: BinaryViewType> Cast for BinaryViewVector<T> {
+    type Output = Vector;
+
+    /// Casts to Utf8 or Binary (identity cast with compatible nullability).
+    fn cast(&self, target_dtype: &DType) -> VortexResult<Vector> {
+        if let Some(result) = try_cast_vector_common(self, target_dtype)? {
+            return Ok(result);
+        }
+
+        match target_dtype {
+            // Identity cast: same type with compatible nullability.
+            dt if T::matches_dtype(dt) && (dt.is_nullable() || self.validity().all_true()) => {
+                Ok(self.clone().into())
+            }
+            // Cross-cast between Utf8 and Binary is not supported.
+            DType::Utf8(_) | DType::Binary(_) => {
+                vortex_bail!(
+                    "Cannot cast BinaryViewVector to {} (cross-cast not supported)",
+                    target_dtype
+                );
+            }
+            _ => {
+                vortex_bail!("Cannot cast BinaryViewVector to {}", target_dtype);
+            }
+        }
+    }
+}
+
+impl<T: BinaryViewType> Cast for BinaryViewScalar<T> {
+    type Output = Scalar;
+
+    /// Casts to Utf8 or Binary (identity cast with compatible nullability).
+    fn cast(&self, target_dtype: &DType) -> VortexResult<Scalar> {
+        if let Some(result) = try_cast_scalar_common(self, target_dtype)? {
+            return Ok(result);
+        }
+
+        match target_dtype {
+            // Identity cast: same type with compatible nullability.
+            dt if T::matches_dtype(dt) && (dt.is_nullable() || self.is_valid()) => {
+                Ok(self.clone().into())
+            }
+            // Cross-cast between Utf8 and Binary is not supported.
+            DType::Utf8(_) | DType::Binary(_) => {
+                vortex_bail!(
+                    "Cannot cast BinaryViewScalar to {} (cross-cast not supported)",
+                    target_dtype
+                );
+            }
+            _ => {
+                vortex_bail!("Cannot cast BinaryViewScalar to {}", target_dtype);
+            }
+        }
+    }
+}

vortex-compute/src/cast/bool.rs

@@ -8,29 +8,33 @@ use vortex_dtype::DType;
 use vortex_dtype::match_each_native_ptype;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
+use vortex_vector::Scalar;
+use vortex_vector::ScalarOps;
 use vortex_vector::Vector;
 use vortex_vector::VectorOps;
+use vortex_vector::bool::BoolScalar;
 use vortex_vector::bool::BoolVector;
-use vortex_vector::null::NullVector;
+use vortex_vector::primitive::PScalar;
 use vortex_vector::primitive::PVector;
 
 use crate::cast::Cast;
+use crate::cast::try_cast_scalar_common;
+use crate::cast::try_cast_vector_common;
 
 impl Cast for BoolVector {
     type Output = Vector;
 
-    fn cast(&self, dtype: &DType) -> VortexResult<Vector> {
-        match dtype {
-            DType::Null if self.validity().all_false() => {
-                // Can cast an all-null BoolVector to NullVector.
-                Ok(NullVector::new(self.len()).into())
-            }
+    /// Casts to Bool (identity) or Primitive (as 0/1).
+    fn cast(&self, target_dtype: &DType) -> VortexResult<Vector> {
+        if let Some(result) = try_cast_vector_common(self, target_dtype)? {
+            return Ok(result);
+        }
+
+        match target_dtype {
             DType::Bool(n) if n.is_nullable() || self.validity().all_true() => {
-                // If the target dtype is nullable, or if the source BoolVector has no nulls,
-                // we can cast directly to BoolVector.
                 Ok(self.clone().into())
             }
-            DType::Primitive(ptype, _) => {
+            DType::Primitive(ptype, n) if n.is_nullable() || self.validity().all_true() => {
                 match_each_native_ptype!(ptype, |T| {
                     Ok(PVector::<T>::new(
                         Buffer::<T>::from_trusted_len_iter(
@@ -43,9 +47,31 @@ impl Cast for BoolVector {
                     .into())
                 })
             }
-            DType::Extension(ext_dtype) => self.cast(ext_dtype.storage_dtype()),
             _ => {
-                vortex_bail!("Cannot cast BoolVector to type {}", dtype);
+                vortex_bail!("Cannot cast BoolVector to {}", target_dtype);
+            }
+        }
+    }
+}
+
+impl Cast for BoolScalar {
+    type Output = Scalar;
+
+    /// Casts to Bool (identity) or Primitive (as 0/1).
+    fn cast(&self, target_dtype: &DType) -> VortexResult<Scalar> {
+        if let Some(result) = try_cast_scalar_common(self, target_dtype)? {
+            return Ok(result);
+        }
+        match target_dtype {
+            DType::Bool(n) if n.is_nullable() || self.is_valid() => Ok(self.clone().into()),
+            DType::Primitive(ptype, n) if n.is_nullable() || self.is_valid() => {
+                match_each_native_ptype!(ptype, |T| {
+                    let value = self.value().map(|b| if b { T::one() } else { T::zero() });
+                    Ok(PScalar::<T>::new(value).into())
+                })
+            }
+            _ => {
+                vortex_bail!("Cannot cast BoolScalar to {}", target_dtype);
             }
         }
     }

vortex-compute/src/cast/decimal.rs

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_dtype::DType;
+use vortex_error::VortexResult;
+use vortex_vector::Scalar;
+use vortex_vector::Vector;
+use vortex_vector::decimal::DecimalScalar;
+use vortex_vector::decimal::DecimalVector;
+use vortex_vector::match_each_dscalar;
+use vortex_vector::match_each_dvector;
+
+use crate::cast::Cast;
+
+impl Cast for DecimalVector {
+    type Output = Vector;
+
+    /// Dispatches to the underlying [`DVector<D>`](vortex_vector::decimal::DVector) implementation.
+    fn cast(&self, target_dtype: &DType) -> VortexResult<Vector> {
+        match_each_dvector!(self, |v| { Cast::cast(v, target_dtype) })
+    }
+}
+
+impl Cast for DecimalScalar {
+    type Output = Scalar;
+
+    /// Dispatches to the underlying [`DScalar<D>`](vortex_vector::decimal::DScalar) implementation.
+    fn cast(&self, target_dtype: &DType) -> VortexResult<Scalar> {
+        match_each_dscalar!(self, |s| { Cast::cast(s, target_dtype) })
+    }
+}

vortex-compute/src/cast/dvector.rs

@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_dtype::DType;
+use vortex_dtype::NativeDecimalType;
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+use vortex_vector::Scalar;
+use vortex_vector::ScalarOps;
+use vortex_vector::Vector;
+use vortex_vector::VectorOps;
+use vortex_vector::decimal::DScalar;
+use vortex_vector::decimal::DVector;
+
+use crate::cast::Cast;
+use crate::cast::try_cast_scalar_common;
+use crate::cast::try_cast_vector_common;
+
+impl<D: NativeDecimalType> Cast for DVector<D> {
+    type Output = Vector;
+
+    /// Casts to Decimal (identity with same precision/scale and compatible nullability).
+    fn cast(&self, target_dtype: &DType) -> VortexResult<Vector> {
+        if let Some(result) = try_cast_vector_common(self, target_dtype)? {
+            return Ok(result);
+        }
+
+        match target_dtype {
+            // Identity cast: same precision, scale, and compatible nullability.
+            DType::Decimal(ddt, n)
+                if ddt.precision() == self.precision()
+                    && ddt.scale() == self.scale()
+                    && (n.is_nullable() || self.validity().all_true()) =>
+            {
+                Ok(self.clone().into())
+            }
+            // TODO(connor): cast to different precision/scale
+            DType::Decimal(..) => {
+                vortex_bail!(
+                    "Casting DVector to {} with different precision/scale not yet implemented",
+                    target_dtype
+                );
+            }
+            _ => {
+                vortex_bail!("Cannot cast DVector to {}", target_dtype);
+            }
+        }
+    }
+}
+
+impl<D: NativeDecimalType> Cast for DScalar<D> {
+    type Output = Scalar;
+
+    /// Casts to Decimal (identity with same precision/scale and compatible nullability).
+    fn cast(&self, target_dtype: &DType) -> VortexResult<Scalar> {
+        if let Some(result) = try_cast_scalar_common(self, target_dtype)? {
+            return Ok(result);
+        }
+
+        match target_dtype {
+            // Identity cast: same precision, scale, and compatible nullability.
+            DType::Decimal(ddt, n)
+                if ddt.precision() == self.precision()
+                    && ddt.scale() == self.scale()
+                    && (n.is_nullable() || self.is_valid()) =>
+            {
+                Ok(self.clone().into())
+            }
+            // TODO(connor): cast to different precision/scale
+            DType::Decimal(..) => {
+                vortex_bail!(
+                    "Casting DScalar to {} with different precision/scale not yet implemented",
+                    target_dtype
+                );
+            }
+            _ => {
+                vortex_bail!("Cannot cast DScalar to {}", target_dtype);
+            }
+        }
+    }
+}

vortex-compute/src/cast/fixed_size_list.rs

@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use vortex_dtype::DType;
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+use vortex_vector::Scalar;
+use vortex_vector::ScalarOps;
+use vortex_vector::Vector;
+use vortex_vector::VectorOps;
+use vortex_vector::fixed_size_list::FixedSizeListScalar;
+use vortex_vector::fixed_size_list::FixedSizeListVector;
+use vortex_vector::vector_matches_dtype;
+
+use crate::cast::Cast;
+use crate::cast::try_cast_scalar_common;
+use crate::cast::try_cast_vector_common;
+
+impl Cast for FixedSizeListVector {
+    type Output = Vector;
+
+    /// Casts to FixedSizeList (identity with same element dtype, size, and compatible nullability).
+    fn cast(&self, target_dtype: &DType) -> VortexResult<Vector> {
+        if let Some(result) = try_cast_vector_common(self, target_dtype)? {
+            return Ok(result);
+        }
+
+        match target_dtype {
+            // Identity cast: same element dtype, size, and compatible nullability.
+            DType::FixedSizeList(element_dtype, size, n)
+                if *size == self.list_size()
+                    && vector_matches_dtype(self.elements(), element_dtype)
+                    && (n.is_nullable() || self.validity().all_true()) =>
+            {
+                Ok(self.clone().into())
+            }
+            DType::FixedSizeList(..) => {
+                vortex_bail!(
+                    "Cannot cast FixedSizeListVector to {} (incompatible element type or size)",
+                    target_dtype
+                );
+            }
+            _ => {
+                vortex_bail!("Cannot cast FixedSizeListVector to {}", target_dtype);
+            }
+        }
+    }
+}
+
+impl Cast for FixedSizeListScalar {
+    type Output = Scalar;
+
+    /// Casts to FixedSizeList (identity with same element dtype, size, and compatible nullability).
+    fn cast(&self, target_dtype: &DType) -> VortexResult<Scalar> {
+        if let Some(result) = try_cast_scalar_common(self, target_dtype)? {
+            return Ok(result);
+        }
+
+        match target_dtype {
+            // Identity cast: same element dtype, size, and compatible nullability.
+            // We check by verifying the scalar's underlying vector matches the target dtype.
+            DType::FixedSizeList(element_dtype, size, n)
+                if *size == self.value().list_size()
+                    && vector_matches_dtype(self.value().elements(), element_dtype)
+                    && (n.is_nullable() || self.is_valid()) =>
+            {
+                Ok(self.clone().into())
+            }
+            DType::FixedSizeList(..) => {
+                vortex_bail!(
+                    "Cannot cast FixedSizeListScalar to {} (incompatible element type, size, or nullability)",
+                    target_dtype
+                );
+            }
+            _ => {
+                vortex_bail!("Cannot cast FixedSizeListScalar to {}", target_dtype);
+            }
+        }
+    }
+}