feat: OperatorVTable::bind for VarBin/VarBinView

encodings/dict/Cargo.toml

@@ -34,6 +34,7 @@ vortex-fsst = { workspace = true, optional = true }
 vortex-mask = { workspace = true }
 vortex-scalar = { workspace = true }
 vortex-utils = { workspace = true }
+vortex-vector = { workspace = true }
 
 [lints]
 workspace = true

encodings/dict/src/builders/bytes.rs

@@ -6,14 +6,14 @@ use std::mem;
 use std::sync::Arc;
 
 use vortex_array::accessor::ArrayAccessor;
-use vortex_array::arrays::binary_view::BinaryView;
 use vortex_array::arrays::{PrimitiveArray, VarBinVTable, VarBinViewArray, VarBinViewVTable};
 use vortex_array::validity::Validity;
 use vortex_array::{Array, ArrayRef, IntoArray};
 use vortex_buffer::{BitBufferMut, BufferMut, ByteBufferMut};
 use vortex_dtype::{DType, UnsignedPType};
 use vortex_error::{VortexExpect, VortexResult, VortexUnwrap, vortex_bail, vortex_panic};
 use vortex_utils::aliases::hash_map::{DefaultHashBuilder, HashTable, HashTableEntry, RandomState};
+use vortex_vector::binaryview::BinaryView;
 
 use super::DictConstraints;
 use crate::builders::DictEncoder;

encodings/fsst/Cargo.toml

@@ -26,6 +26,7 @@ vortex-dtype = { workspace = true }
 vortex-error = { workspace = true }
 vortex-mask = { workspace = true }
 vortex-scalar = { workspace = true }
+vortex-vector = { workspace = true }
 
 [dev-dependencies]
 divan = { workspace = true }

encodings/fsst/src/canonical.rs

@@ -4,12 +4,12 @@
 use std::sync::Arc;
 
 use vortex_array::arrays::VarBinViewArray;
-use vortex_array::arrays::binary_view::BinaryView;
 use vortex_array::builders::{ArrayBuilder, VarBinViewBuilder};
 use vortex_array::vtable::{CanonicalVTable, ValidityHelper};
 use vortex_array::{Canonical, IntoArray, ToCanonical};
 use vortex_buffer::{Buffer, BufferMut, ByteBuffer, ByteBufferMut};
 use vortex_dtype::match_each_integer_ptype;
+use vortex_vector::binaryview::BinaryView;
 
 use crate::{FSSTArray, FSSTVTable};
 

encodings/sparse/Cargo.toml

@@ -26,6 +26,7 @@ vortex-dtype = { workspace = true }
 vortex-error = { workspace = true }
 vortex-mask = { workspace = true }
 vortex-scalar = { workspace = true }
+vortex-vector = { workspace = true }
 
 [dev-dependencies]
 itertools = { workspace = true }

encodings/sparse/src/canonical.rs

@@ -5,7 +5,6 @@ use std::sync::Arc;
 
 use itertools::Itertools;
 use num_traits::NumCast;
-use vortex_array::arrays::binary_view::BinaryView;
 use vortex_array::arrays::{
     BoolArray, ConstantArray, FixedSizeListArray, ListViewArray, NullArray, PrimitiveArray,
     StructArray, VarBinViewArray,
@@ -24,6 +23,7 @@ use vortex_dtype::{
 };
 use vortex_error::{VortexError, VortexExpect, vortex_panic};
 use vortex_scalar::{DecimalScalar, ListScalar, Scalar, StructScalar};
+use vortex_vector::binaryview::BinaryView;
 
 use crate::{SparseArray, SparseVTable};
 

encodings/zstd/Cargo.toml

@@ -26,6 +26,7 @@ vortex-error = { workspace = true }
 vortex-mask = { workspace = true }
 vortex-scalar = { workspace = true }
 vortex-sparse = { workspace = true }
+vortex-vector = { workspace = true }
 zstd = { workspace = true }
 
 [dev-dependencies]

encodings/zstd/src/array.rs

@@ -8,7 +8,6 @@ use std::sync::Arc;
 
 use itertools::Itertools as _;
 use vortex_array::accessor::ArrayAccessor;
-use vortex_array::arrays::binary_view::BinaryView;
 use vortex_array::arrays::{ConstantArray, PrimitiveArray, VarBinViewArray};
 use vortex_array::compute::filter;
 use vortex_array::stats::{ArrayStats, StatsSetRef};
@@ -26,6 +25,7 @@ use vortex_dtype::DType;
 use vortex_error::{VortexError, VortexExpect, VortexResult, vortex_err, vortex_panic};
 use vortex_mask::AllOr;
 use vortex_scalar::Scalar;
+use vortex_vector::binaryview::BinaryView;
 
 use crate::serde::{ZstdFrameMetadata, ZstdMetadata};
 

vortex-array/src/arrays/constant/vtable/canonical.rs

@@ -12,8 +12,8 @@ use vortex_error::VortexExpect;
 use vortex_scalar::{
     BinaryScalar, BoolScalar, DecimalValue, ExtScalar, ListScalar, Scalar, StructScalar, Utf8Scalar,
 };
+use vortex_vector::binaryview::BinaryView;
 
-use crate::arrays::binary_view::BinaryView;
 use crate::arrays::constant::ConstantArray;
 use crate::arrays::primitive::PrimitiveArray;
 use crate::arrays::{
@@ -172,7 +172,7 @@ fn constant_canonical_byte_view(
 ) -> VarBinViewArray {
     match scalar_bytes {
         None => {
-            let views = buffer![BinaryView::from(0_u128); len];
+            let views = buffer![BinaryView::empty_view(); len];
 
             // SAFETY: for all-null the views and buffers are just zeroed, never accessed.
             unsafe {

vortex-array/src/arrays/validation_tests.rs

@@ -12,6 +12,7 @@ mod tests {
 
     use vortex_buffer::{Buffer, ByteBuffer, buffer};
     use vortex_dtype::{DType, Nullability, PType};
+    use vortex_vector::binaryview::BinaryView;
 
     use crate::IntoArray;
     use crate::arrays::*;
@@ -152,8 +153,6 @@ mod tests {
     #[test]
     fn test_varbinview_array_validation_success() {
         // Valid case: simple inline strings.
-        use crate::arrays::binary_view::BinaryView;
-
         // Create inline views (length <= 12).
         let view1 = BinaryView::new_inlined(b"foo");
         let view2 = BinaryView::new_inlined(b"bar");
@@ -171,8 +170,6 @@ mod tests {
     #[test]
     fn test_varbinview_array_validation_failure_buffer_index_out_of_bounds() {
         // Invalid case: view references non-existent buffer.
-        use crate::arrays::binary_view::BinaryView;
-
         // Create a view that references buffer 1, but we only have 1 buffer (index 0).
         let data = b"this is a long string that needs a buffer";
         let view = BinaryView::make_view(data, 1, 0); // Buffer index 1.

vortex-array/src/arrays/varbin/vtable/mod.rs

@@ -8,6 +8,7 @@ use crate::{EncodingId, EncodingRef, vtable};
 mod array;
 mod canonical;
 mod operations;
+mod operator;
 mod serde;
 mod validity;
 mod visitor;
@@ -24,7 +25,7 @@ impl VTable for VarBinVTable {
     type VisitorVTable = Self;
     type ComputeVTable = NotSupported;
     type EncodeVTable = NotSupported;
-    type OperatorVTable = NotSupported;
+    type OperatorVTable = Self;
     type SerdeVTable = Self;
 
     fn id(_encoding: &Self::Encoding) -> EncodingId {