i_dao 0.1.3

mysql 数据库增改查
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

use log::{debug, warn};
use crate::{sql};
use std::collections::HashMap;
use std::any::Any;
use r2d2_mysql::mysql::{Transaction, Value, Row};
use r2d2_mysql::mysql::prelude::Queryable;
use r2d2_mysql::{MySqlConnectionManager, r2d2};
use crate::library_test::test_user;

pub fn query_list(tx: &mut Transaction, condition_params: &HashMap<String, Box<dyn Any>>, condition: &[sql:: Condition]) -> Result<Vec<test_user::TestUser>, Box<dyn std::error::Error>> {
    let mut query_sql = format!("SELECT {} FROM {}", test_user::get_field_sql(""), test_user::TABLE_NAME);
    let mut params: Vec<Value> = vec![];

    let (mut where_sql,page_index,page_size,mut order_by_sql_field,order_by_sql_type) = sql::pot_base_condition(&mut params, &condition);

    for (key, val) in condition_params.iter() {
        let (i_key, operator) = sql::get_real_key_operator(key.to_string());
        if "" != where_sql {
            where_sql = format!(" {} AND {} {} ?", where_sql, i_key, operator)
        } else {
            where_sql = format!(" {} {} ?", i_key, operator)
        }

        if !sql::pot_params_condition(&mut params, &val) {
            warn!("test_user_dao::query_list::pot_params_condition - {} 参数装入失败", key)
        }
    }

    if "" != where_sql {
        query_sql = format!("{} WHERE {}", query_sql, where_sql);
    }
    if "" == order_by_sql_field {
        order_by_sql_field = "id".to_string();
    }
    query_sql = format!(" {} ORDER BY {} {}", query_sql, order_by_sql_field, order_by_sql_type);
    query_sql = format!("{} LIMIT {},{}", query_sql, (page_index-1) * page_size, page_size);

    debug!("test_user_dao::query_list::query_sql={}", query_sql);
    let result = tx.exec_map(
        query_sql,  params ,|row: Row| test_user::pot(row, 0)

    );

    if result.is_err() {
        warn!("b_d::test_user_dao::query_list 失败！ res={:?}", result);
        return Ok(result?);
    }

    return Ok(result?);
}

pub fn query_count(conn: &mut r2d2::PooledConnection<MySqlConnectionManager>, condition_params: &HashMap<String, Box<dyn Any>>, condition: &[sql:: Condition]) -> Result<u64, Box<dyn std::error::Error>> {
    let mut query_sql = format!("SELECT COUNT(1) AS co FROM {}", test_user::TABLE_NAME);
    let mut params: Vec<Value> = vec![];

    let mut where_sql = sql::pot_base_condition_by_time(&mut params, &condition);

    for (key, val) in condition_params.iter() {
        let (i_key, operator) = sql::get_real_key_operator(key.to_string());
        if "" != where_sql {
            where_sql = format!(" {} AND {} {} ?", where_sql, i_key, operator)
        } else {
            where_sql = format!(" {} {} ?", i_key, operator)
        }

        if !sql::pot_params_condition(&mut params, &val) {
            warn!("test_user_dao::query_count::pot_params_condition - {} 参数装入失败", key)
        }
    }

    if "" != where_sql {
        query_sql = format!("{} WHERE {}", query_sql, where_sql);
    }

    debug!("test_user_dao::query_count::query_sql={}", query_sql);
    let result = conn.exec_first::<u64,_,_> (
        query_sql,  params );

    return match result {
        Err(e) => {
            Err(Box::new(e))
        },
        Ok(op) => {
            return match op {
                Some(c) => {
                    Ok(c)
                },
                _ => {
                    Ok(0)
                }
            }
        },
    };
}

pub fn find_by_id(tx: &mut Transaction, id: u64) -> Result<Option<test_user::TestUser>, Box<dyn std::error::Error>> {
    let query_sql = format!("SELECT {} FROM {} WHERE {} = ? LIMIT 0,1", test_user::get_field_sql("") ,test_user::TABLE_NAME, test_user::FIELDS[0]);
    let result = tx.exec_map(
        query_sql, (id,),|row: Row| test_user::pot(row, 0)

    );
    if result.is_err() {
        warn!("b_d::test_user_dao::find_by_id 失败！ res={:?}", result);
        return match result {
            Err(e) => {
                Err(Box::new(e))
            },
            Ok(_) => {
                unimplemented!()
            },
        };
    }

    let mut lst = result.unwrap();
    if 0 == lst.len() {
        return Ok(None);
    }

    let one:Option<test_user::TestUser> = lst.pop();
    return Ok(one);
}