vortex_array/arrays/varbinview/vtable/
mod.rs

1// SPDX-License-Identifier: Apache-2.0
2// SPDX-FileCopyrightText: Copyright the Vortex contributors
3
4use std::sync::Arc;
5
6use vortex_buffer::Buffer;
7use vortex_buffer::BufferHandle;
8use vortex_buffer::ByteBuffer;
9use vortex_dtype::DType;
10use vortex_error::VortexExpect;
11use vortex_error::VortexResult;
12use vortex_error::vortex_bail;
13use vortex_vector::Vector;
14use vortex_vector::binaryview::BinaryVector;
15use vortex_vector::binaryview::BinaryView;
16use vortex_vector::binaryview::StringVector;
17
18use crate::EmptyMetadata;
19use crate::arrays::varbinview::VarBinViewArray;
20use crate::execution::ExecutionCtx;
21use crate::serde::ArrayChildren;
22use crate::validity::Validity;
23use crate::vtable;
24use crate::vtable::ArrayId;
25use crate::vtable::ArrayVTable;
26use crate::vtable::ArrayVTableExt;
27use crate::vtable::NotSupported;
28use crate::vtable::VTable;
29use crate::vtable::ValidityVTableFromValidityHelper;
30
31mod array;
32mod canonical;
33mod operations;
34mod validity;
35mod visitor;
36
37vtable!(VarBinView);
38
39impl VTable for VarBinViewVTable {
40    type Array = VarBinViewArray;
41
42    type Metadata = EmptyMetadata;
43
44    type ArrayVTable = Self;
45    type CanonicalVTable = Self;
46    type OperationsVTable = Self;
47    type ValidityVTable = ValidityVTableFromValidityHelper;
48    type VisitorVTable = Self;
49    type ComputeVTable = NotSupported;
50    type EncodeVTable = NotSupported;
51
52    fn id(&self) -> ArrayId {
53        ArrayId::new_ref("vortex.varbinview")
54    }
55
56    fn encoding(_array: &Self::Array) -> ArrayVTable {
57        VarBinViewVTable.as_vtable()
58    }
59
60    fn metadata(_array: &VarBinViewArray) -> VortexResult<Self::Metadata> {
61        Ok(EmptyMetadata)
62    }
63
64    fn serialize(_metadata: Self::Metadata) -> VortexResult<Option<Vec<u8>>> {
65        Ok(Some(vec![]))
66    }
67
68    fn deserialize(_buffer: &[u8]) -> VortexResult<Self::Metadata> {
69        Ok(EmptyMetadata)
70    }
71
72    fn build(
73        &self,
74        dtype: &DType,
75        len: usize,
76        _metadata: &Self::Metadata,
77        buffers: &[BufferHandle],
78        children: &dyn ArrayChildren,
79    ) -> VortexResult<VarBinViewArray> {
80        if buffers.is_empty() {
81            vortex_bail!("Expected at least 1 buffer, got {}", buffers.len());
82        }
83        let mut buffers: Vec<ByteBuffer> = buffers
84            .iter()
85            .map(|b| b.clone().try_to_bytes())
86            .collect::<VortexResult<Vec<_>>>()?;
87        let views = buffers.pop().vortex_expect("buffers non-empty");
88
89        let views = Buffer::<BinaryView>::from_byte_buffer(views);
90
91        if views.len() != len {
92            vortex_bail!("Expected {} views, got {}", len, views.len());
93        }
94
95        let validity = if children.is_empty() {
96            Validity::from(dtype.nullability())
97        } else if children.len() == 1 {
98            let validity = children.get(0, &Validity::DTYPE, len)?;
99            Validity::Array(validity)
100        } else {
101            vortex_bail!("Expected 0 or 1 children, got {}", children.len());
102        };
103
104        VarBinViewArray::try_new(views, Arc::from(buffers), dtype.clone(), validity)
105    }
106
107    fn batch_execute(array: &Self::Array, _ctx: &mut ExecutionCtx) -> VortexResult<Vector> {
108        Ok(match array.dtype() {
109            DType::Utf8(_) => unsafe {
110                StringVector::new_unchecked(
111                    array.views().clone(),
112                    Arc::new(array.buffers().to_vec().into_boxed_slice()),
113                    array.validity_mask(),
114                )
115            }
116            .into(),
117            DType::Binary(_) => unsafe {
118                BinaryVector::new_unchecked(
119                    array.views().clone(),
120                    Arc::new(array.buffers().to_vec().into_boxed_slice()),
121                    array.validity_mask(),
122                )
123            }
124            .into(),
125            _ => unreachable!("VarBinViewArray must have Binary or Utf8 dtype"),
126        })
127    }
128}
129
130#[derive(Debug)]
131pub struct VarBinViewVTable;