sqlstr 0.1.0

Sql string builder
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
120
121
122
123
124
125
126
127
128
129

use super::{BinaryOperator, UnaryOperator, WriteSql};

/// Math binary operators
#[cfg_attr(any(feature = "fmt", test, debug_assertions), derive(Debug))]
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum MathBi {
    /// Adition `+`
    ///
    /// 2 + 3
    Add,
    /// Subtration `-`
    ///
    /// 2 - 3
    Sub,
    /// Multiplication `*`
    ///
    /// 5 * 2
    Mult,
    /// Division `/`
    ///
    /// 4 / 2
    Div,
    /// Module `%`
    ///
    /// 3 % 2
    Mod,
    /// Bitwise and `&`
    ///
    /// 0b0101 & 0b0001
    BitAnd,
    /// Bitwise or `|`
    ///
    /// 0b0101 | 0b0001
    BitOr,
    /// Bitwise xor `^`
    ///
    /// 0b0101 ^ 0b0001
    BitXor,
    /// Bit shift left `<<`
    ///
    /// 0b0101 << 0b0001
    ShiftLeft,
    /// Bit shift left `>>`
    ///
    /// 0b0101 >> 0b0001
    ShiftRight,
}

impl MathBi {
    pub const fn as_str(&self) -> &'static str {
        match *self {
            Self::Add => "+",
            Self::Sub => "-",
            Self::Mult => "*",
            Self::Div => "/",
            Self::Mod => "%",
            Self::BitAnd => "&",
            Self::BitOr => "|",
            Self::BitXor => "^",
            Self::ShiftLeft => "<<",
            Self::ShiftRight => ">>",
        }
    }
}

impl super::private::Sealed for MathBi {}

impl BinaryOperator for MathBi {
    fn push_operator<Sql, Arg>(&self, sql: &mut Sql)
    where
        Sql: WriteSql<Arg>,
    {
        sql.push_cmd(self.as_str())
    }
}

/// Math binary operators
#[cfg_attr(any(feature = "fmt", test, debug_assertions), derive(Debug))]
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum MathUnary {
    /// Negation `-`
    ///
    /// - (-1)
    Neg,
    /// Bitwise not `~`
    ///
    /// ~ 0b0101
    BitNot,
}

impl MathUnary {
    pub const fn as_str(&self) -> &'static str {
        match *self {
            Self::Neg => "!",
            Self::BitNot => "~",
        }
    }
}

impl super::private::Sealed for MathUnary {}

impl UnaryOperator for MathUnary {
    fn push_operator<Sql, Arg>(&self, sql: &mut Sql)
    where
        Sql: WriteSql<Arg>,
    {
        sql.push_cmd(self.as_str())
    }
}

/// Math functions
#[cfg_attr(any(feature = "fmt", test, debug_assertions), derive(Debug))]
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum MathFn {
    /// Square root
    Sqrt,
    /// Exponentiation `^`
    ///
    /// 2 ^ 8
    Exp,
    /// Factorial
    ///
    /// 5!
    Factorial,
    /// Absolute
    ///
    /// |-3|
    Abs,
}