Method has_non_empty_nulls

arrow-buffer/src/buffer/offset.rs:277–328

Check if any null positions in the `null_buffer` correspond to non-empty ranges in this [`OffsetBuffer`]. In variable-length array types (e.g., `StringArray`, `ListArray`), null entries may or may not have empty offset ranges. This method detects cases where a null entry has a non-empty range (i.e., `offsets[i] != offsets[i+1]`), which means the underlying data buffer contains data behind nulls.

(&self, null_buffer: Option<&NullBuffer>)

    ///
    /// Panics if the length of the `null_buffer` does not equal `self.len() - 1`.
    pub fn has_non_empty_nulls(&self, null_buffer: Option<&NullBuffer>) -> bool {
        let Some(null_buffer) = null_buffer else {
            return false;
        };

        assert_eq!(
            self.len() - 1,
            null_buffer.len(),
            "The length of the offsets should be 1 more than the length of the null buffer"
        );

        if null_buffer.null_count() == 0 {
            return false;
        }

        // Offsets always have at least 1 value
        let initial_offset = self[0];
        let last_offset = self[self.len() - 1];

        // If all the values are null (offsets have 1 more value than the length of the array)
        if null_buffer.null_count() == self.len() - 1 {
            return last_offset != initial_offset;
        }

        let mut valid_slices_iter = null_buffer.valid_slices();

        // This is safe as we validated that are at least 1 valid value in the array
        let (start, end) = valid_slices_iter.next().unwrap();

        // If the nulls before have length greater than 0
        if self[start] != initial_offset {
            return true;
        }

        // End is exclusive, so it already point to the last offset value
        // This is valid as the length of the array is always 1 less than the length of the offsets
        let mut end_offset_of_last_valid_value = self[end];

        for (start, end) in valid_slices_iter {
            // If there is a null value that point to a non-empty value than the start offset of the valid value
            // will be different that the end offset of the last valid value
            if self[start] != end_offset_of_last_valid_value {
                return true;
            }

            // End is exclusive, so it already point to the last offset value
            // This is valid as the length of the array is always 1 less than the length of the offsets
            end_offset_of_last_valid_value = self[end];
        }

        end_offset_of_last_valid_value != last_offset
    }
}

impl<T: ArrowNativeType> Deref for OffsetBuffer<T> {