bmbp_rdbc_sql 0.2.8

SQL构建器
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

use std::sync::RwLock;

use bmbp_rdbc_type::{RdbcDataBase, RdbcIdent, RdbcValue};

use crate::{QueryWrapper, RdbcDmlValue, RdbcTableColumn, RdbcTableInner, RdbcTableWrapper};

pub struct InsertWrapper {
    driver_: RwLock<Option<RdbcDataBase>>,
    table_: Vec<RdbcTableInner>,
    join_: Option<Vec<RdbcTableInner>>,
    column_: Vec<RdbcTableColumn>,
    values_: Vec<RdbcDmlValue>,
    column_values: Vec<(RdbcTableColumn, RdbcDmlValue)>,
    query_: Option<QueryWrapper>,
}

impl InsertWrapper {
    pub fn new() -> InsertWrapper {
        InsertWrapper {
            driver_: RwLock::new(None),
            table_: Vec::new(),
            join_: None,
            column_: Vec::new(),
            values_: Vec::new(),
            column_values: Vec::new(),
            query_: None,
        }
    }
    pub fn set_driver(&self, driver: RdbcDataBase) -> &Self {
        *self.driver_.write().unwrap() = Some(driver);
        self
    }

    pub fn get_table(&self) -> &Vec<RdbcTableInner> {
        &self.table_
    }
    pub fn get_column(&self) -> &Vec<RdbcTableColumn> {
        &self.column_
    }
    pub fn get_values(&self) -> &Vec<RdbcDmlValue> {
        &self.values_
    }
    pub fn get_column_values(&self) -> &Vec<(RdbcTableColumn, RdbcDmlValue)> {
        &self.column_values
    }
    pub fn get_query(&self) -> Option<&QueryWrapper> {
        self.query_.as_ref()
    }
}

impl InsertWrapper {
    pub fn insert<RC, RV>(&mut self, column: RC, value: RV) -> &mut Self
    where
        RC: RdbcIdent,
        RdbcValue: From<RV>,
    {
        self.insert_column_value(column.get_ident(), RdbcValue::from(value))
    }
    pub fn column<RC>(&mut self, column: RC) -> &mut Self
    where
        RC: RdbcIdent,
    {
        self.insert_column(column.get_ident())
    }
    pub fn value<RC>(&mut self, value: RC) -> &mut Self
    where
        RdbcValue: From<RC>,
    {
        self.insert_value(RdbcValue::from(value))
    }
    pub fn insert_query(&mut self, query: QueryWrapper) -> &mut Self {
        self.query_ = Some(query);
        self
    }

    pub fn insert_column<RC>(&mut self, column: RC) -> &mut Self
    where
        RdbcTableColumn: From<RC>,
    {
        self.column_.push(RdbcTableColumn::from(column));
        self
    }
    pub fn insert_value<RV>(&mut self, value: RV) -> &mut Self
    where
        RdbcDmlValue: From<RV>,
    {
        self.values_.push(RdbcDmlValue::from(value));
        self
    }
    pub fn insert_column_value<RC, RV>(&mut self, column: RC, value: RV) -> &mut Self
    where
        RdbcTableColumn: From<RC>,
        RdbcDmlValue: From<RV>,
    {
        self.column_values
            .push((RdbcTableColumn::from(column), RdbcDmlValue::from(value)));
        self
    }
}
impl RdbcTableWrapper for InsertWrapper {
    fn get_table_mut(&mut self) -> &mut Vec<RdbcTableInner> {
        self.table_.as_mut()
    }
    fn get_join_mut(&mut self) -> &mut Vec<RdbcTableInner> {
        if self.join_.is_none() {
            self.join_ = Some(vec![]);
        }
        self.join_.as_mut().unwrap()
    }
}