|
| 1 | +// SPDX-License-Identifier: Apache-2.0 |
| 2 | +// SPDX-FileCopyrightText: Copyright the Vortex contributors |
| 3 | + |
| 4 | +//! Conversion logic from this "legacy" scalar crate to Vortex Vector scalars. |
| 5 | +
|
| 6 | +use std::sync::Arc; |
| 7 | + |
| 8 | +use vortex_buffer::Buffer; |
| 9 | +use vortex_dtype::{ |
| 10 | + DType, DecimalType, PrecisionScale, match_each_decimal_value_type, match_each_native_ptype, |
| 11 | +}; |
| 12 | +use vortex_error::VortexExpect; |
| 13 | +use vortex_mask::Mask; |
| 14 | +use vortex_vector::binaryview::{BinaryScalar, StringScalar}; |
| 15 | +use vortex_vector::bool::BoolScalar; |
| 16 | +use vortex_vector::decimal::DScalar; |
| 17 | +use vortex_vector::fixed_size_list::{FixedSizeListScalar, FixedSizeListVector}; |
| 18 | +use vortex_vector::listview::{ListViewScalar, ListViewVector, ListViewVectorMut}; |
| 19 | +use vortex_vector::null::NullScalar; |
| 20 | +use vortex_vector::primitive::{PScalar, PVector}; |
| 21 | +use vortex_vector::struct_::{StructScalar, StructVector}; |
| 22 | +use vortex_vector::{VectorMut, VectorMutOps}; |
| 23 | + |
| 24 | +use crate::Scalar; |
| 25 | + |
| 26 | +impl Scalar { |
| 27 | + /// Convert the `vortex-scalar` [`Scalar`] into a `vortex-vector` [`vortex_vector::Scalar`]. |
| 28 | + pub fn to_vector_scalar(&self) -> vortex_vector::Scalar { |
| 29 | + match self.dtype() { |
| 30 | + DType::Null => NullScalar.into(), |
| 31 | + DType::Bool(_) => BoolScalar::new(self.as_bool().value()).into(), |
| 32 | + DType::Primitive(ptype, _) => { |
| 33 | + match_each_native_ptype!(ptype, |T| { |
| 34 | + PScalar::new(self.as_primitive().typed_value::<T>()).into() |
| 35 | + }) |
| 36 | + } |
| 37 | + DType::Decimal(dec_dtype, _) => { |
| 38 | + let dscalar = self.as_decimal(); |
| 39 | + let dec_type = DecimalType::smallest_decimal_value_type(dec_dtype); |
| 40 | + match_each_decimal_value_type!(dec_type, |D| { |
| 41 | + let ps = PrecisionScale::<D>::new(dec_dtype.precision(), dec_dtype.scale()); |
| 42 | + DScalar::maybe_new( |
| 43 | + ps, |
| 44 | + dscalar |
| 45 | + .decimal_value() |
| 46 | + .map(|d| d.cast::<D>().vortex_expect("Failed to cast decimal value")), |
| 47 | + ) |
| 48 | + .vortex_expect("Failed to create decimal scalar") |
| 49 | + .into() |
| 50 | + }) |
| 51 | + } |
| 52 | + DType::Utf8(_) => StringScalar::new(self.as_utf8().value()).into(), |
| 53 | + DType::Binary(_) => BinaryScalar::new(self.as_binary().value()).into(), |
| 54 | + DType::List(elems_dtype, _) => { |
| 55 | + let lscalar = self.as_list(); |
| 56 | + match lscalar.elements() { |
| 57 | + None => { |
| 58 | + let mut list_view = ListViewVectorMut::with_capacity(elems_dtype, 1); |
| 59 | + list_view.append_nulls(1); |
| 60 | + ListViewScalar::new(list_view.freeze()).into() |
| 61 | + } |
| 62 | + Some(elements) => { |
| 63 | + // If the list elements are non-null, we convert each one accordingly |
| 64 | + // and append it to the new list view. |
| 65 | + let mut new_elements = |
| 66 | + VectorMut::with_capacity(elems_dtype, elements.len()); |
| 67 | + for element in &elements { |
| 68 | + let element_scalar = element.to_vector_scalar(); |
| 69 | + new_elements.append_scalars(&element_scalar, 1); |
| 70 | + } |
| 71 | + |
| 72 | + let offsets = |
| 73 | + PVector::<u64>::new(Buffer::from_iter([0]), Mask::new_true(1)); |
| 74 | + let sizes = PVector::<u64>::new( |
| 75 | + Buffer::from_iter([elements.len() as u64]), |
| 76 | + Mask::new_true(1), |
| 77 | + ); |
| 78 | + |
| 79 | + // Create the length-1 vector holding the list scalar. |
| 80 | + let list_view_vector = ListViewVector::new( |
| 81 | + Arc::new(new_elements.freeze()), |
| 82 | + offsets.into(), |
| 83 | + sizes.into(), |
| 84 | + Mask::new_true(1), |
| 85 | + ); |
| 86 | + |
| 87 | + ListViewScalar::new(list_view_vector).into() |
| 88 | + } |
| 89 | + } |
| 90 | + } |
| 91 | + DType::FixedSizeList(elems_dtype, size, _) => { |
| 92 | + let lscalar = self.as_list(); |
| 93 | + match lscalar.elements() { |
| 94 | + None => { |
| 95 | + let mut elements = VectorMut::with_capacity(elems_dtype, *size as usize); |
| 96 | + elements.append_zeros(*size as usize); |
| 97 | + |
| 98 | + FixedSizeListScalar::new(FixedSizeListVector::new( |
| 99 | + Arc::new(elements.freeze()), |
| 100 | + *size, |
| 101 | + Mask::new_false(1), |
| 102 | + )) |
| 103 | + .into() |
| 104 | + } |
| 105 | + Some(element_scalars) => { |
| 106 | + let mut elements = VectorMut::with_capacity(elems_dtype, *size as usize); |
| 107 | + for element_scalar in &element_scalars { |
| 108 | + elements.append_scalars(&element_scalar.to_vector_scalar(), 1); |
| 109 | + } |
| 110 | + FixedSizeListScalar::new(FixedSizeListVector::new( |
| 111 | + Arc::new(elements.freeze()), |
| 112 | + *size, |
| 113 | + Mask::new_true(1), |
| 114 | + )) |
| 115 | + .into() |
| 116 | + } |
| 117 | + } |
| 118 | + } |
| 119 | + DType::Struct(fields, _) => { |
| 120 | + let scalar = self.as_struct(); |
| 121 | + |
| 122 | + match scalar.fields() { |
| 123 | + None => { |
| 124 | + // Null struct scalar, we still need a length-1 vector for each field. |
| 125 | + let fields = fields |
| 126 | + .fields() |
| 127 | + .map(|dtype| { |
| 128 | + let mut field_vec = VectorMut::with_capacity(&dtype, 1); |
| 129 | + field_vec.append_zeros(1); |
| 130 | + field_vec.freeze() |
| 131 | + }) |
| 132 | + .collect(); |
| 133 | + StructScalar::new(StructVector::new(Arc::new(fields), Mask::new_false(1))) |
| 134 | + .into() |
| 135 | + } |
| 136 | + Some(field_scalars) => { |
| 137 | + let fields = field_scalars |
| 138 | + .map(|scalar| { |
| 139 | + let mut field_vec = VectorMut::with_capacity(scalar.dtype(), 1); |
| 140 | + field_vec.append_scalars(&scalar.to_vector_scalar(), 1); |
| 141 | + field_vec.freeze() |
| 142 | + }) |
| 143 | + .collect(); |
| 144 | + StructScalar::new(StructVector::new(Arc::new(fields), Mask::new_false(1))) |
| 145 | + .into() |
| 146 | + } |
| 147 | + } |
| 148 | + } |
| 149 | + DType::Extension(_) => self.as_extension().storage().to_vector_scalar(), |
| 150 | + } |
| 151 | + } |
| 152 | +} |
0 commit comments