diesel/query_builder/
combination_clause.rs

Help
1//! Combine queries using a combinator like `UNION`, `INTERSECT` or `EXPECT`
2//! with or without `ALL` rule for duplicates
3
4use crate::backend::{Backend, DieselReserveSpecialization};
5use crate::expression::subselect::ValidSubselect;
6use crate::expression::NonAggregate;
7use crate::query_builder::insert_statement::InsertFromSelect;
8use crate::query_builder::{AsQuery, AstPass, Query, QueryFragment, QueryId, SelectQuery};
9use crate::{CombineDsl, Insertable, QueryResult, RunQueryDsl, Table};
10
11#[derive(Debug, Copy, Clone, QueryId)]
12#[must_use = "Queries are only executed when calling `load`, `get_result` or similar."]
13/// Combine queries using a combinator like `UNION`, `INTERSECT` or `EXPECT`
14/// with or without `ALL` rule for duplicates
15pub struct CombinationClause<Combinator, Rule, Source, Rhs> {
16    combinator: Combinator,
17    duplicate_rule: Rule,
18    source: ParenthesisWrapper<Source>,
19    rhs: ParenthesisWrapper<Rhs>,
20}
21
22impl<Combinator, Rule, Source, Rhs> CombinationClause<Combinator, Rule, Source, Rhs> {
23    /// Create a new combination
24    pub(crate) fn new(
25        combinator: Combinator,
26        duplicate_rule: Rule,
27        source: Source,
28        rhs: Rhs,
29    ) -> Self {
30        CombinationClause {
31            combinator,
32            duplicate_rule,
33            source: ParenthesisWrapper(source),
34            rhs: ParenthesisWrapper(rhs),
35        }
36    }
37}
38
39impl<Combinator, Rule, Source, Rhs> Query for CombinationClause<Combinator, Rule, Source, Rhs>
40where
41    Source: Query,
42    Rhs: Query<SqlType = Source::SqlType>,
43{
44    type SqlType = Source::SqlType;
45}
46
47impl<Combinator, Rule, Source, Rhs> SelectQuery for CombinationClause<Combinator, Rule, Source, Rhs>
48where
49    Source: SelectQuery,
50    Rhs: SelectQuery<SqlType = Source::SqlType>,
51{
52    type SqlType = Source::SqlType;
53}
54
55impl<Combinator, Rule, Source, Rhs, QS> ValidSubselect<QS>
56    for CombinationClause<Combinator, Rule, Source, Rhs>
57where
58    Source: ValidSubselect<QS>,
59    Rhs: ValidSubselect<QS>,
60{
61}
62
63impl<Combinator, Rule, Source, Rhs, Conn> RunQueryDsl<Conn>
64    for CombinationClause<Combinator, Rule, Source, Rhs>
65{
66}
67
68impl<Combinator, Rule, Source, Rhs, T> Insertable<T>
69    for CombinationClause<Combinator, Rule, Source, Rhs>
70where
71    T: Table,
72    T::AllColumns: NonAggregate,
73    Self: Query,
74{
75    type Values = InsertFromSelect<Self, T::AllColumns>;
76
77    fn values(self) -> Self::Values {
78        InsertFromSelect::new(self)
79    }
80}
81
82impl<Combinator, Rule, Source, OriginRhs> CombineDsl
83    for CombinationClause<Combinator, Rule, Source, OriginRhs>
84where
85    Self: Query,
86{
87    type Query = Self;
88
89    fn union<Rhs>(self, rhs: Rhs) -> crate::dsl::Union<Self, Rhs>
90    where
91        Rhs: AsQuery<SqlType = <Self::Query as Query>::SqlType>,
92    {
93        CombinationClause::new(Union, Distinct, self, rhs.as_query())
94    }
95
96    fn union_all<Rhs>(self, rhs: Rhs) -> crate::dsl::UnionAll<Self, Rhs>
97    where
98        Rhs: AsQuery<SqlType = <Self::Query as Query>::SqlType>,
99    {
100        CombinationClause::new(Union, All, self, rhs.as_query())
101    }
102
103    fn intersect<Rhs>(self, rhs: Rhs) -> crate::dsl::Intersect<Self, Rhs>
104    where
105        Rhs: AsQuery<SqlType = <Self::Query as Query>::SqlType>,
106    {
107        CombinationClause::new(Intersect, Distinct, self, rhs.as_query())
108    }
109
110    fn intersect_all<Rhs>(self, rhs: Rhs) -> crate::dsl::IntersectAll<Self, Rhs>
111    where
112        Rhs: AsQuery<SqlType = <Self::Query as Query>::SqlType>,
113    {
114        CombinationClause::new(Intersect, All, self, rhs.as_query())
115    }
116
117    fn except<Rhs>(self, rhs: Rhs) -> crate::dsl::Except<Self, Rhs>
118    where
119        Rhs: AsQuery<SqlType = <Self::Query as Query>::SqlType>,
120    {
121        CombinationClause::new(Except, Distinct, self, rhs.as_query())
122    }
123
124    fn except_all<Rhs>(self, rhs: Rhs) -> crate::dsl::ExceptAll<Self, Rhs>
125    where
126        Rhs: AsQuery<SqlType = <Self::Query as Query>::SqlType>,
127    {
128        CombinationClause::new(Except, All, self, rhs.as_query())
129    }
130}
131
132impl<Combinator, Rule, Source, Rhs, DB: Backend> QueryFragment<DB>
133    for CombinationClause<Combinator, Rule, Source, Rhs>
134where
135    Combinator: QueryFragment<DB>,
136    Rule: QueryFragment<DB>,
137    ParenthesisWrapper<Source>: QueryFragment<DB>,
138    ParenthesisWrapper<Rhs>: QueryFragment<DB>,
139    DB: Backend + SupportsCombinationClause<Combinator, Rule> + DieselReserveSpecialization,
140{
141    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, DB>) -> QueryResult<()> {
142        self.source.walk_ast(out.reborrow())?;
143        self.combinator.walk_ast(out.reborrow())?;
144        self.duplicate_rule.walk_ast(out.reborrow())?;
145        self.rhs.walk_ast(out)
146    }
147}
148
149#[derive(Debug, Copy, Clone, QueryId)]
150/// Computes the set union of the rows returned by the involved `SELECT` statements using SQL `UNION`
151pub struct Union;
152
153impl<DB> QueryFragment<DB> for Union
154where
155    DB: Backend + DieselReserveSpecialization,
156{
157    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, DB>) -> QueryResult<()> {
158        out.push_sql(" UNION ");
159        Ok(())
160    }
161}
162
163#[derive(Debug, Copy, Clone, QueryId)]
164/// Computes the set intersection of the rows returned by the involved `SELECT` statements using SQL `INTERSECT`
165pub struct Intersect;
166
167impl<DB> QueryFragment<DB> for Intersect
168where
169    DB: Backend + DieselReserveSpecialization,
170{
171    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, DB>) -> QueryResult<()> {
172        out.push_sql(" INTERSECT ");
173        Ok(())
174    }
175}
176
177#[derive(Debug, Copy, Clone, QueryId)]
178/// Computes the set difference of the rows returned by the involved `SELECT` statements using SQL `EXCEPT`
179pub struct Except;
180
181impl<DB> QueryFragment<DB> for Except
182where
183    DB: Backend + DieselReserveSpecialization,
184{
185    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, DB>) -> QueryResult<()> {
186        out.push_sql(" EXCEPT ");
187        Ok(())
188    }
189}
190
191#[derive(Debug, Copy, Clone, QueryId)]
192/// Remove duplicate rows in the result, this is the default behavior of `UNION`, `INTERSECT` and `EXCEPT`
193pub struct Distinct;
194
195impl<DB> QueryFragment<DB> for Distinct
196where
197    DB: Backend + DieselReserveSpecialization,
198{
199    fn walk_ast<'b>(&'b self, _: AstPass<'_, 'b, DB>) -> QueryResult<()> {
200        Ok(())
201    }
202}
203
204#[derive(Debug, Copy, Clone, QueryId)]
205/// Keep duplicate rows in the result
206pub struct All;
207
208impl<DB> QueryFragment<DB> for All
209where
210    DB: Backend + DieselReserveSpecialization,
211{
212    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, DB>) -> QueryResult<()> {
213        out.push_sql("ALL ");
214        Ok(())
215    }
216}
217
218/// Marker trait used to indicate whenever a backend supports given combination
219pub trait SupportsCombinationClause<Combinator, Rule> {}
220
221#[derive(Debug, Copy, Clone, QueryId)]
222/// Wrapper used to wrap rhs sql in parenthesis when supported by backend
223pub struct ParenthesisWrapper<T>(T);
224
225#[cfg(feature = "postgres_backend")]
226mod postgres {
227    use super::*;
228    use crate::pg::Pg;
229
230    impl<T: QueryFragment<Pg>> QueryFragment<Pg> for ParenthesisWrapper<T> {
231        fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
232            out.push_sql("(");
233            self.0.walk_ast(out.reborrow())?;
234            out.push_sql(")");
235            Ok(())
236        }
237    }
238
239    impl SupportsCombinationClause<Union, Distinct> for Pg {}
240    impl SupportsCombinationClause<Union, All> for Pg {}
241    impl SupportsCombinationClause<Intersect, Distinct> for Pg {}
242    impl SupportsCombinationClause<Intersect, All> for Pg {}
243    impl SupportsCombinationClause<Except, Distinct> for Pg {}
244    impl SupportsCombinationClause<Except, All> for Pg {}
245}
246
247#[cfg(feature = "mysql_backend")]
248mod mysql {
249    use super::*;
250    use crate::mysql::Mysql;
251
252    impl<T: QueryFragment<Mysql>> QueryFragment<Mysql> for ParenthesisWrapper<T> {
253        fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Mysql>) -> QueryResult<()> {
254            out.push_sql("(");
255            self.0.walk_ast(out.reborrow())?;
256            out.push_sql(")");
257            Ok(())
258        }
259    }
260
261    impl SupportsCombinationClause<Union, Distinct> for Mysql {}
262    impl SupportsCombinationClause<Union, All> for Mysql {}
263}
264
265#[cfg(feature = "sqlite")]
266mod sqlite {
267    use super::*;
268    use crate::sqlite::Sqlite;
269
270    impl<T: QueryFragment<Sqlite>> QueryFragment<Sqlite> for ParenthesisWrapper<T> {
271        fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Sqlite>) -> QueryResult<()> {
272            // SQLite does not support parenthesis around this clause
273            // we can emulate this by construct a fake outer
274            // SELECT * FROM (inner_query) statement
275            out.push_sql("SELECT * FROM (");
276            self.0.walk_ast(out.reborrow())?;
277            out.push_sql(")");
278            Ok(())
279        }
280    }
281
282    impl SupportsCombinationClause<Union, Distinct> for Sqlite {}
283    impl SupportsCombinationClause<Union, All> for Sqlite {}
284    impl SupportsCombinationClause<Intersect, Distinct> for Sqlite {}
285    impl SupportsCombinationClause<Except, Distinct> for Sqlite {}
286}
diesel/query_builder/combination_clause.rs

diesel/query_builder/
combination_clause.rs
