from_vec

Signed-off-by: Andrew Duffy <andrew@a10y.dev>

Author: a10y

encodings/bytebool/src/array.rs

@@ -131,7 +131,7 @@ impl VTable for ByteBool {
         }
         let buffer = buffers[0].clone();
 
-        let data = ByteBoolData::new(buffer, validity.clone());
+        let data = ByteBoolData::new(buffer);
         let slots = ByteBoolData::make_slots(&validity, len);
         Ok(ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
     }
@@ -199,10 +199,17 @@ pub struct ByteBool;
 
 impl ByteBool {
     pub fn new(buffer: BufferHandle, validity: Validity) -> ByteBoolArray {
+        if let Some(len) = validity.maybe_len() {
+            assert_eq!(
+                buffer.len(),
+                len,
+                "ByteBool validity and bytes must have same length"
+            );
+        }
         let dtype = DType::Bool(validity.nullability());
 
         let slots = ByteBoolData::make_slots(&validity, buffer.len());
-        let data = ByteBoolData::new(buffer, validity);
+        let data = ByteBoolData::new(buffer);
         let len = data.len();
         unsafe {
             Array::from_parts_unchecked(
@@ -214,29 +221,22 @@ impl ByteBool {
     /// Construct a [`ByteBoolArray`] from a `Vec<bool>` and validity.
     pub fn from_vec<V: Into<Validity>>(data: Vec<bool>, validity: V) -> ByteBoolArray {
         let validity = validity.into();
-        let data = ByteBoolData::from_vec(data, validity.clone());
-        let dtype = DType::Bool(validity.nullability());
-        let len = data.len();
-        let slots = ByteBoolData::make_slots(&validity, len);
-        unsafe {
-            Array::from_parts_unchecked(
-                ArrayParts::new(ByteBool, dtype, len, data).with_slots(slots),
-            )
-        }
+        // NOTE: this will not cause allocation on release builds
+        let bytes: Vec<u8> = data.into_iter().map(|b| b as u8).collect();
+        let handle = BufferHandle::new_host(ByteBuffer::from(bytes));
+        ByteBool::new(handle, validity)
     }
 
     /// Construct a [`ByteBoolArray`] from optional bools.
     pub fn from_option_vec(data: Vec<Option<bool>>) -> ByteBoolArray {
         let validity = Validity::from_iter(data.iter().map(|v| v.is_some()));
-        let data = ByteBoolData::from(data);
-        let dtype = DType::Bool(validity.nullability());
-        let len = data.len();
-        let slots = ByteBoolData::make_slots(&validity, len);
-        unsafe {
-            Array::from_parts_unchecked(
-                ArrayParts::new(ByteBool, dtype, len, data).with_slots(slots),
-            )
-        }
+        // NOTE: this will not cause allocation on release builds
+        let bytes: Vec<u8> = data
+            .into_iter()
+            .map(|b| b.unwrap_or_default() as u8)
+            .collect();
+        let handle = BufferHandle::new_host(ByteBuffer::from(bytes));
+        ByteBool::new(handle, validity)
     }
 }
 
@@ -267,17 +267,7 @@ impl ByteBoolData {
         vec![validity_to_child(validity, len)]
     }
 
-    pub fn new(buffer: BufferHandle, validity: Validity) -> Self {
-        let length = buffer.len();
-        if let Some(vlen) = validity.maybe_len()
-            && length != vlen
-        {
-            vortex_panic!(
-                "Buffer length ({}) does not match validity length ({})",
-                length,
-                vlen
-            );
-        }
+    pub fn new(buffer: BufferHandle) -> Self {
         Self { buffer }
     }
 
@@ -291,14 +281,6 @@ impl ByteBoolData {
         self.buffer.len() == 0
     }
 
-    // TODO(ngates): deprecate construction from vec
-    pub fn from_vec<V: Into<Validity>>(data: Vec<bool>, validity: V) -> Self {
-        let validity = validity.into();
-        // SAFETY: we are transmuting a Vec<bool> into a Vec<u8>
-        let data: Vec<u8> = unsafe { std::mem::transmute(data) };
-        Self::new(BufferHandle::new_host(ByteBuffer::from(data)), validity)
-    }
-
     pub fn buffer(&self) -> &BufferHandle {
         &self.buffer
     }
@@ -330,23 +312,6 @@ impl OperationsVTable<ByteBool> for ByteBool {
     }
 }
 
-impl From<Vec<bool>> for ByteBoolData {
-    fn from(value: Vec<bool>) -> Self {
-        Self::from_vec(value, Validity::AllValid)
-    }
-}
-
-impl From<Vec<Option<bool>>> for ByteBoolData {
-    fn from(value: Vec<Option<bool>>) -> Self {
-        let validity = Validity::from_iter(value.iter().map(|v| v.is_some()));
-
-        // This doesn't reallocate, and the compiler even vectorizes it
-        let data = value.into_iter().map(Option::unwrap_or_default).collect();
-
-        Self::from_vec(data, validity)
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use vortex_array::ArrayContext;