rs_natural2array/
lib.rs

1pub use arrow;
2
3use arrow::array::ArrowNativeTypeOp;
4
5use arrow::array::PrimitiveArray;
6use arrow::array::PrimitiveBuilder;
7
8use arrow::datatypes::ArrowPrimitiveType;
9
10pub fn is_negative<N>(natural: N) -> bool
11where
12    N: ArrowNativeTypeOp,
13{
14    let zero: N = N::ZERO;
15    natural < zero
16}
17
18pub fn negative2none<N>(natural: N) -> Option<N>
19where
20    N: ArrowNativeTypeOp,
21{
22    let neg: bool = is_negative(natural);
23    let pos: bool = !neg;
24    pos.then_some(natural)
25}
26
27pub fn natural2builder<T>(natural: T::Native, bldr: &mut PrimitiveBuilder<T>)
28where
29    T: ArrowPrimitiveType,
30{
31    let o: Option<T::Native> = negative2none(natural);
32    match o {
33        None => bldr.append_null(),
34        Some(i) => bldr.append_value(i),
35    }
36}
37
38pub fn opt2builder<T>(natural: Option<T::Native>, bldr: &mut PrimitiveBuilder<T>)
39where
40    T: ArrowPrimitiveType,
41{
42    let o: Option<T::Native> = natural.and_then(negative2none);
43    match o {
44        None => bldr.append_null(),
45        Some(i) => bldr.append_value(i),
46    }
47}
48
49pub fn natural2array<I, T>(nat: I, cap: usize) -> PrimitiveArray<T>
50where
51    I: Iterator<Item = T::Native>,
52    T: ArrowPrimitiveType,
53{
54    let mut bldr = PrimitiveBuilder::with_capacity(cap);
55    for n in nat {
56        natural2builder(n, &mut bldr);
57    }
58    bldr.finish()
59}
60
61pub fn opts2array<I, T>(nat: I, cap: usize) -> PrimitiveArray<T>
62where
63    I: Iterator<Item = Option<T::Native>>,
64    T: ArrowPrimitiveType,
65{
66    let mut bldr = PrimitiveBuilder::with_capacity(cap);
67    for o in nat {
68        opt2builder(o, &mut bldr);
69    }
70    bldr.finish()
71}
72
73pub const CAPACITY_DEFAULT: usize = 1024;
74
75pub fn natural2array_default<I, T>(nat: I) -> PrimitiveArray<T>
76where
77    I: Iterator<Item = T::Native>,
78    T: ArrowPrimitiveType,
79{
80    natural2array(nat, CAPACITY_DEFAULT)
81}
82
83pub fn opts2array_default<I, T>(nat: I) -> PrimitiveArray<T>
84where
85    I: Iterator<Item = Option<T::Native>>,
86    T: ArrowPrimitiveType,
87{
88    opts2array(nat, CAPACITY_DEFAULT)
89}
90
91macro_rules! nat2arr {
92    ($fname: ident, $ptyp: ty) => {
93        /// Converts the natural numbers to an array.
94        pub fn $fname<I>(nat: I) -> PrimitiveArray<$ptyp>
95        where
96            I: Iterator<Item = <$ptyp as ArrowPrimitiveType>::Native>,
97        {
98            natural2array_default(nat)
99        }
100    };
101}
102
103nat2arr!(nat2arr8i, arrow::datatypes::Int8Type);
104nat2arr!(nat2arr16i, arrow::datatypes::Int16Type);
105nat2arr!(nat2arr32i, arrow::datatypes::Int32Type);
106nat2arr!(nat2arr64i, arrow::datatypes::Int64Type);
107
108macro_rules! opt2arr {
109    ($fname: ident, $ptyp: ty) => {
110        /// Converts the optionals to an array.
111        pub fn $fname<I>(nat: I) -> PrimitiveArray<$ptyp>
112        where
113            I: Iterator<Item = Option<<$ptyp as ArrowPrimitiveType>::Native>>,
114        {
115            opts2array_default(nat)
116        }
117    };
118}
119
120opt2arr!(opt2arr8i, arrow::datatypes::Int8Type);
121opt2arr!(opt2arr16i, arrow::datatypes::Int16Type);
122opt2arr!(opt2arr32i, arrow::datatypes::Int32Type);
123opt2arr!(opt2arr64i, arrow::datatypes::Int64Type);
124
125pub fn num2opt(number: &serde_json::Number) -> Option<i64> {
126    let oi: Option<i64> = number.as_i64();
127    oi.and_then(negative2none)
128}
129
130pub fn val2opt(val: &serde_json::Value) -> Option<i64> {
131    match val {
132        serde_json::Value::Number(n) => num2opt(n),
133        _ => None,
134    }
135}
136
137#[cfg(test)]
138mod test {
139    mod test_nat2arr {
140        mod test_short {
141            use crate::nat2arr16i;
142
143            use arrow::array::Array;
144            use arrow::array::PrimitiveArray;
145
146            #[test]
147            fn test_multi() {
148                let v: Vec<i16> = vec![0, 42, -1, 634, -42, 333];
149                let pa: PrimitiveArray<_> = nat2arr16i(v.into_iter());
150                assert_eq!(6, pa.len());
151                assert_eq!(2, pa.null_count());
152                assert_eq!(pa.values(), &[0, 42, 0, 634, 0, 333]);
153            }
154        }
155    }
156
157    mod test_opt2arr {
158        mod test_short {
159            use crate::opt2arr16i;
160
161            use arrow::array::Array;
162            use arrow::array::PrimitiveArray;
163
164            #[test]
165            fn test_multi() {
166                let v: Vec<Option<i16>> = vec![
167                    Some(0),
168                    Some(42),
169                    Some(-1),
170                    Some(634),
171                    None,
172                    Some(-42),
173                    Some(333),
174                ];
175                let pa: PrimitiveArray<_> = opt2arr16i(v.into_iter());
176                assert_eq!(7, pa.len());
177                assert_eq!(3, pa.null_count());
178                assert_eq!(pa.values(), &[0, 42, 0, 634, 0, 0, 333]);
179            }
180        }
181    }
182}
rs_natural2array/lib.rs

rs_natural2array/
lib.rs
