sql_tools 0.11.10

A rust crate meant to make SQL queries simple and communication between various SQL versions easy.
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

use execution::stmt_res;

use crate::{
    Error, SQLImplementation,
    data_types::{SQLDataTypes, ToSQLData},
    sql_implementations::OracleConnect,
    statements::select::{
        SelectProps,
        sql_implementations::{
            multithread::multithread_execution, mutate_query::limit_offset_oracle,
            oracle::execution::oracle_handle_execution, shared_select_operations,
        },
    },
};

pub mod columns;
pub mod execution;

pub(crate) fn oracle_build_select(
    select_props: SelectProps,
) -> Result<Vec<Vec<Box<SQLDataTypes>>>, Error> {
    let table = &select_props.table;
    let cols = select_props.oracle_column_name()?;

    let header = &cols
        .iter()
        .map(|col| {
            let col = col.split(".").collect::<Vec<&str>>();
            let col = col[col.len() - 1];
            let col = col.split(" ").collect::<Vec<&str>>();
            let col = col[col.len() - 1];
            let col = col.split(" as ").collect::<Vec<&str>>();
            let col = col[col.len() - 1];
            Box::new(col.to_sql_fmt())
        })
        .collect::<Vec<Box<SQLDataTypes>>>();
    let columns = &cols.join(", ");
    
    let mut query = format!("SELECT {} FROM {}", &columns, &table,);

    let mut count_sql = format!("SELECT COUNT(*) FROM {}", &table);

    query = shared_select_operations(&select_props, query)?;
    count_sql = shared_select_operations(&select_props, count_sql)?;

    query = limit_offset_oracle(&select_props, query);
    count_sql = limit_offset_oracle(&select_props, count_sql);

    let conn_info = extract_connection(&select_props.connect)?;
    let conn: oracle::Connection = oracle::Connection::connect(
        &conn_info.username,
        &conn_info.password,
        &conn_info.connection_string,
    )?;

    let mut count: Option<usize> = None;
    let count_query = conn.query(&count_sql, &[])?;
    for res in count_query {
        let row = res?;
        // might change get_as type to Option<usize>
        count = row.get_as::<Option<usize>>()?;
    }

    multithread_execution( SQLImplementation::Oracle(conn_info),oracle_handle_execution, select_props, header, query, count)
}

pub(crate) fn oracle_build_single_thread_select(
    select_props: SelectProps,
) -> Result<Vec<Vec<Box<SQLDataTypes>>>, Error> {
    let table = &select_props.table;
    let cols = select_props.oracle_column_name()?;

    let header = &cols
        .iter()
        .map(|col| {
            let col = col.split(".").collect::<Vec<&str>>();
            let col = col[col.len() - 1];
            let col = col.split(" ").collect::<Vec<&str>>();
            let col = col[col.len() - 1];
            let col = col.split(" as ").collect::<Vec<&str>>();
            let col = col[col.len() - 1];
            Box::new(col.to_sql_fmt())
        })
        .collect::<Vec<Box<SQLDataTypes>>>();
    let columns = &cols.join(", ");

    let mut query = format!("SELECT {} FROM {}", &columns, &table,);

    query = shared_select_operations(&select_props, query)?;
    query = limit_offset_oracle(&select_props, query);

    let conn_info = extract_connection(&select_props.connect)?;
    let conn: oracle::Connection = oracle::Connection::connect(
        conn_info.username,
        conn_info.password,
        conn_info.connection_string,
    )?;

    let stmt = conn.statement(&query).build()?;
    let column_size = header.len();
    let mut res = stmt_res(stmt, column_size, false)?;
    if select_props.return_header {
        let header = header
            .iter()
            .map(|head| {
                let head = head.to_string();
                let head = head.split(" as ").collect::<Vec<&str>>();
                let head = head[head.len() - 1];
                let head = head.split(" ").collect::<Vec<&str>>();
                let head = head[head.len() - 1];
                let head = head.split(".").collect::<Vec<&str>>();
                let head = head[head.len() - 1];
                Box::new(head.to_sql_fmt())
            })
            .collect::<Vec<Box<SQLDataTypes>>>();
        let header = vec![header.to_owned()];
        res.splice(..0, header.iter().cloned());
    }
    Ok(res)
}

fn extract_connection(connect: &SQLImplementation) -> Result<OracleConnect, Error> {
    match connect {
        SQLImplementation::Oracle(oracle_connect) => Ok(oracle_connect.to_owned()),
        SQLImplementation::SQLite(_) => return Err(Error::SQLVariationError),
    }
}