mik-sql 0.1.2

SQL query builder with Mongo-style filters - sql_read!, sql_create!, sql_update!, sql_delete!
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

//! INSERT query builder.

use crate::dialect::{Dialect, Postgres, Sqlite};
use crate::validate::assert_valid_sql_identifier;

use super::types::{QueryResult, Value};

/// Builder for INSERT queries.
#[derive(Debug)]
#[must_use = "builder does nothing until .build() is called"]
pub struct InsertBuilder<D: Dialect> {
    dialect: D,
    table: String,
    columns: Vec<String>,
    values: Vec<Vec<Value>>,
    returning: Vec<String>,
}

impl<D: Dialect> InsertBuilder<D> {
    /// Create a new insert builder.
    ///
    /// # Panics
    ///
    /// Panics if the table name is not a valid SQL identifier.
    pub fn new(dialect: D, table: impl Into<String>) -> Self {
        let table = table.into();
        assert_valid_sql_identifier(&table, "table");
        Self {
            dialect,
            table,
            columns: Vec::new(),
            values: Vec::new(),
            returning: Vec::new(),
        }
    }

    /// Set the columns for insertion.
    ///
    /// # Panics
    ///
    /// Panics if any column name is not a valid SQL identifier.
    pub fn columns(mut self, columns: &[&str]) -> Self {
        for col in columns {
            assert_valid_sql_identifier(col, "column");
        }
        self.columns = columns.iter().map(|s| (*s).to_string()).collect();
        self
    }

    /// Add a row of values.
    pub fn values(mut self, values: Vec<Value>) -> Self {
        self.values.push(values);
        self
    }

    /// Add multiple rows of values.
    pub fn values_many(mut self, rows: Vec<Vec<Value>>) -> Self {
        self.values.extend(rows);
        self
    }

    /// Add RETURNING clause (Postgres).
    ///
    /// # Panics
    ///
    /// Panics if any column name is not a valid SQL identifier.
    pub fn returning(mut self, columns: &[&str]) -> Self {
        for col in columns {
            assert_valid_sql_identifier(col, "returning column");
        }
        self.returning = columns.iter().map(|s| (*s).to_string()).collect();
        self
    }

    /// Build the INSERT query.
    pub fn build(self) -> QueryResult {
        let mut sql = String::new();
        let mut params = Vec::new();
        let mut param_idx = 1usize;

        // INSERT INTO table (columns)
        sql.push_str(&format!(
            "INSERT INTO {} ({})",
            self.table,
            self.columns.join(", ")
        ));

        // VALUES (...)
        let mut value_groups = Vec::new();
        for row in &self.values {
            let placeholders: Vec<String> = row
                .iter()
                .map(|v| {
                    let p = self.dialect.param(param_idx);
                    params.push(v.clone());
                    param_idx += 1;
                    p
                })
                .collect();
            value_groups.push(format!("({})", placeholders.join(", ")));
        }
        sql.push_str(&format!(" VALUES {}", value_groups.join(", ")));

        // RETURNING clause
        if !self.returning.is_empty() {
            sql.push_str(&format!(" RETURNING {}", self.returning.join(", ")));
        }

        QueryResult { sql, params }
    }
}

/// Create an INSERT builder for Postgres.
pub fn insert(table: impl Into<String>) -> InsertBuilder<Postgres> {
    InsertBuilder::new(Postgres, table)
}

/// Create an INSERT builder for `SQLite`.
pub fn insert_sqlite(table: impl Into<String>) -> InsertBuilder<Sqlite> {
    InsertBuilder::new(Sqlite, table)
}