wip

Author: danking

encodings/sparse/src/canonical.rs

@@ -226,39 +226,21 @@ fn canonicalize_utf8<I: NativePType>(
     let n_patch_buffers = values.buffers().len();
     let mut buffers = values.buffers().to_vec();
 
-    let (fill_view, _fill_validity) = if let Some(buffer) = &fill_value.value() {
+    let fill_view = if let Some(buffer) = &fill_value.value() {
         buffers.push(buffer.inner().clone());
-        let view = BinaryView::make_view(
+        BinaryView::make_view(
             buffer.as_ref(),
             u32::try_from(n_patch_buffers).vortex_expect("too many buffers"),
             0,
-        );
-        (view, Validity::AllValid)
+        )
     } else {
         // any <12 character filler value will do
-        let view = BinaryView::make_view("FILL_VALUE".as_ref(), 0, 0);
-        (view, Validity::AllInvalid)
+        BinaryView::make_view("FILL_VALUE".as_ref(), 0, 0)
     };
+
     let mut view_builder = BufferMut::<BinaryView>::with_capacity(len);
     let mut i = 0usize;
-    println!("indices: {:?}", indices.as_ref());
-    println!("values: {:?}", values.as_ref());
     for (patch_index, &view) in indices.into_iter().zip_eq(values.views().iter()) {
-        if view.is_inlined() {
-            println!(
-                "patch_index={}, i={}, view={:?}",
-                patch_index,
-                i,
-                view.as_inlined().value()
-            );
-        } else {
-            println!(
-                "patch_index={}, i={}, view={:?}",
-                patch_index,
-                i,
-                view.as_view()
-            );
-        }
         let patch_index_usize = <usize as NumCast>::from(patch_index)
             .vortex_expect("var bin view indices must fit in usize");
         for _ in i..patch_index_usize {
@@ -271,27 +253,6 @@ fn canonicalize_utf8<I: NativePType>(
     for _ in i..len {
         view_builder.push(fill_view)
     }
-
-    match &validity {
-        Validity::NonNullable => println!("validity: nonnull"),
-        Validity::AllValid => println!("validity: allvalid"),
-        Validity::AllInvalid => println!("validity: allinvalid"),
-        Validity::Array(a) => {
-            println!(
-                "validity: {}",
-                (0..a.len())
-                    .map(|i| a.scalar_at(i).vortex_expect("shutup"))
-                    .map(|x| x
-                        .as_bool()
-                        .value()
-                        .map_or("N", |b| if b { "T" } else { "F" })
-                        .to_owned())
-                    .join(" ")
-            );
-        }
-    }
-
-    // let validity = fill_validity.patch(len, 0, indices_array.as_ref(), &patch_validity)?;
     let array = VarBinViewArray::try_new(
         view_builder.freeze(),
         buffers,
@@ -701,26 +662,6 @@ mod test {
         )
         .unwrap();
 
-        println!(
-            "array: {}",
-            (0..array.len())
-                .map(|i| array.scalar_at(i).unwrap())
-                .join(",")
-        );
-        let va = array.validity_mask().unwrap().into_array();
-        println!(
-            "array_validity: {}",
-            (0..va.len())
-                .map(|i| va
-                    .scalar_at(i)
-                    .unwrap()
-                    .as_bool()
-                    .value()
-                    .map_or("N", |b| if b { "T" } else { "F" })
-                    .to_owned())
-                .join(",")
-        );
-
         let actual = array.to_varbinview().unwrap().into_array();
         let expected = <VarBinViewArray as FromIterator<_>>::from_iter([
             Some("hello"),