Struct TextArrayV

pub struct TextArrayV {
    pub array: TextArray,
    pub offset: usize,
    /* private fields */
}

TextArrayView

Borrowed, indexable view into a [offset .. offset + len) window of a TextArray.

Purpose

• Zero-copy access to contiguous UTF-8 values in either StringArray or CategoricalArray form.
• Allows null counts for the view to be cached to speed up scans.

Fields

• array: the backing TextArray.
• offset: starting index of the view.
• len: number of logical elements in the view.
• null_count: cached Option<usize> of nulls for this range.

Notes

• TextArrayV is not thread-safe due to its use of Cell for caching the null count.
• Use slice to derive smaller views from this one.
• Use to_text_array to materialise the data.

Fields

array: TextArray

offset: usize

Implementations

impl TextArrayV

pub fn new(array: TextArray, offset: usize, len: usize) -> Self

Creates a new TextArrayView with the given offset and length.

Examples found in repository

examples/print_arrays.rs (line 119)

fn main() {
    // Numeric (Integer, Float, all sizes)
    let col_i32 = IntArr::<i32>::from_slice(&[1, 2, 3, 4, 5]);
    let col_u32 = IntArr::<u32>::from_slice(&[100, 200, 300, 400, 500]);
    let col_f32 = FltArr::<f32>::from_slice(&[1.1, 2.2, 3.3, 4.4, 5.5]);

    // Boolean with nulls
    let mut col_bool = BoolArr::from_slice(&[true, false, true, false, true]);
    col_bool.set_null_mask(Some(Bitmask::from_bools(&[true, true, true, false, true])));

    // String and Dictionary/Categorical
    let col_str32 = StrArr::from_slice(&["red", "blue", "green", "yellow", "purple"]);

    let col_cat32 = CatArr::<u32>::from_values(
        ["apple", "banana", "cherry", "banana", "apple"]
            .iter()
            .copied(),
    );

    // Datetime
    #[cfg(feature = "datetime")]
    let col_dt32 = DatetimeArray::<i32>::from_slice(
        &[1000, 2000, 3000, 4000, 5000],
        Some(minarrow::enums::time_units::TimeUnit::Milliseconds),
    );
    #[cfg(feature = "datetime")]
    let col_dt64 = DatetimeArray::<i64>::from_slice(
        &[
            1_000_000_000,
            2_000_000_000,
            3_000_000_000,
            4_000_000_000,
            5_000_000_000,
        ],
        Some(minarrow::enums::time_units::TimeUnit::Nanoseconds),
    );

    #[cfg(feature = "datetime")]
    col_dt32.print();
    #[cfg(feature = "datetime")]
    println!("\n");
    #[cfg(feature = "datetime")]
    col_dt64.print();
    #[cfg(feature = "datetime")]
    println!("\n");

    // --- Print NumericArray, TextArray, TemporalArray enums
    println!("\n--- Enums: NumericArray, TextArray, TemporalArray ---");
    NumericArray::Int32(Arc::new(col_i32.clone())).print();
    println!("\n");
    NumericArray::UInt32(Arc::new(col_u32.clone())).print();
    println!("\n");
    NumericArray::Float32(Arc::new(col_f32.clone())).print();
    println!("\n");
    TextArray::String32(Arc::new(col_str32.clone())).print();
    println!("\n");
    let _ = &TextArray::Categorical32(Arc::new(col_cat32.clone())).print();

    println!("\n/ *** To display as dates, enable the optional 'chrono' feature *** /\n");

    #[cfg(feature = "datetime")]
    let _ = &TemporalArray::Datetime32(Arc::new(col_dt32.clone())).print();
    println!("\n");
    #[cfg(feature = "datetime")]
    let _ = &TemporalArray::Datetime64(Arc::new(col_dt64.clone())).print();
    println!("\n");

    println!("\n--- Array (top-level) ---");
    Array::from_int32(col_i32.clone()).print();
    println!("\n");
    Array::from_uint32(col_u32.clone()).print();
    println!("\n");
    Array::from_float32(col_f32.clone()).print();
    println!("\n");
    Array::from_string32(col_str32.clone()).print();
    println!("\n");
    Array::from_categorical32(col_cat32.clone()).print();
    println!("\n");
    #[cfg(feature = "datetime")]
    Array::from_datetime_i32(col_dt32.clone()).print();
    println!("\n");
    // --- Print Array Views (ArrayV, NumericArrayV, TextArrayV, TemporalArrayV)
    #[cfg(feature = "views")]
    println!("\n--- Array Views ---");
    #[cfg(feature = "views")]
    ArrayV::new(Array::from_int32(col_i32.clone()), 1, 3).print();

    let num_arr = NumericArray::Int32(Arc::new(col_i32.clone()));
    num_arr.print();

    #[cfg(feature = "views")]
    let num_view = NumericArrayV::new(num_arr, 1, 3);
    #[cfg(feature = "views")]
    num_view.print();

    let txt_arr = TextArray::String32(Arc::new(col_str32.clone()));
    txt_arr.print();

    #[cfg(feature = "views")]
    let txt_view = TextArrayV::new(txt_arr, 1, 3);
    #[cfg(feature = "views")]
    txt_view.print();

    #[cfg(all(feature = "datetime", feature = "views"))]
    {
        use minarrow::TemporalArrayV;

        let tmp_arr = TemporalArray::Datetime32(Arc::new(col_dt32.clone()));
        tmp_arr.print();
        TemporalArrayV::new(tmp_arr, 1, 3).print();
    }

    // --- Print Bitmask and BitmaskV
    println!("\n--- Bitmask & BitmaskV ---");
    let bm = Bitmask::from_bools(&[true, false, true, true, false]);
    bm.print();
    #[cfg(feature = "views")]   
    BitmaskV::new(bm.clone(), 1, 3).print();
}

pub fn with_null_count( array: TextArray, offset: usize, len: usize, null_count: usize, ) -> Self

Creates a new TextArrayView with a precomputed null count.

pub fn is_empty(&self) -> bool

Returns true if the view is empty.

pub fn get_str(&self, i: usize) -> Option<&str>

Returns the value at logical index i as an Option<&str>.

pub fn slice(&self, offset: usize, len: usize) -> Self

Returns a sliced view into a subrange of this view.

pub fn len(&self) -> usize

Returns the length of the window

pub fn as_array(&self) -> Array

Returns the underlying array as an Array enum value.

Useful to access its inner methods

pub fn to_text_array(&self) -> TextArray

Returns an owned TextArray clone of the window.

pub fn end(&self) -> usize

Returns the end index of the view.

pub fn as_tuple(&self) -> (TextArray, usize, usize)

Returns the view as a tuple (array, offset, len).

pub fn null_count(&self) -> usize

Returns the number of nulls in the view.

Caches it after the first calculation.

pub fn null_mask_view(&self) -> Option<BitmaskV>

Returns the null mask as a windowed BitmaskView.

pub fn set_null_count(&self, count: usize)

Sets the cached null count for the view.

Trait Implementations

impl Clone for TextArrayV

fn clone(&self) -> TextArrayV

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TextArrayV

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for TextArrayV

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<Array> for TextArrayV

fn from(array: Array) -> Self

Converts to this type from the input type.

impl From<ArrayV> for TextArrayV

fn from(view: ArrayV) -> Self

Converts to this type from the input type.

impl From<TextArray> for TextArrayV

fn from(array: TextArray) -> Self

Converts to this type from the input type.

impl From<TextArrayV> for Value

fn from(v: TextArrayV) -> Self

Converts to this type from the input type.

impl PartialEq for TextArrayV

fn eq(&self, other: &TextArrayV) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TryFrom<Value> for TextArrayV

type Error = MinarrowError

The type returned in the event of a conversion error.

fn try_from(v: Value) -> Result<Self, Self::Error>

Performs the conversion.

impl StructuralPartialEq for TextArrayV