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

use super::separator_optional;
use crate::WriteSql;

/// Write a `INSERT INTO` clause to start a insert sql command.
///
/// # Example
///
/// ```
/// # use sqlstr::{SqlCommand, Void, SqlExpr};
/// # use sqlstr::expr::{insert};
/// # use core::convert::Infallible;
/// # fn main() -> Result<(), Infallible> {
/// let mut sql: SqlCommand<Void> = SqlCommand::default();
/// insert(&mut sql);
///
/// assert_eq!(sql.as_command(), "INSERT INTO");
/// # Ok(())
/// # }
/// ```
pub fn insert<Sql, Arg>(sql: &mut Sql)
where
    Sql: WriteSql<Arg>,
{
    separator_optional(sql);
    sql.push_cmd("INSERT INTO");
}

/// Write an `INSERT INTO <table>` clause to start an insert command with a
/// table.
///
/// # Example
///
/// ```
/// # use sqlstr::{SqlCommand, Void, SqlExpr};
/// # use sqlstr::expr::{insert_into};
/// # use core::convert::Infallible;
/// # fn main() -> Result<(), Infallible> {
/// let mut sql: SqlCommand<Void> = SqlCommand::default();
/// insert_into(&mut sql, "user");
///
/// assert_eq!(sql.as_command(), "INSERT INTO user");
/// # Ok(())
/// # }
/// ```
pub fn insert_into<Sql, Arg>(sql: &mut Sql, table: &str)
where
    Sql: WriteSql<Arg>,
{
    separator_optional(sql);
    sql.push_cmd("INSERT INTO ");
    sql.push_cmd(table);
}

#[derive(Clone, Copy, PartialEq, Eq)]
pub enum ConflictTarget<'expr> {
    Constraint(&'expr str),
    IndexColumn(&'expr str),
}

#[derive(Clone, Copy, PartialEq, Eq)]
pub enum ConflictAction {
    Nothing,
    Update,
}

/// Writes a `ON CONFLICT <target> DO <action>` clause to specify an
/// alternative action during conflict in a `INSERT` clause.
///
/// # Example
///
/// ```
/// # use sqlstr::{SqlCommand, Void, SqlExpr};
/// # use sqlstr::expr::{on_conflict, ConflictAction, ConflictTarget};
/// # use core::convert::Infallible;
/// # fn main() -> Result<(), Infallible> {
/// let mut sql: SqlCommand<Void> = SqlCommand::default();
/// on_conflict(&mut sql, Some(ConflictTarget::Constraint("pkey_user")), ConflictAction::Update);
///
/// assert_eq!(sql.as_command(), "ON CONFLICT ON CONSTRAINT pkey_user DO UPDATE");
/// # Ok(())
/// # }
/// ```
pub fn on_conflict<'expr, Sql, Arg>(
    sql: &mut Sql,
    target: Option<ConflictTarget<'expr>>,
    action: ConflictAction,
) where
    Sql: WriteSql<Arg>,
{
    separator_optional(sql);
    sql.push_cmd("ON CONFLICT");

    if let Some(target) = target {
        match target {
            ConflictTarget::Constraint(constr_name) => {
                sql.push_cmd(" ON CONSTRAINT ");
                sql.push_cmd(constr_name);
            }
            ConflictTarget::IndexColumn(indx_expr) => {
                sql.push_cmd(" ");
                sql.push_cmd(indx_expr);
            }
        }
    }

    match action {
        ConflictAction::Nothing => {
            sql.push_cmd(" DO NOTHING");
        }
        ConflictAction::Update => {
            sql.push_cmd(" DO UPDATE");
        }
    }
}