a3s-orm 0.3.1

A type-safe, executor-neutral SQL query builder for Rust
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

use std::marker::PhantomData;

use crate::{CompiledQuery, Dialect, Error, Query, Result, Value};

#[derive(Clone, Debug)]
enum SqlPart {
    Trusted(&'static str),
    Value(Value),
}

/// A trusted static SQL query with separately bound values.
///
/// Text parts must have a static lifetime. Runtime values can only enter the
/// query through bind, which emits a dialect-specific placeholder.
#[derive(Clone, Debug)]
pub struct SqlQuery<O> {
    parts: Vec<SqlPart>,
    marker: PhantomData<fn() -> O>,
}

pub fn sql_query<O>(sql: &'static str) -> SqlQuery<O> {
    SqlQuery {
        parts: vec![SqlPart::Trusted(sql)],
        marker: PhantomData,
    }
}

impl<O> SqlQuery<O> {
    pub fn append(mut self, sql: &'static str) -> Self {
        self.parts.push(SqlPart::Trusted(sql));
        self
    }

    pub fn bind(mut self, value: impl Into<Value>) -> Self {
        self.parts.push(SqlPart::Value(value.into()));
        self
    }
}

impl<O> Query for SqlQuery<O> {
    type Output = O;

    fn compile(self, dialect: &impl Dialect) -> Result<CompiledQuery> {
        let mut sql = String::new();
        let mut parameters = Vec::new();
        for part in self.parts {
            match part {
                SqlPart::Trusted(part) => sql.push_str(part),
                SqlPart::Value(value) => {
                    parameters.push(value);
                    sql.push_str(&dialect.placeholder(parameters.len()));
                }
            }
        }
        if sql.trim().is_empty() {
            return Err(Error::EmptyRawQuery);
        }
        Ok(CompiledQuery { sql, parameters })
    }
}