welds 0.4.23

An async ORM for (postgres, mssql, mysql, sqlite)
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164

use crate::connections::Row;
use crate::errors::WeldsError;
use crate::model_traits::{HasSchema, TableColumns, TableInfo, UniqueIdentifier};
use crate::query::builder::QueryBuilder;
use crate::query::clause::{AsFieldName, ClauseAdder};
use crate::relations::{HasRelations, Relationship};

mod exec;
pub(crate) mod related_query;
use related_query::{IncludeQuery, RelatedQuery};
#[cfg(test)]
mod tests;

/// An un-executed Query Selecting a model AND its relationship objects.
pub struct IncludeBuilder<T> {
    qb: QueryBuilder<T>,
    related: Vec<Box<dyn RelatedQuery<T> + Sync + Send>>,
}

impl<T> IncludeBuilder<T>
where
    T: Send + HasSchema,
{
    pub fn new(qb: QueryBuilder<T>) -> Self {
        Self {
            qb,
            related: Vec::default(),
        }
    }

    /// Include models related to this model in the returned data. `BelongsTo` `HasMany`.
    /// querying will continue over your current Object, but the related object will be
    /// accessible in the resulting dataset off of each instance of your model
    pub fn include<R, Ship>(
        mut self,
        relationship: impl Fn(<T as HasRelations>::Relation) -> Ship,
    ) -> IncludeBuilder<T>
    where
        T: 'static + HasRelations,
        Ship: 'static + Sync + Relationship<T, R>,
        R: HasSchema,
        R: 'static,
        R: Send + Sync + HasSchema,
        <R as HasSchema>::Schema: TableInfo + TableColumns + UniqueIdentifier,
        <T as HasSchema>::Schema: TableInfo + TableColumns + UniqueIdentifier,
        <T as HasRelations>::Relation: Default,
        R: TryFrom<Row>,
        WeldsError: From<<R as TryFrom<Row>>::Error>,
    {
        // capture how to run this query as a sub-query in on the related table
        let ship = relationship(Default::default());
        let out_col = ship.their_key();
        let inner_tn = <T as HasSchema>::Schema::identifier();
        let inner_col = ship.my_key();

        let include_query: IncludeQuery<T, R, Ship> = IncludeQuery::<T, R, Ship> {
            _t: Default::default(),
            row_type: Default::default(),
            out_col,
            inner_tn,
            inner_col,
            ship: ship.clone(),
            qb: QueryBuilder::new(),
        };

        self.related.push(Box::new(include_query));
        self
    }

    /// Include models related to this model in the returned data. `BelongsTo` `HasMany`.
    /// querying will continue over your current Object, but the related object will be
    /// accessible in the resulting dataset off of each instance of your model
    ///
    /// This is identical the `include` but allows for a filter to be applied to the included data
    pub fn include_where<R, Ship>(
        mut self,
        relationship: impl Fn(<T as HasRelations>::Relation) -> Ship,
        qb: QueryBuilder<R>,
    ) -> IncludeBuilder<T>
    where
        T: 'static + HasRelations,
        Ship: 'static + Sync + Relationship<T, R>,
        R: HasSchema,
        R: 'static,
        R: Send + Sync + HasSchema,
        <R as HasSchema>::Schema: TableInfo + TableColumns + UniqueIdentifier,
        <T as HasSchema>::Schema: TableInfo + TableColumns + UniqueIdentifier,
        <T as HasRelations>::Relation: Default,
        R: TryFrom<Row>,
        WeldsError: From<<R as TryFrom<Row>>::Error>,
    {
        let ship = relationship(Default::default());
        let out_col = ship.their_key();
        let inner_tn = <T as HasSchema>::Schema::identifier();
        let inner_col = ship.my_key();

        let include_query: IncludeQuery<T, R, Ship> = IncludeQuery::<T, R, Ship> {
            _t: Default::default(),
            row_type: Default::default(),
            out_col,
            inner_tn,
            inner_col,
            ship: ship.clone(),
            qb,
        };

        self.related.push(Box::new(include_query));
        self
    }

    /// Filter the results returned by this query.
    /// Used when you want to filter on the columns of this table.
    pub fn where_col(
        mut self,
        lam: impl Fn(<T as HasSchema>::Schema) -> Box<dyn ClauseAdder>,
    ) -> Self
    where
        <T as HasSchema>::Schema: Default,
    {
        self.qb = self.qb.where_col(lam);
        self
    }

    /// Limit the number of rows returned by this query
    pub fn limit(mut self, x: i64) -> Self {
        self.qb = self.qb.limit(x);
        self
    }

    /// Offset the starting point for the results returned by this query
    pub fn offset(mut self, x: i64) -> Self {
        self.qb = self.qb.offset(x);
        self
    }

    /// Order the results of the query by a given column
    ///
    /// multiple calls will result in multiple OrderBys
    pub fn order_by_desc<V, FN: AsFieldName<V>>(
        mut self,
        lam: impl Fn(<T as HasSchema>::Schema) -> FN,
    ) -> Self {
        self.qb = self.qb.order_by_desc(lam);
        self
    }

    /// Order the results of the query by a given column
    ///
    /// multiple calls will result in multiple OrderBys
    pub fn order_by_asc<V, FN: AsFieldName<V>>(
        mut self,
        lam: impl Fn(<T as HasSchema>::Schema) -> FN,
    ) -> Self {
        self.qb = self.qb.order_by_asc(lam);
        self
    }

    // pub(crate) fn set_aliases(&mut self, alias_asigner: &Arc<TableAlias>) {
    //     self.qb.set_aliases(alias_asigner);
    //     for join in &mut self.joins {
    //         join.set_aliases(&self.qb.alias_asigner);
    //     }
    // }
}