chain_builder/query/join/
join_methods.rs

1//! JOIN methods for building JOIN clauses
2
3use super::{JoinBuilder, JoinStatement};
4use crate::query::QueryBuilder;
5use serde_json::Value;
6
7/// Trait for JOIN operations
8pub trait JoinMethods {
9    /// Add a JOIN clause
10    fn join(&mut self, table: &str, on: impl FnOnce(&mut JoinBuilder));
11
12    /// Add an INNER JOIN clause
13    fn inner_join(&mut self, table: &str, on: impl FnOnce(&mut JoinBuilder));
14
15    /// Add a LEFT JOIN clause
16    fn left_join(&mut self, table: &str, on: impl FnOnce(&mut JoinBuilder));
17
18    /// Add a RIGHT JOIN clause
19    fn right_join(&mut self, table: &str, on: impl FnOnce(&mut JoinBuilder));
20
21    /// Add a LEFT OUTER JOIN clause
22    fn left_outer_join(&mut self, table: &str, on: impl FnOnce(&mut JoinBuilder));
23
24    /// Add a RIGHT OUTER JOIN clause
25    fn right_outer_join(&mut self, table: &str, on: impl FnOnce(&mut JoinBuilder));
26
27    /// Add a FULL OUTER JOIN clause
28    fn full_outer_join(&mut self, table: &str, on: impl FnOnce(&mut JoinBuilder));
29
30    /// Add a CROSS JOIN clause
31    fn cross_join(&mut self, table: &str, on: impl FnOnce(&mut JoinBuilder));
32
33    /// Add a JOIN USING clause
34    fn join_using(&mut self, table: &str, columns: Vec<String>);
35
36    /// Add a raw JOIN clause
37    fn raw_join(&mut self, raw: &str, val: Option<Vec<Value>>);
38}
39
40impl JoinMethods for QueryBuilder {
41    fn join(&mut self, table: &str, on: impl FnOnce(&mut JoinBuilder)) {
42        let mut join = JoinBuilder {
43            table: table.to_string(),
44            statement: vec![],
45            join_type: "JOIN".into(),
46            raw: None,
47            as_name: None,
48        };
49        on(&mut join);
50        self.join.push(join);
51    }
52
53    fn inner_join(&mut self, table: &str, on: impl FnOnce(&mut JoinBuilder)) {
54        let mut join = JoinBuilder {
55            table: table.to_string(),
56            statement: vec![],
57            join_type: "INNER JOIN".into(),
58            raw: None,
59            as_name: None,
60        };
61        on(&mut join);
62        self.join.push(join);
63    }
64
65    fn left_join(&mut self, table: &str, on: impl FnOnce(&mut JoinBuilder)) {
66        let mut join = JoinBuilder {
67            table: table.to_string(),
68            statement: vec![],
69            join_type: "LEFT JOIN".into(),
70            raw: None,
71            as_name: None,
72        };
73        on(&mut join);
74        self.join.push(join);
75    }
76
77    fn right_join(&mut self, table: &str, on: impl FnOnce(&mut JoinBuilder)) {
78        let mut join = JoinBuilder {
79            table: table.to_string(),
80            statement: vec![],
81            join_type: "RIGHT JOIN".into(),
82            raw: None,
83            as_name: None,
84        };
85        on(&mut join);
86        self.join.push(join);
87    }
88
89    fn left_outer_join(&mut self, table: &str, on: impl FnOnce(&mut JoinBuilder)) {
90        let mut join = JoinBuilder {
91            table: table.to_string(),
92            statement: vec![],
93            join_type: "LEFT OUTER JOIN".into(),
94            raw: None,
95            as_name: None,
96        };
97        on(&mut join);
98        self.join.push(join);
99    }
100
101    fn right_outer_join(&mut self, table: &str, on: impl FnOnce(&mut JoinBuilder)) {
102        let mut join = JoinBuilder {
103            table: table.to_string(),
104            statement: vec![],
105            join_type: "RIGHT OUTER JOIN".into(),
106            raw: None,
107            as_name: None,
108        };
109        on(&mut join);
110        self.join.push(join);
111    }
112
113    fn cross_join(&mut self, table: &str, on: impl FnOnce(&mut JoinBuilder)) {
114        let mut join = JoinBuilder {
115            table: table.to_string(),
116            statement: vec![],
117            join_type: "CROSS JOIN".into(),
118            raw: None,
119            as_name: None,
120        };
121        on(&mut join);
122        self.join.push(join);
123    }
124
125    fn full_outer_join(&mut self, table: &str, on: impl FnOnce(&mut JoinBuilder)) {
126        let mut join = JoinBuilder {
127            table: table.to_string(),
128            statement: vec![],
129            join_type: "FULL OUTER JOIN".into(),
130            raw: None,
131            as_name: None,
132        };
133        on(&mut join);
134        self.join.push(join);
135    }
136
137    fn join_using(&mut self, table: &str, columns: Vec<String>) {
138        let table = crate::dialect::escape_identifier(table, &self.client);
139        let columns_str = crate::dialect::escape_identifier_list(&columns, &self.client);
140        let sql = format!("JOIN {} USING ({})", table, columns_str);
141        self.raw_join(&sql, None);
142    }
143
144    fn raw_join(&mut self, raw: &str, val: Option<Vec<Value>>) {
145        self.join.push(JoinBuilder {
146            table: raw.to_string(),
147            statement: vec![],
148            join_type: "".into(),
149            raw: Some((raw.to_string(), val)),
150            as_name: None,
151        });
152    }
153}
154
155impl JoinBuilder {
156    /// Set table alias
157    pub fn as_name(&mut self, name: &str) -> &mut Self {
158        self.as_name = Some(name.to_string());
159        self
160    }
161
162    /// Add ON condition with column comparison
163    pub fn on(&mut self, column: &str, operator: &str, column2: &str) -> &mut Self {
164        self.statement.push(JoinStatement::On(
165            column.to_string(),
166            operator.to_string(),
167            column2.to_string(),
168        ));
169        self
170    }
171
172    /// Start an OR chain for complex JOIN conditions
173    pub fn or(&mut self) -> &mut JoinBuilder {
174        let mut chain = self.clone();
175        chain.statement = vec![];
176        self.statement.push(JoinStatement::OrChain(Box::new(chain)));
177        // SAFETY: unwrap() is safe because we just pushed an OrChain
178        self.statement.last_mut().unwrap().as_mut_join_builder()
179    }
180
181    /// Add ON condition with value comparison
182    pub fn on_val(&mut self, column: &str, operator: &str, value: Value) -> &mut Self {
183        self.statement.push(JoinStatement::OnVal(
184            column.to_string(),
185            operator.to_string(),
186            value,
187        ));
188        self
189    }
190
191    /// Add raw ON condition
192    pub fn on_raw(&mut self, raw: &str, val: Option<Vec<Value>>) -> &mut Self {
193        self.statement
194            .push(JoinStatement::OnRaw(raw.to_string(), val));
195        self
196    }
197}
chain_builder/query/join/join_methods.rs

chain_builder/query/join/
join_methods.rs
