taitan-orm-parser 0.1.11

Next Generation ORM based on sqlx
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

use crate::template::MaybeValue;
use crate::template_parser::structs::atomics::postgres_atomic::PostgresAtomic;
use crate::template_parser::structs::bool_value::Bool;
use crate::template_parser::structs::text::Text;
use crate::template_parser::to_sql::SqlSegment;
use crate::{Number, Operator, Sign, ToSqlSegment};
use crate::template_parser::structs::atomics::mysql_atomic::MySqlAtomic;
use crate::template_parser::structs::atomics::sqlite_atomic::SqliteAtomic;

#[derive(Debug, Clone, PartialEq)]
pub enum GenericAtomic {
    Null,
    Number(Number),
    Text(Text),
    Bool(Bool),
    Operator(Operator), // 各类操作符+-*/% like in = > < <> !=
    Maybe(MaybeValue),  // 可能是Number/Text/Bool/Operator
    Sign(Sign),         // 各种特殊符号，例如括号()[]{}等
    Keyword(&'static str),
}

impl From<PostgresAtomic> for GenericAtomic {
    fn from(pg_atomic: PostgresAtomic) -> Self {
        match pg_atomic {
            PostgresAtomic::Null => GenericAtomic::Null,
            PostgresAtomic::Number(n) => Self::Number(n),
            PostgresAtomic::Text(t) => Self::Text(t),
            PostgresAtomic::Bool(b) => Self::Bool(b),
            PostgresAtomic::Operator(o) => Self::Operator(o),
            PostgresAtomic::Maybe(m) => Self::Maybe(m),
            PostgresAtomic::Sign(s) => Self::Sign(s),
            PostgresAtomic::Keyword(k) => Self::Keyword(k.0),
        }
    }
}

impl From<MySqlAtomic> for GenericAtomic  {
    fn from(pg_atomic: MySqlAtomic) -> Self {
        match pg_atomic.into() {
            MySqlAtomic::Null => GenericAtomic::Null,
            MySqlAtomic::Number(n) => Self::Number(n),
            MySqlAtomic::Text(t) => Self::Text(t),
            MySqlAtomic::Bool(b) => Self::Bool(b),
            MySqlAtomic::Operator(o) => Self::Operator(o),
            MySqlAtomic::Maybe(m) => Self::Maybe(m),
            MySqlAtomic::Sign(s) => Self::Sign(s),
            MySqlAtomic::Keyword(k) => Self::Keyword(k.0),
        }
    }
}

impl From<SqliteAtomic> for GenericAtomic {
    fn from(pg_atomic: SqliteAtomic) -> Self {
        match pg_atomic.into() {
            SqliteAtomic::Null => GenericAtomic::Null,
            SqliteAtomic::Number(n) => Self::Number(n),
            SqliteAtomic::Text(t) => Self::Text(t),
            SqliteAtomic::Bool(b) => Self::Bool(b),
            SqliteAtomic::Operator(o) => Self::Operator(o),
            SqliteAtomic::Maybe(m) => Self::Maybe(m),
            SqliteAtomic::Sign(s) => Self::Sign(s),
            SqliteAtomic::Keyword(k) => Self::Keyword(k.0),
        }
    }
}
impl ToSqlSegment for GenericAtomic {
    fn gen_sql_segment(&self) -> SqlSegment {
        match self {
            GenericAtomic::Null=>SqlSegment::Simple("NULL".to_string()),
            GenericAtomic::Sign(s) => SqlSegment::Simple(s.to_string()),
            GenericAtomic::Maybe(m) => SqlSegment::Simple(m.gen_sql_segment().to_sql(false).to_string()),
            GenericAtomic::Operator(b) => SqlSegment::Simple(b.to_string()),
            GenericAtomic::Bool(b) => SqlSegment::Simple(b.to_string()),
            GenericAtomic::Text(t) => SqlSegment::Simple(t.to_string()),
            GenericAtomic::Number(n) => SqlSegment::Simple(n.to_string()),
            GenericAtomic::Keyword(k) => SqlSegment::Simple(k.to_string()),
        }
    }
}