typed-arrow 0.7.0

Compile-time Arrow schemas for Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

//! Showcase: Duration and Interval types in a typed Record.

// Native structs for DayTime and MonthDayNano interval values
use arrow_array::{Array, types as t};
use typed_arrow::{
    IntervalDayTime, IntervalMonthDayNano, IntervalYearMonth,
    bridge::{Duration as Dur, Millisecond, Nanosecond},
    prelude::*,
};

#[derive(Record)]
struct RowDurInt {
    d_ms: Dur<Millisecond>,
    d_ns_opt: Option<Dur<Nanosecond>>,
    i_ym: IntervalYearMonth,
    i_dt: IntervalDayTime,
    i_mdn_opt: Option<IntervalMonthDayNano>,
}

fn main() {
    use arrow_array::builder::PrimitiveBuilder;
    use arrow_schema::{DataType, IntervalUnit, TimeUnit};

    // Inspect compile-time datatypes
    println!(
        "d_ms={:?}, d_ns_opt={:?}, i_ym={:?}, i_dt={:?}, i_mdn_opt={:?}",
        <RowDurInt as ColAt<0>>::data_type(),
        <RowDurInt as ColAt<1>>::data_type(),
        <RowDurInt as ColAt<2>>::data_type(),
        <RowDurInt as ColAt<3>>::data_type(),
        <RowDurInt as ColAt<4>>::data_type(),
    );

    assert_eq!(
        <RowDurInt as ColAt<0>>::data_type(),
        DataType::Duration(TimeUnit::Millisecond)
    );
    assert_eq!(
        <RowDurInt as ColAt<2>>::data_type(),
        DataType::Interval(IntervalUnit::YearMonth)
    );
    assert_eq!(
        <RowDurInt as ColAt<3>>::data_type(),
        DataType::Interval(IntervalUnit::DayTime)
    );
    assert_eq!(
        <RowDurInt as ColAt<4>>::data_type(),
        DataType::Interval(IntervalUnit::MonthDayNano)
    );

    // Build a couple arrays for demonstration
    // Duration<Millisecond>
    let mut b0: <RowDurInt as ColAt<0>>::ColumnBuilder =
        PrimitiveBuilder::<t::DurationMillisecondType>::with_capacity(3);
    b0.append_value(1);
    b0.append_value(2);
    b0.append_null();
    let a0: <RowDurInt as ColAt<0>>::ColumnArray = b0.finish();
    println!("d_ms_len={}, null2={}", a0.len(), a0.is_null(2));

    // IntervalDayTime
    let mut b3: <RowDurInt as ColAt<3>>::ColumnBuilder =
        PrimitiveBuilder::<t::IntervalDayTimeType>::with_capacity(2);
    b3.append_value(t::IntervalDayTime {
        days: 1,
        milliseconds: 500,
    });
    b3.append_value(t::IntervalDayTime {
        days: 0,
        milliseconds: 0,
    });
    let a3: <RowDurInt as ColAt<3>>::ColumnArray = b3.finish();
    println!("i_dt_len={}", a3.len());
}