Skip to main content

cartel_sqlite/dsl/query/
mod.rs

1use crate::dsl::{agg, scope::never::Never, write};
2
3pub mod join;
4
5pub struct Filter<T>(Never<T>);
6pub struct Rows<T>(Never<T>);
7pub struct Cte<T>(Never<T>);
8pub struct Select<T>(Never<T>);
9pub struct Stream<T>(Never<T>);
10
11impl<T> Filter<T> {
12    pub fn rows(self) -> Rows<T> {
13        self.0.infer(())
14    }
15
16    pub fn count(self) -> i64 {
17        self.0.infer(())
18    }
19
20    pub fn sum<F, U, R>(self, map: F) -> Option<R>
21    where
22        F: FnOnce(T) -> U,
23    {
24        self.0.infer(map)
25    }
26
27    pub fn avg<F, U, R>(self, map: F) -> Option<R>
28    where
29        F: FnOnce(T) -> U,
30    {
31        self.0.infer(map)
32    }
33
34    pub fn min<F, U, R>(self, map: F) -> Option<R>
35    where
36        F: FnOnce(T) -> U,
37    {
38        self.0.infer(map)
39    }
40
41    pub fn max<F, U, R>(self, map: F) -> Option<R>
42    where
43        F: FnOnce(T) -> U,
44    {
45        self.0.infer(map)
46    }
47
48    pub fn group_by<F, K>(self, key: F) -> agg::Group<T, K>
49    where
50        F: FnOnce(T) -> K,
51    {
52        self.0.infer(key)
53    }
54
55    pub fn update<F>(self, change: F) -> write::Update<T>
56    where
57        F: FnOnce(&mut T),
58    {
59        self.0.infer(change)
60    }
61
62    pub fn delete(self) -> write::Delete<T> {
63        self.0.infer(())
64    }
65
66    pub fn union(self, other: Self) -> Self {
67        self.0.infer(other)
68    }
69
70    pub fn union_all(self, other: Self) -> Self {
71        self.0.infer(other)
72    }
73
74    pub fn intersect(self, other: Self) -> Self {
75        self.0.infer(other)
76    }
77
78    pub fn except(self, other: Self) -> Self {
79        self.0.infer(other)
80    }
81
82    pub fn cte(self) -> Cte<T> {
83        self.0.infer(())
84    }
85}
86
87impl<T> Rows<T> {
88    pub fn one(self) -> T {
89        self.0.infer(())
90    }
91
92    pub fn first(self) -> Option<T> {
93        self.0.infer(())
94    }
95
96    pub fn all(self) -> Vec<T> {
97        self.0.infer(())
98    }
99
100    pub fn stream(self) -> Stream<T> {
101        self.0.infer(())
102    }
103
104    pub fn order_by<F, U>(self, key: F) -> Self
105    where
106        F: FnOnce(T) -> U,
107    {
108        self.0.infer(key)
109    }
110
111    pub fn order_desc<F, U>(self, key: F) -> Self
112    where
113        F: FnOnce(T) -> U,
114    {
115        self.0.infer(key)
116    }
117
118    pub fn limit(self, count: i64) -> Self {
119        self.0.infer(count)
120    }
121
122    pub fn offset(self, count: i64) -> Self {
123        self.0.infer(count)
124    }
125
126    pub fn distinct(self) -> Self {
127        self.0.infer(())
128    }
129
130    pub fn select<F, R>(self, map: F) -> Select<R>
131    where
132        F: FnOnce(T) -> R,
133    {
134        self.0.infer(map)
135    }
136}
137
138impl<T> Cte<T> {
139    pub fn filter<F>(self, pred: F) -> Filter<T>
140    where
141        F: FnOnce(T) -> bool,
142    {
143        self.0.infer(pred)
144    }
145}
146
147impl<T> Select<T> {
148    pub fn one(self) -> T {
149        self.0.infer(())
150    }
151
152    pub fn first(self) -> Option<T> {
153        self.0.infer(())
154    }
155
156    pub fn all(self) -> Vec<T> {
157        self.0.infer(())
158    }
159}