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
106
107
108
109
110
111

use oracle::sql_type::OracleType;
use rbs::Value;
use std::fmt::{self, Display, Formatter};

#[derive(Debug, Clone)]
pub struct OracleTypeInfo {
    pub(crate) oracle_type: Option<OracleType>,
    pub(crate) name: String,
}

pub trait Type {
    fn type_info(&self) -> OracleTypeInfo;
}

impl<T: Type> Type for Option<T> {
    fn type_info(&self) -> OracleTypeInfo {
        match self {
            Some(value) => value.type_info(),
            None => OracleTypeInfo::null(),
        }
    }
}

impl OracleTypeInfo {
    pub fn from_oracle_type(oracle_type: OracleType) -> Self {
        Self {
            name: format!("{oracle_type:?}"),
            oracle_type: Some(oracle_type),
        }
    }

    pub fn null() -> Self {
        Self {
            oracle_type: None,
            name: "NULL".to_owned(),
        }
    }

    pub fn number() -> Self {
        Self {
            oracle_type: None,
            name: "NUMBER".to_owned(),
        }
    }

    pub fn float() -> Self {
        Self {
            oracle_type: None,
            name: "FLOAT".to_owned(),
        }
    }

    pub fn text() -> Self {
        Self {
            oracle_type: None,
            name: "VARCHAR2".to_owned(),
        }
    }

    pub fn binary() -> Self {
        Self {
            oracle_type: None,
            name: "BLOB".to_owned(),
        }
    }

    pub fn date() -> Self {
        Self {
            oracle_type: None,
            name: "DATE".to_owned(),
        }
    }

    pub fn oracle_type(&self) -> Option<&OracleType> {
        self.oracle_type.as_ref()
    }

    pub fn name(&self) -> &str {
        &self.name
    }
}

impl Display for OracleTypeInfo {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        f.pad(self.name())
    }
}

impl Type for Value {
    fn type_info(&self) -> OracleTypeInfo {
        match self {
            Value::Null => OracleTypeInfo::null(),
            Value::Bool(_) => OracleTypeInfo::number(),
            Value::I32(_) | Value::I64(_) | Value::U32(_) | Value::U64(_) => {
                OracleTypeInfo::number()
            }
            Value::F32(_) | Value::F64(_) => OracleTypeInfo::float(),
            Value::String(_) => OracleTypeInfo::text(),
            Value::Binary(_) => OracleTypeInfo::binary(),
            Value::Array(_) | Value::Map(_) => OracleTypeInfo::text(),
            Value::Ext(type_name, _) => match *type_name {
                "Date" | "DateTime" | "Time" => OracleTypeInfo::date(),
                "Timestamp" => OracleTypeInfo::number(),
                "Decimal" => OracleTypeInfo::number(),
                "Json" => OracleTypeInfo::binary(),
                "Uuid" => OracleTypeInfo::text(),
                _ => OracleTypeInfo::null(),
            },
        }
    }
}