rust-query 0.8.1

A query builder using rust concepts.
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

use std::marker::PhantomData;

use sea_query::IntoIden;

use crate::{
    Expr, Table, TableRow,
    alias::JoinableTable,
    value::{DbTyp, DynTypedExpr},
};

pub trait IntoJoinable<'inner, S> {
    type Typ: DbTyp;
    fn into_joinable(self) -> Joinable<'inner, S, Self::Typ>;
}

pub struct Joinable<'inner, S, T: DbTyp> {
    _p: PhantomData<Expr<'inner, S, T>>,
    pub(crate) table: JoinableTable,
    pub(crate) conds: Vec<(&'static str, DynTypedExpr)>,
}

impl<'inner, S, T: DbTyp> Joinable<'inner, S, T> {
    pub fn new(j: JoinableTable) -> Self {
        Self {
            _p: PhantomData,
            table: j,
            conds: Vec::new(),
        }
    }
}

impl<'inner, S, T: Table> Joinable<'inner, S, TableRow<T>> {
    pub fn table() -> Self {
        Self::new(JoinableTable::Normal(T::NAME.into_iden()))
    }
}
impl<'inner, S, T: DbTyp> Joinable<'inner, S, T> {
    pub fn add_cond<C: DbTyp>(mut self, col: &'static str, val: Expr<'inner, S, C>) -> Self {
        self.conds.push((col, DynTypedExpr::erase(val)));
        self
    }
}

impl<'inner, S, T: DbTyp> IntoJoinable<'inner, S> for Joinable<'inner, S, T> {
    type Typ = T;

    fn into_joinable(self) -> Joinable<'inner, S, Self::Typ> {
        self
    }
}

#[cfg(false)] // vec support doesn't work yet
trait ConstExpr<S>: crate::IntoExpr<'static, S> {
    fn into_out(self) -> <Self::Typ as DbTyp>::Out;
}

#[cfg(false)] // vec support doesn't work yet
impl<'x, S, T: IntoIterator<Item: ConstExpr<S>>> IntoJoinable<'x, S> for T {
    type Typ = <T::Item as IntoExpr<'static, S>>::Typ;

    fn into_joinable(self) -> Joinable<'x, S, Self::Typ> {
        Joinable {
            _p: PhantomData,
            table: JoinableTable::Vec(
                self.into_iter()
                    .map(|x| Self::Typ::out_to_value(x.into_out()))
                    .collect(),
            ),
            conds: Vec::new(),
        }
    }
}