reset validity instead of filling

Signed-off-by: Mikhail Kot <to@myrrc.dev>

Author: myrrc

vortex-buffer/src/bit/buf.rs

@@ -319,6 +319,30 @@ impl BitBuffer {
         count_ones(self.buffer.as_slice(), self.offset, self.len)
     }
 
+    /// Copy bits to "target", counting ones.
+    pub fn copy_with_true_count(&self, target: &mut [u64]) -> usize {
+        let mut ones = 0usize;
+        let iter = target.iter_mut();
+        if self.offset == 0 {
+            let chunks = self.chunks();
+            let remainder = chunks.remainder_bits();
+            let remainder_len = chunks.remainder_len();
+            for (slot, chunk) in iter.zip(chunks) {
+                *slot = chunk;
+                ones += chunk.count_ones() as usize;
+            }
+            if remainder_len > 0 {
+                ones += remainder.count_ones() as usize;
+            }
+        } else {
+            for (slot, chunk) in iter.zip(self.unaligned_chunks().iter()) {
+                *slot = chunk;
+                ones += chunk.count_ones() as usize;
+            }
+        }
+        ones
+    }
+
     /// Get the number of unset bits in the buffer.
     pub fn false_count(&self) -> usize {
         self.len - self.true_count()
@@ -781,4 +805,77 @@ mod tests {
             assert_eq!(mapped.value(i), expected, "Mismatch at index {}", i);
         }
     }
+
+    #[test]
+    fn test_copy_with_true_count_all_true() {
+        let mut target = [0u64; 10];
+        let source = BitBuffer::new_set(10);
+        let true_count = source.copy_with_true_count(&mut target);
+        let slice = source.inner().as_slice();
+        assert!(
+            target
+                .iter()
+                .zip(slice.chunks_exact(8))
+                .all(|(val, chunk)| val.to_le_bytes() == chunk)
+        );
+        assert_eq!(true_count, 10);
+    }
+
+    #[test]
+    fn test_copy_with_true_count_unaligned() {
+        let mut target = [0u64; 10];
+        let source = BitBuffer::new_with_offset(buffer![10u8, 11u8, 12u8], 16, 1);
+        let true_count = source.copy_with_true_count(&mut target);
+        let slice = source.inner().as_slice();
+        assert!(
+            target
+                .iter()
+                .zip(slice.chunks_exact(8))
+                .all(|(val, chunk)| val.to_le_bytes() == chunk)
+        );
+        assert_eq!(true_count, 5);
+    }
+
+    #[test]
+    fn test_copy_with_true_count_all_false() {
+        let mut target = [0u64; 10];
+        let source = BitBuffer::new_unset(10);
+        let true_count = source.copy_with_true_count(&mut target);
+        let slice = source.inner().as_slice();
+        assert!(
+            target
+                .iter()
+                .zip(slice.chunks_exact(8))
+                .all(|(val, chunk)| val.to_le_bytes() == chunk)
+        );
+        assert_eq!(true_count, 0);
+    }
+
+    #[test]
+    fn test_copy_with_true_count_one() {
+        let mut target = [0u64; 10];
+        let source = BitBuffer::new(buffer![0u8, 1], 16);
+        let true_count = source.copy_with_true_count(&mut target);
+        let slice = source.inner().as_slice();
+        assert!(
+            target
+                .iter()
+                .zip(slice.chunks_exact(8))
+                .all(|(val, chunk)| val.to_le_bytes() == chunk)
+        );
+        assert_eq!(true_count, 1);
+    }
+
+    #[test]
+    fn test_copy_with_true_count() {
+        let mut target = vec![0u64];
+        let source = BitBuffer::new(buffer![1u8, 2, 3, 50, 51, 52, 100, 101], 64);
+        let true_count = source.copy_with_true_count(&mut target);
+        assert_eq!(
+            target[0], 0x65_64_34_33_32_03_02_01_u64,
+            "{:#08x} == {:#08x}",
+            target[0], 0x65_64_34_33_32_03_02_01_u64,
+        );
+        assert_eq!(true_count, 21);
+    }
 }

vortex-duckdb/cpp/include/duckdb_vx/vector.h

@@ -47,6 +47,10 @@ void duckdb_vx_string_vector_add_vector_data_buffer(duckdb_vector ffi_vector, du
 // valid.
 void duckdb_vx_vector_set_vector_data_buffer(duckdb_vector ffi_vector, duckdb_vx_vector_buffer buffer);
 
+// Reset vector's validity mask to nullptr, making all vector's elements valid.
+// vector must not be a DictionaryVector or a SequenceVector
+void duckdb_vx_vector_set_all_valid(duckdb_vector ffi_vector);
+
 // Set the data pointer for the vector. This is the start of the values array in the vector.
 void duckdb_vx_vector_set_data_ptr(duckdb_vector ffi_vector, void *ptr);
 

vortex-duckdb/cpp/vector.cpp

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+#include "include/duckdb_vx/vector.h"
 #include "duckdb_vx/duckdb_diagnostics.h"
 
 DUCKDB_INCLUDES_BEGIN
@@ -106,3 +107,20 @@ const char *duckdb_vector_to_string(duckdb_vector vector, unsigned long len, duc
         return nullptr;
     }
 }
+
+void duckdb_vx_vector_set_all_valid(duckdb_vector ffi_vector) {
+    using enum VectorType;
+    Vector &vector = *reinterpret_cast<Vector *>(ffi_vector);
+    const VectorType type = vector.GetVectorType();
+    D_ASSERT(type != DICTIONARY_VECTOR && type != SEQUENCE_VECTOR);
+    switch (type) {
+    case CONSTANT_VECTOR:
+        return ConstantVector::Validity(vector).Reset();
+    case FLAT_VECTOR:
+        return FlatVector::Validity(vector).Reset();
+    case FSST_VECTOR:
+        return FSSTVector::Validity(vector).Reset();
+    default:
+        __builtin_unreachable();
+    }
+}

vortex-duckdb/src/duckdb/vector.rs

@@ -207,7 +207,11 @@ impl VectorRef {
     ///
     /// The provided capacity *must* be the actual capacity of this vector.
     pub unsafe fn validity_bitslice_mut(&mut self, capacity: usize) -> Option<&mut BitSlice<u64>> {
-        unsafe { self.validity_slice_mut(capacity) }.map(|slice| slice.view_bits_mut())
+        // capacity is always less than BitSlice<u64>::MAX_ELTS
+        unsafe {
+            self.validity_slice_mut(capacity)
+                .map(|slice| BitSlice::from_slice_unchecked_mut(slice))
+        }
     }
 
     pub fn validity_ref(&self, len: usize) -> ValidityRef<'_> {

vortex-duckdb/src/exporter/mod.rs

@@ -19,8 +19,6 @@ mod validity;
 mod varbinview;
 mod vector;
 
-use bitvec::prelude::Lsb0;
-use bitvec::view::BitView;
 pub use cache::ConversionCache;
 pub use decimal::precision_to_duckdb_storage_size;
 use vortex::array::ArrayRef;
@@ -187,19 +185,6 @@ fn new_array_exporter_with_flatten(
     }
 }
 
-/// Copy the sliced bits from source into target.
-///
-/// Offset and length are a _bit_ offset and a _bit_ length into source.
-///
-/// `target.len()` must equal `len`.
-fn copy_from_slice(target: &mut [u64], source: &[u8], offset: usize, len: usize) {
-    let (start, middle, end) = unsafe { target.align_to_mut::<u8>() };
-    assert!(start.is_empty());
-    assert!(end.is_empty());
-    let target = &mut middle.view_bits_mut::<Lsb0>()[..len];
-    target.copy_from_bitslice(&source.view_bits()[offset..][..len]);
-}
-
 #[cfg(test)]
 mod tests {
     use vortex::buffer::BitBuffer;
@@ -208,7 +193,6 @@ mod tests {
     use crate::cpp::DUCKDB_TYPE;
     use crate::duckdb::LogicalType;
     use crate::duckdb::Vector;
-    use crate::exporter::copy_from_slice;
 
     #[test]
     fn test_set_validity_all_true() {
@@ -355,178 +339,4 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_copy_from_slice_empty_to_empty() {
-        let target = &mut [];
-        let source = Vec::<u8>::new();
-        copy_from_slice(target, &source, 0, 0);
-    }
-
-    #[test]
-    fn test_copy_from_slice_64_to_empty() {
-        let target = &mut [];
-        let source = [1u8, 2, 3, 50, 51, 52, 100, 101];
-        copy_from_slice(target, &source, 0, 0);
-        copy_from_slice(target, &source, 5, 0);
-        copy_from_slice(target, &source, 8, 0);
-    }
-
-    #[test]
-    fn test_copy_from_slice_64_to_64() {
-        let mut target = vec![0u64];
-        let source = [1u8, 2, 3, 50, 51, 52, 100, 101];
-        copy_from_slice(&mut target, &source, 0, 64);
-        assert_eq!(
-            target[0], 0x65_64_34_33_32_03_02_01_u64,
-            "{:#08x} == {:#08x}",
-            target[0], 0x65_64_34_33_32_03_02_01_u64,
-        );
-    }
-
-    #[test]
-    fn test_copy_from_slice_80_to_0() {
-        let target = &mut [];
-        let source = [1u8, 2, 3, 50, 51, 52, 100, 101, 254, 255];
-        copy_from_slice(target, &source, 0, 0);
-        copy_from_slice(target, &source, 8, 0);
-        copy_from_slice(target, &source, 10, 0);
-    }
-
-    #[test]
-    fn test_copy_from_slice_80_to_64_case_1() {
-        let mut target = [0u64];
-        let source = [1u8, 2, 3, 50, 51, 52, 100, 101, 254, 255];
-        copy_from_slice(&mut target, &source, 16, 64);
-        assert_eq!(
-            target[0], 0xff_fe_65_64_34_33_32_03_u64,
-            "{:#08x} == {:#08x}",
-            target[0], 0xff_fe_65_64_34_33_32_03_u64,
-        );
-    }
-
-    #[test]
-    fn test_copy_from_slice_80_to_64_case_2() {
-        let mut target = [0u64];
-        let source = [1u8, 2, 3, 50, 51, 52, 100, 101, 254, 255];
-        copy_from_slice(&mut target, &source, 8, 64);
-        assert_eq!(
-            target[0], 0xfe_65_64_34_33_32_03_02_u64,
-            "{:#08x} == {:#08x}",
-            target[0], 0xfe_65_64_34_33_32_03_02_u64,
-        );
-    }
-
-    #[test]
-    fn test_copy_from_slice_80_to_64_case_3() {
-        let mut target = [0u64];
-        let source = [1u8, 2, 3, 50, 51, 52, 100, 101, 254, 255];
-        copy_from_slice(&mut target, &source, 0, 64);
-        assert_eq!(
-            target[0], 0x65_64_34_33_32_03_02_01_u64,
-            "{:#08x} == {:#08x}",
-            target[0], 0x65_64_34_33_32_03_02_01_u64,
-        );
-    }
-
-    #[test]
-    fn test_copy_from_slice_80_to_64_case_4() {
-        let mut target = [0u64];
-        let source = [1u8, 2, 3, 50, 51, 52, 100, 101, 254, 255];
-        copy_from_slice(&mut target, &source, 10, 64);
-        assert_eq!(
-            target[0],
-            0xff_99_59_0d_0c_cc_80_c0_u64, // Python: hex(0xff_fe_65_64_34_33_32_03_02 >> 2), then remove the high two hexits
-            "{:#08x} == {:#08x}",
-            target[0],
-            0xff_99_59_0d_0c_cc_80_c0_u64
-        );
-    }
-
-    #[test]
-    fn test_copy_from_slice_248_to_128_middle_non_empty() {
-        let mut target = [0u64, 0u64];
-        let source: [u8; 31] = [
-            0x01, 0x02, 0x03, 0x04, 0xff, 0xfe, 0xfd, 0xfc, 0x05, 0x06, 0x07, 0x08, 0xfc, 0xfb,
-            0xfa, 0xf9, 0x01, 0x02, 0x03, 0x04, 0xff, 0xfe, 0xfd, 0xfc, 0x05, 0x06, 0x07, 0x08,
-            0xfc, 0xfb, 0xfa,
-        ];
-        // In a span of 248 bits (31 bytes) there should be at least one 8-byte aligned span.
-        let (_, middle, _) = unsafe { source.align_to::<u64>() };
-        assert!(!middle.is_empty());
-
-        copy_from_slice(&mut target, &source, 0, 128);
-        assert_eq!(
-            target[0], 0xfc_fd_fe_ff_04_03_02_01_u64,
-            "{:#08x} == {:#08x}",
-            target[0], 0xfc_fd_fe_ff_04_03_02_01_u64,
-        );
-        assert_eq!(
-            target[1], 0xf9_fa_fb_fc_08_07_06_05_u64,
-            "{:#08x} == {:#08x}",
-            target[1], 0xf9_fa_fb_fc_08_07_06_05_u64,
-        );
-
-        copy_from_slice(&mut target, &source, 8, 128);
-        assert_eq!(
-            target[0], 0x05_fc_fd_fe_ff_04_03_02_u64,
-            "{:#08x} == {:#08x}",
-            target[0], 0x05_fc_fd_fe_ff_04_03_02_u64,
-        );
-        assert_eq!(
-            target[1], 0x01_f9_fa_fb_fc_08_07_06_u64,
-            "{:#08x} == {:#08x}",
-            target[1], 0x01_f9_fa_fb_fc_08_07_06_u64,
-        );
-
-        copy_from_slice(&mut target, &source, 8 * 8, 128);
-        assert_eq!(
-            target[0], 0xf9_fa_fb_fc_08_07_06_05_u64,
-            "{:#08x} == {:#08x}",
-            target[0], 0xf9_fa_fb_fc_08_07_06_05_u64,
-        );
-        assert_eq!(
-            target[1], 0xfc_fd_fe_ff_04_03_02_01_u64,
-            "{:#08x} == {:#08x}",
-            target[1], 0xfc_fd_fe_ff_04_03_02_01_u64,
-        );
-
-        copy_from_slice(&mut target, &source, 8 * 12, 128);
-        assert_eq!(
-            target[0], 0x04_03_02_01_f9_fa_fb_fc_u64,
-            "{:#08x} == {:#08x}",
-            target[0], 0x04_03_02_01_f9_fa_fb_fc_u64,
-        );
-        assert_eq!(
-            target[1], 0x08_07_06_05_fc_fd_fe_ff_u64,
-            "{:#08x} == {:#08x}",
-            target[1], 0x08_07_06_05_fc_fd_fe_ff_u64,
-        );
-
-        copy_from_slice(&mut target, &source, 8 * 12 + 4, 128);
-        // Find the 12th byte, skip the first hexit, take the next 32 hexits (i.e. 16 bytesor 128
-        // bits).
-        assert_eq!(
-            target[0], 0xf0_40_30_20_1f_9f_af_bf_u64,
-            "{:#08x} == {:#08x}",
-            target[0], 0xf0_40_30_20_1f_9f_af_bf_u64,
-        );
-        assert_eq!(
-            target[1], 0xc0_80_70_60_5f_cf_df_ef_u64,
-            "{:#08x} == {:#08x}",
-            target[1], 0xc0_80_70_60_5f_cf_df_ef_u64,
-        );
-
-        // Take the above and shift one bit towards the right-hand-side.
-        copy_from_slice(&mut target, &source, 8 * 12 + 4 + 1, 128);
-        assert_eq!(
-            target[0], 0xf8_20_18_10_0f_cf_d7_df_u64,
-            "{:#08x} == {:#08x}",
-            target[0], 0xf8_20_18_10_0f_cf_d7_df_u64,
-        );
-        assert_eq!(
-            target[1], 0xe0_40_38_30_2f_e7_ef_f7_u64,
-            "{:#08x} == {:#08x}",
-            target[1], 0xe0_40_38_30_2f_e7_ef_f7_u64,
-        );
-    }
 }