arrow-odbc 23.2.0

Read/Write Apache Arrow arrays from/to ODBC data sources.
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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

use arrow::{
    array::{Array, Decimal128Array, Decimal256Array},
    datatypes::{ArrowPrimitiveType, Decimal256Type},
};
use odbc_api::{BindParamDesc, buffers::AnySliceMut};

use crate::{WriterError, odbc_writer::WriteStrategy};

pub struct NullableDecimal128AsText {
    precision: u8,
    scale: i8,
}

impl NullableDecimal128AsText {
    pub fn new(precision: u8, scale: i8) -> Self {
        Self { precision, scale }
    }
}

pub struct NullableDecimal256AsText {
    precision: u8,
    scale: i8,
}

impl NullableDecimal256AsText {
    pub fn new(precision: u8, scale: i8) -> Self {
        Self { precision, scale }
    }
}

/// Length of a text representation of a decimal
fn len_text(scale: i8, precision: u8) -> usize {
    match scale {
        // Precision digits + (- scale zeroes) + sign
        i8::MIN..=-1 => (precision as i32 - scale as i32 + 1).try_into().unwrap(),
        // Precision digits + sign
        0 => precision as usize + 1,
        // Precision digits + radix character (`.`) + sign
        1.. => precision as usize + 1 + 1,
    }
}

impl WriteStrategy for NullableDecimal128AsText {
    fn buffer_desc(&self) -> BindParamDesc {
        BindParamDesc::decimal_as_text(self.precision, self.scale)
    }

    fn write_rows(
        &self,
        param_offset: usize,
        column_buf: AnySliceMut<'_>,
        array: &dyn Array,
    ) -> Result<(), WriterError> {
        let length = len_text(self.scale, self.precision);

        let from = array.as_any().downcast_ref::<Decimal128Array>().unwrap();
        let mut to = column_buf.as_text_view().unwrap();

        for (index, cell) in from.iter().enumerate() {
            if let Some(value) = cell {
                let buf = to.set_mut(index + param_offset, length);
                write_i128_as_decimal(value, self.precision, self.scale, buf)
            } else {
                to.set_cell(index + param_offset, None)
            }
        }
        Ok(())
    }
}

impl WriteStrategy for NullableDecimal256AsText {
    fn buffer_desc(&self) -> BindParamDesc {
        BindParamDesc::decimal_as_text(self.precision, self.scale)
    }

    fn write_rows(
        &self,
        param_offset: usize,
        column_buf: AnySliceMut<'_>,
        array: &dyn Array,
    ) -> Result<(), WriterError> {
        let from = array.as_any().downcast_ref::<Decimal256Array>().unwrap();
        let mut to = column_buf.as_text_view().unwrap();
        let length = len_text(self.scale, self.precision);

        for (index, cell) in from.iter().enumerate() {
            if let Some(value) = cell {
                let buf = to.set_mut(index + param_offset, length);
                write_i256_as_decimal(value, self.precision, self.scale, buf)
            } else {
                to.set_cell(index + param_offset, None)
            }
        }
        Ok(())
    }
}

fn write_i128_as_decimal(mut n: i128, precision: u8, scale: i8, text: &mut [u8]) {
    if n.is_negative() {
        n *= n.signum();
        text[0] = b'-';
    } else {
        text[0] = b'+';
    }

    // Number of digits + one decimal separator (`.`)
    let str_len: i32 = (len_text(scale, precision) - 1).try_into().unwrap();

    let ten = 10;
    for index in (0..str_len).rev() {
        // In case of negative scale, fill the last digits with zeroes
        let char = if (str_len - index) <= -scale as i32 {
            b'0'
        // The separator will not be printed in case of scale <= 0 since index is never going to
        // reach `precision`.
        } else if index == precision as i32 - scale as i32 {
            b'.'
        } else {
            let digit: u8 = (n % ten) as u8;
            n /= ten;
            b'0' + digit
        };
        // +1 offset to make space for sign character
        text[index as usize + 1] = char;
    }
}

type I256 = <Decimal256Type as ArrowPrimitiveType>::Native;

fn write_i256_as_decimal(mut n: I256, precision: u8, scale: i8, text: &mut [u8]) {
    if n.lt(&I256::ZERO) {
        n = n.checked_mul(I256::MINUS_ONE).unwrap();
        text[0] = b'-';
    } else {
        text[0] = b'+';
    }

    // Number of digits + one decimal separator (`.`)
    let str_len: i32 = (len_text(scale, precision) - 1).try_into().unwrap();

    let ten = I256::from_i128(10);
    for index in (0..str_len).rev() {
        let char = if (str_len - index) <= -scale as i32 {
            b'0'
        // The separator will not be printed in case of scale == 0 since index is never going to
        // reach `precision`.
        } else if index == precision as i32 - scale as i32 {
            b'.'
        } else {
            let digit: u8 = n.checked_rem(ten).unwrap().to_i128().unwrap() as u8;
            n = n.checked_div(ten).unwrap();
            b'0' + digit
        };
        // +1 offset to make space for sign character
        text[index as usize + 1] = char;
    }
}