chore(ci): minor CI and justfile cleanup

Author: nyurik

rust/mlt-nom/src/v01/stream.rs

@@ -296,14 +296,12 @@ impl<'a> Stream<'a> {
             .map_err(Into::into)
     }
 
-    pub fn decode_u64(self) -> Result<Vec<u64>, MltError> {
-        let meta = self.meta;
-        // First decode physical layer as u64
-        let physical_data = match meta.physical_decoder {
+    pub fn decode_bits_u64(self) -> Result<Vec<u64>, MltError> {
+        match self.meta.physical_decoder {
             PhysicalDecoder::VarInt => match self.data {
                 StreamData::VarInt(data) => all(utils::parse_varint_vec::<u64, u64>(
                     data.data,
-                    meta.num_values,
+                    self.meta.num_values,
                 )?),
                 StreamData::Raw(_) => {
                     return Err(MltError::InvalidStreamData {
@@ -323,40 +321,15 @@ impl<'a> Stream<'a> {
                 return Err(MltError::UnsupportedPhysicalDecoder("FastPFOR"));
             }
             PhysicalDecoder::Alp => return Err(MltError::UnsupportedPhysicalDecoder("ALP")),
-        }?;
-        
-        // Then apply logical decoding
-        match meta.logical_decoder {
-            LogicalDecoder::None => Ok(physical_data),
-            LogicalDecoder::Rle(rle_meta) => {
-                decode_rle(
-                    &physical_data,
-                    rle_meta.runs as usize,
-                    rle_meta.num_rle_values as usize,
-                )
-            }
-            LogicalDecoder::Delta => {
-                // For delta decoding, we need to treat values as signed (i64) for zigzag
-                // Convert u64 to u64 (no-op) but we'll decode as if they were zigzag-encoded i64 values
-                // The zigzag encoding stores signed values in unsigned form
-                Ok(decode_zigzag_delta::<i64, u64>(&physical_data))
-            }
-            LogicalDecoder::DeltaRle(rle_meta) => {
-                // First decode RLE
-                let rle_decoded = decode_rle(
-                    &physical_data,
-                    rle_meta.runs as usize,
-                    rle_meta.num_rle_values as usize,
-                )?;
-                // Then apply ZigZag Delta decoding
-                Ok(decode_zigzag_delta::<i64, u64>(&rle_decoded))
-            }
-            v => Err(MltError::DecodeError(format!(
-                "Unsupported LogicalDecoder {v:?} for u64"
-            ))),
         }
     }
 
+    pub fn decode_u64(self) -> Result<Vec<u64>, MltError> {
+        let meta = self.meta;
+        let physical_data = self.decode_bits_u64()?;
+        apply_logical_decoding_u64(physical_data, meta.logical_decoder)
+    }
+
     pub fn decode_bits_u32(self) -> Result<LogicalValue, MltError> {
         let value = match self.meta.physical_decoder {
             PhysicalDecoder::VarInt => match self.data {
@@ -391,34 +364,6 @@ impl<'a> Stream<'a> {
         Ok(LogicalValue::new(self.meta, LogicalData::VecU32(value)))
     }
 
-    fn decode_physical_u64(self) -> Result<Vec<u64>, MltError> {
-        match self.meta.physical_decoder {
-            PhysicalDecoder::VarInt => match self.data {
-                StreamData::VarInt(data) => all(utils::parse_varint_vec::<u64, u64>(
-                    data.data,
-                    self.meta.num_values,
-                )?),
-                StreamData::Raw(_) => {
-                    return Err(MltError::InvalidStreamData {
-                        expected: "VarInt",
-                        got: format!("{:?}", self.data),
-                    });
-                }
-            },
-            PhysicalDecoder::None => {
-                // For raw data, we'd need to read 8 bytes per value
-                // But typically 64-bit IDs use VarInt encoding
-                return Err(MltError::DecodeError(
-                    "Raw physical decoder not supported for u64".to_string(),
-                ));
-            }
-            PhysicalDecoder::FastPFOR => {
-                return Err(MltError::UnsupportedPhysicalDecoder("FastPFOR"));
-            }
-            PhysicalDecoder::Alp => return Err(MltError::UnsupportedPhysicalDecoder("ALP")),
-        }
-    }
-
     // pub fn decode<'a, T, U>(&'_ self) -> Result<Vec<U>, MltError>
     // where
     //     T: VarInt,
@@ -546,6 +491,41 @@ impl LogicalValue {
     }
 }
 
+/// Apply logical decoding to u64 data
+fn apply_logical_decoding_u64(
+    physical_data: Vec<u64>,
+    logical_decoder: LogicalDecoder,
+) -> Result<Vec<u64>, MltError> {
+    match logical_decoder {
+        LogicalDecoder::None => Ok(physical_data),
+        LogicalDecoder::Rle(rle_meta) => {
+            decode_rle(
+                &physical_data,
+                rle_meta.runs as usize,
+                rle_meta.num_rle_values as usize,
+            )
+        }
+        LogicalDecoder::Delta => {
+            // For delta decoding, we need to treat values as signed (i64) for zigzag
+            // The zigzag encoding stores signed values in unsigned form
+            Ok(decode_zigzag_delta::<i64, u64>(&physical_data))
+        }
+        LogicalDecoder::DeltaRle(rle_meta) => {
+            // First decode RLE
+            let rle_decoded = decode_rle(
+                &physical_data,
+                rle_meta.runs as usize,
+                rle_meta.num_rle_values as usize,
+            )?;
+            // Then apply ZigZag Delta decoding
+            Ok(decode_zigzag_delta::<i64, u64>(&rle_decoded))
+        }
+        v => Err(MltError::DecodeError(format!(
+            "Unsupported LogicalDecoder {v:?} for u64"
+        ))),
+    }
+}
+
 /// Logical encoding technique used for a column, as stored in the tile
 #[borrowme]
 #[derive(Debug, Clone, Copy, PartialEq, TryFromPrimitive)]