db_meta_derive 0.1.0

db-meta-derive is a wrapper around PostgresSOL using tokio-postgres
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

use std::time::SystemTime;
use db_derive::{PostgresMeta};


mod test;

#[allow(dead_code)]
#[derive(Debug, PostgresMeta)]
#[pg_mapper(table = "oms_order")]
pub struct Command{
    #[id]
    id: i64,
    #[field(type="varchar", length=50)]
    name: String,
    #[field(type="varchar", length=200)]
    nickname: Option<String>,
    age: Option<i16>,
    create_time: Option<SystemTime>,
}

#[derive(Debug)]
enum Data {
    BigInt(Option<i64>),
    Int(Option<i32>),
    SmallInt(Option<i16>),
    Float(Option<f64>),
    String(Option<String>),
    SystemTime(Option<SystemTime>),
}

impl Command {
    pub fn to_vec_1(self) -> Result<Vec<Data>, &'static str> {
        let mut v = vec![];
        v.push(Data::BigInt(Some(self.id)));
        v.push(Data::String(Some(self.name)));
        v.push(Data::String(self.nickname));
        v.push(Data::SmallInt(self.age));
        v.push(Data::SystemTime(self.create_time));
        Ok(v)
    }

}

pub fn main(){
    let mut data_vec: Vec<Data> = Vec::new();
    data_vec.push(Data::Int(Some(10)));
    data_vec.push(Data::Float(Some(3.14)));
    data_vec.push(Data::String(Some(String::from("Hello, World!"))));

    for datum in data_vec {
        match datum {
            Data::Int(i) => println!("Integer: {}", i.unwrap()),
            Data::Float(f) => println!("Float: {}", f.unwrap()),
            Data::String(s) => println!("String: {}", s.unwrap()),
            _ => {}
        }
    }


    let c = Command::meta();
    let (table_name, fields): (String, Vec<(String, String, u16, String, bool)>) = Command::meta();
    println!("{:?}", fields);

    let b = Command {
        id: 0,
        name: "111".to_string(),
        nickname: None,
        age: None,
        create_time: None,
    };


    let b = b.to_vec_1();
    println!("builder: {:?}", b);
    // let create = Command::sql().create();
    // println!("create: {:?}", create);
    //
    // let insert = Command::sql().insert();
    // println!("insert: {:?}", insert);
    //
    // let select = Command::sql()
    //     .condition(Some("uid=$1".to_string()))
    //     .order(Some("createdate desc".to_string()))
    //     .select();
    // println!("select: {:?}", select);
    //
    // let update = Command::sql()
    //     .renew(Some("uid=$1".to_owned()))
    //     .condition(Some("uid=$2".to_string()))
    //     .update();
    // println!("update: {:?}", update);
    //
    // let delete = Command::sql().delete();
    // println!("delete: {:?}", delete);
}