odbc 0.17.0

ODBC wrapper for idiomatic 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
75

extern crate odbc;
// Use this crate and set environment variable RUST_LOG=odbc to see ODBC warnings
extern crate env_logger;
extern crate chrono;
extern crate odbc_safe;

use odbc::*;
use chrono::prelude::*;
use odbc_safe::AutocommitMode;

trait Extract {
    fn extract<T>(&mut self, index: u16) -> Option<T>
    where
        T: MySupportedType;
}

impl<'s, 'a: 's, S: 's, AC: AutocommitMode> Extract for Cursor<'s, 'a, 'a, S, AC> {
    fn extract<T>(&mut self, index: u16) -> Option<T>
    where
        T: MySupportedType,
    {
        MySupportedType::extract_from(self, index)
    }
}

trait MySupportedType
where
    Self: Sized,
{
    fn extract_from<'a, 'con, S, AC: AutocommitMode>(
        cursor: &mut odbc::Cursor<'a, 'con, 'con, S, AC>,
        index: u16,
    ) -> Option<Self>;
}

impl MySupportedType for DateTime<Local> {
    fn extract_from<'a, 'con, S, AC: AutocommitMode>(
        cursor: &mut odbc::Cursor<'a, 'con, 'con, S, AC>,
        index: u16,
    ) -> Option<Self> {
        cursor.get_data(index).expect("Can't get column").map(
            |datetime: String| {
                Local
                    .datetime_from_str(&datetime, "%Y-%m-%d %H:%M:%S%.f")
                    .unwrap()
            },
        )
    }
}

fn main() {
    env_logger::init();
    println!("Success: {}", test_me().unwrap().expect("No result!"))
}

fn test_me() -> std::result::Result<Option<DateTime<Local>>, DiagnosticRecord> {
    let env = create_environment_v3().map_err(|e| {
        e.expect("Can't create ODBC environment")
    })?;
    let conn = env.connect("PostgreSQL", "postgres", "postgres")?;
    let mut result = Statement::with_parent(&conn)?.exec_direct(
        "select current_timestamp",
    )?;

    if let &mut Data(ref mut stmt) = &mut result {
        let val = stmt.fetch().expect("Can't get cursor").and_then(
            |mut cursor| {
                cursor.extract(1)
            },
        );
        Ok(val)
    } else {
        Ok(None)
    }
}