welds 0.4.23

An async ORM for (postgres, mssql, mysql, sqlite)
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

use crate::writers::ColumnWriter;
use welds_connections::Syntax;

/// What is added to the query_builder, will be build into SQL
#[derive(Clone)]
pub(crate) struct SelectColumn {
    pub(crate) col_name: String,
    pub(crate) field_name: String,
    pub(crate) kind: SelectKind,
}

impl SelectColumn {
    pub fn is_aggregate(&self) -> bool {
        self.kind.is_aggregate()
    }
}
impl SelectRender {
    pub fn is_aggregate(&self) -> bool {
        self.kind.is_aggregate()
    }
}

impl SelectKind {
    pub fn is_aggregate(&self) -> bool {
        ![SelectKind::All, SelectKind::Column].contains(self)
    }
}

#[derive(PartialEq, Clone, Debug)]
pub(crate) enum SelectKind {
    Column,
    All,
    Count,
    Max,
    Min,
    Average,
    Sum,
}

/// used while writing SQL to help keep track of parts of the select
/// it is the parts needed to know how to write each part of the select
#[derive(Debug)]
pub(crate) struct SelectRender {
    pub(crate) col_name: String,
    pub(crate) field_name: String,
    pub(crate) alias: String,
    pub(crate) kind: SelectKind,
}

impl SelectRender {
    pub(crate) fn new(col: &SelectColumn, alias: impl Into<String>) -> Self {
        Self {
            col_name: col.col_name.to_owned(),
            field_name: col.field_name.to_owned(),
            alias: alias.into(),
            kind: col.kind.clone(),
        }
    }

    pub(crate) fn write(&self, syntax: Syntax) -> String {
        let writer = ColumnWriter::new(syntax);
        let colname = writer.excape(&self.col_name);
        let fieldname = writer.excape(&self.field_name);

        match self.kind {
            SelectKind::Column => {
                if colname == fieldname {
                    format!("{}.{}", self.alias, colname)
                } else {
                    format!("{}.{} AS {}", self.alias, colname, fieldname)
                }
            }
            SelectKind::All => {
                format!("{}.*", self.alias)
            }
            SelectKind::Count => {
                format!("COUNT({}.{}) AS {}", self.alias, colname, fieldname)
            }
            SelectKind::Max => {
                format!("MAX({}.{}) AS {}", self.alias, colname, fieldname)
            }
            SelectKind::Min => {
                format!("MIN({}.{}) AS {}", self.alias, colname, fieldname)
            }
            SelectKind::Average => {
                format!("AVG({}.{}) AS {}", self.alias, colname, fieldname)
            }
            SelectKind::Sum => {
                format!("SUM({}.{}) AS {}", self.alias, colname, fieldname)
            }
        }
    }
}