rbdc-oracle 0.10.0

Oracle driver for rbdc
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

use crate::decode::Decode;
use crate::encode::{Encode, IsNull};
use crate::type_info::{OracleTypeInfo, Type};
use crate::types::value::MISSING_STRING_VALUE;
use crate::{OracleArgumentValue, OracleValueRef};
use bigdecimal::BigDecimal;
use oracle::sql_type::OracleType;
use rbdc::Error;
use rbdc::datetime::DateTime;
use rbs::Value;
use std::str::FromStr;

pub(crate) fn decode_by_oracle_type(
    oracle_type: &OracleType,
    value: OracleValueRef<'_>,
) -> Result<Value, Error> {
    match oracle_type {
        OracleType::Number(precision, scale) => decode_number(value, *precision, *scale),
        OracleType::Int64 => Ok(Value::I32(i32::decode(value)?)),
        OracleType::Float(precision) => crate::types::float::decode_float(value, *precision),
        OracleType::Date => Ok(Value::from(DateTime::from_str(value.text()?)?)),
        OracleType::BLOB => Ok(crate::types::bytes::decode_binary(value)),
        OracleType::Long | OracleType::CLOB | OracleType::NCLOB => {
            Ok(Value::String(String::decode(value)?))
        }
        _ => value
            .text()
            .map(|text| Value::String(text.to_owned()))
            .map_err(|_| Error::from("unimpl")),
    }
}

fn decode_number(value: OracleValueRef<'_>, precision: u8, scale: i8) -> Result<Value, Error> {
    let value = value
        .text()
        .map_err(|_| Error::from(MISSING_STRING_VALUE))?;

    if precision == 0 && scale == -127 {
        let decimal = BigDecimal::from_str(value).map_err(|e| Error::from(e.to_string()))?;
        if decimal.is_integer() {
            let digits = decimal.digits();
            if (1..=9).contains(&digits) {
                return Ok(Value::I32(value.parse()?));
            }
            if (10..=18).contains(&digits) {
                return Ok(Value::I64(value.parse()?));
            }
        }
        return Ok(Value::String(decimal.to_string()).into_ext("Decimal"));
    }

    if scale > 0 {
        let decimal = BigDecimal::from_str(value).map_err(|e| Error::from(e.to_string()))?;
        return Ok(Value::String(decimal.to_string()).into_ext("Decimal"));
    }

    if (1..=9).contains(&precision) {
        return Ok(Value::I32(value.parse()?));
    }

    if (10..=18).contains(&precision) {
        return Ok(Value::I64(value.parse()?));
    }

    let decimal = BigDecimal::from_str(value).map_err(|e| Error::from(e.to_string()))?;
    Ok(Value::String(decimal.to_string()).into_ext("Decimal"))
}

impl Type for i32 {
    fn type_info(&self) -> OracleTypeInfo {
        OracleTypeInfo::number()
    }
}

impl Encode for i32 {
    fn encode(self, args: &mut Vec<OracleArgumentValue>) -> Result<IsNull, Error> {
        args.push(OracleArgumentValue::I32(self));
        Ok(IsNull::No)
    }
}

impl Decode for i32 {
    fn decode(value: OracleValueRef<'_>) -> Result<Self, Error> {
        Ok(value.text()?.parse()?)
    }
}

impl Type for i64 {
    fn type_info(&self) -> OracleTypeInfo {
        OracleTypeInfo::number()
    }
}

impl Encode for i64 {
    fn encode(self, args: &mut Vec<OracleArgumentValue>) -> Result<IsNull, Error> {
        args.push(OracleArgumentValue::I64(self));
        Ok(IsNull::No)
    }
}

impl Decode for i64 {
    fn decode(value: OracleValueRef<'_>) -> Result<Self, Error> {
        Ok(value.text()?.parse()?)
    }
}