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

use crate::{
    Error,
    statements::select::{
        Column, SelectProps,
        sql_implementations::{
            mutate_query::{filters, group_by, join_operations, order_by},
            oracle::columns::get_column_names_oracle,
        },
    },
};

pub(crate) mod multithread;
pub(crate) mod mutate_query;
pub mod oracle;
pub mod sqlite;

pub(crate) fn shared_select_operations(
    select_props: &SelectProps,
    mut query: String,
) -> Result<String, Error> {
    if &select_props.joins.len() > &0 {
        query = join_operations(&select_props, query);
    }

    // ===== Where, and, or =====
    query = filters(&select_props, &query);

    if let Some(group) = &select_props.group_by {
        query = group_by(group, &query);
    }

    if let Some(order) = &select_props.order_by {
        query = order_by(order, &query);
    }

    Ok(query)
}

impl SelectProps {
    pub(crate) fn oracle_column_name(&self) -> Result<Vec<String>, Error> {
        self.columns
            .iter()
            .map(|col| -> Result<String, Error> { col.to_query_string(self) })
            .collect::<Result<Vec<String>, Error>>()
    }
}

impl Column {
    pub(crate) fn to_query_string(&self, select_props: &SelectProps) -> Result<String, Error> {
        let col = match self {
            crate::statements::select::Column::Name(name) => {
                format!("{}.{}", name.table, name.name)
            }
            crate::statements::select::Column::Function(function) => {
                format!("{}", function)
            }
            crate::statements::select::Column::Varchar(varchar) => format!("'{}'", varchar),
            crate::statements::select::Column::ALL(all) => {
                let columns = get_column_names_oracle(&select_props)?;
                columns
                    .iter()
                    .map(|col| format!("{}.{}", all, col.name))
                    .collect::<Vec<String>>()
                    .join(", ")
            }
        };
        Ok(col)
    }
}