1use crate::{
2 AnyQuery, ColumnDef, Dataset, Expression, Fragment, InsertIntoQuery, IsTrue, SelectQuery,
3 TableRef, UpdateQuery,
4 future::Either,
5 separated_by,
6 writer::{Context, SqlCoreWriter, SqlExpressionWriter, SqlFragmentWriter, SqlValueWriter},
7};
8
9pub trait SqlWriter:
12 SqlCoreWriter + SqlValueWriter + SqlExpressionWriter + SqlFragmentWriter
13{
14 fn write_transaction_begin(&self, out: &mut AnyQuery) {
16 const SQL: &str = "BEGIN;";
17 out.buffer().reserve(SQL.len() + 1);
18 if !out.is_empty() {
19 out.push('\n');
20 }
21 out.push_str(SQL);
22 }
23
24 fn write_transaction_commit(&self, out: &mut AnyQuery) {
26 const SQL: &str = "COMMIT;";
27 out.buffer().reserve(SQL.len() + 1);
28 if !out.is_empty() {
29 out.push('\n');
30 }
31 out.push_str(SQL);
32 }
33
34 fn write_transaction_rollback(&self, out: &mut AnyQuery) {
36 const SQL: &str = "ROLLBACK;";
37 out.buffer().reserve(SQL.len() + 1);
38 if !out.is_empty() {
39 out.push('\n');
40 }
41 out.push_str(SQL);
42 }
43
44 fn write_create_schema(&self, out: &mut AnyQuery, table: &TableRef, if_not_exists: bool)
46 where
47 Self: Sized,
48 {
49 out.buffer().reserve(32 + table.schema.len());
50 if !out.is_empty() {
51 out.push('\n');
52 }
53 out.push_str("CREATE SCHEMA ");
54 let mut context = Context::new(Fragment::SqlCreateSchema, table.qualified_columns());
55 if if_not_exists {
56 out.push_str("IF NOT EXISTS ");
57 }
58 self.write_identifier(&mut context, out, &table.schema, true);
59 out.push(';');
60 }
61
62 fn write_drop_schema(&self, out: &mut AnyQuery, table: &TableRef, if_exists: bool)
64 where
65 Self: Sized,
66 {
67 let mut context = Context::new(Fragment::SqlDropSchema, table.qualified_columns());
68 out.buffer().reserve(32 + table.schema.len());
69 if !out.is_empty() {
70 out.push('\n');
71 }
72 out.push_str("DROP SCHEMA ");
73 if if_exists {
74 out.push_str("IF EXISTS ");
75 }
76 self.write_identifier(&mut context, out, &table.schema, true);
77 out.push(';');
78 }
79
80 fn write_create_table(&self, out: &mut AnyQuery, table: &TableRef, if_not_exists: bool)
82 where
83 Self: Sized,
84 {
85 let mut context = Context::new(Fragment::SqlCreateTable, table.qualified_columns());
86 let estimated = 128 + table.columns.len() * 64 + table.primary_key.len() * 24;
87 out.buffer().reserve(estimated);
88 if !out.is_empty() {
89 out.push('\n');
90 }
91 out.push_str("CREATE TABLE ");
92 if if_not_exists {
93 out.push_str("IF NOT EXISTS ");
94 }
95 self.write_table_ref(&mut context, out, table);
96 out.push_str(" (\n");
97 separated_by(
98 out,
99 table.columns.iter(),
100 |out, col| {
101 self.write_create_table_column_fragment(&mut context, out, col);
102 },
103 ",\n",
104 );
105 if table.primary_key.len() > 1 {
106 self.write_create_table_primary_key_fragment(&mut context, out, table.primary_key());
107 }
108 for unique in table.unique() {
109 let mut unique = unique.peekable();
110 if unique.peek().is_some() {
111 out.push_str(",\nUNIQUE (");
112 separated_by(
113 out,
114 unique,
115 |out, col| {
116 self.write_identifier(
117 &mut context
118 .switch_fragment(Fragment::SqlCreateTableUnique)
119 .current,
120 out,
121 col.name(),
122 true,
123 );
124 },
125 ", ",
126 );
127 out.push(')');
128 }
129 }
130 let foreign_keys = table.columns.iter().filter(|c| c.references.is_some());
131 separated_by(
132 out,
133 foreign_keys,
134 |out, column| {
135 let Some(references) = column.references.as_ref() else {
136 log::error!(
137 "Column `{}` was filtered as a foreign key but has no references",
138 column.name()
139 );
140 return;
141 };
142 out.push_str(",\nFOREIGN KEY (");
143 self.write_identifier(&mut context, out, &column.name(), true);
144 out.push_str(") REFERENCES ");
145 self.write_table_ref(&mut context, out, &references.table());
146 out.push('(');
147 self.write_column_ref(&mut context, out, references);
148 out.push(')');
149 if let Some(on_delete) = &column.on_delete {
150 out.push_str(" ON DELETE ");
151 self.write_create_table_references_action(&mut context, out, on_delete);
152 }
153 if let Some(on_update) = &column.on_update {
154 out.push_str(" ON UPDATE ");
155 self.write_create_table_references_action(&mut context, out, on_update);
156 }
157 },
158 "",
159 );
160 out.push_str(");");
161 }
162
163 fn write_column_comment(&self, context: &mut Context, out: &mut AnyQuery, column: &ColumnDef) {
165 let mut context = context.switch_fragment(Fragment::SqlCommentOnColumn);
166 context.current.qualify_columns = true;
167 out.buffer().reserve(
169 34 + column.schema().len()
170 + column.table().len()
171 + column.name().len()
172 + column.comment.len(),
173 );
174 if !out.is_empty() {
175 out.push('\n');
176 }
177 out.push_str("COMMENT ON COLUMN ");
178 self.write_column_ref(&mut context.current, out, column.into());
179 out.push_str(" IS ");
180 self.write_string(&mut context.current, out, column.comment);
181 out.push(';');
182 }
183
184 fn write_drop_table(&self, out: &mut AnyQuery, table: &TableRef, if_exists: bool)
186 where
187 Self: Sized,
188 {
189 out.buffer()
190 .reserve(32 + table.schema.len() + table.name.len());
191 if !out.is_empty() {
192 out.push('\n');
193 }
194 out.push_str("DROP TABLE ");
195 let mut context = Context::new(Fragment::SqlDropTable, table.qualified_columns());
196 if if_exists {
197 out.push_str("IF EXISTS ");
198 }
199 self.write_table_ref(&mut context, out, table);
200 out.push(';');
201 }
202
203 fn write_select<'a, Data>(&self, out: &mut AnyQuery, query: impl SelectQuery<Data>)
205 where
206 Self: Sized,
207 Data: Dataset + 'a,
208 {
209 let columns = query.get_select();
210 let columns_count = columns.clone().into_iter().count();
211 out.buffer().reserve(256 + columns_count * 32);
212 if !out.is_empty() {
213 out.push('\n');
214 }
215 out.push_str("SELECT ");
216 if query.is_distinct() {
217 out.push_str("DISTINCT ");
218 }
219 let qualified = query
220 .get_from()
221 .as_ref()
222 .is_some_and(Dataset::qualified_columns);
223 let mut context = Context::new(Fragment::SqlSelect, qualified);
224 if columns_count != 0 {
225 separated_by(
226 out,
227 columns.clone(),
228 |out, col| {
229 col.write_query(self, &mut context, out);
230 },
231 ", ",
232 );
233 } else {
234 out.push('*');
235 }
236 if let Some(from) = query.get_from() {
237 out.push_str("\nFROM ");
238 from.write_table_name(
239 self,
240 &mut context.switch_fragment(Fragment::SqlSelectFrom).current,
241 out,
242 );
243 }
244 if let Some(condition) = query.get_where()
245 && !condition.accept_visitor(&mut IsTrue, self, &mut context, out)
246 {
247 out.push_str("\nWHERE ");
248 condition.write_query(
249 self,
250 &mut context.switch_fragment(Fragment::SqlSelectWhere).current,
251 out,
252 );
253 }
254 let mut group_by = query.get_group_by().peekable();
255 if group_by.peek().is_some() {
256 out.push_str("\nGROUP BY ");
257 let mut context = context.switch_fragment(Fragment::SqlSelectGroupBy);
258 separated_by(
259 out,
260 group_by,
261 |out, col| {
262 col.write_query(self, &mut context.current, out);
263 },
264 ", ",
265 );
266 }
267 if let Some(having) = query.get_having() {
268 out.push_str("\nHAVING ");
269 having.write_query(
270 self,
271 &mut context.switch_fragment(Fragment::SqlSelectHaving).current,
272 out,
273 );
274 }
275 let mut order_by = query.get_order_by().peekable();
276 if order_by.peek().is_some() {
277 out.push_str("\nORDER BY ");
278 let mut context = context.switch_fragment(Fragment::SqlSelectOrderBy);
279 separated_by(
280 out,
281 order_by,
282 |out, col| {
283 col.write_query(self, &mut context.current, out);
284 },
285 ", ",
286 );
287 }
288 self.write_limit_offset(&mut context, out, query.get_limit(), query.get_offset());
289 out.push(';');
290 }
291
292 fn write_insert(&self, out: &mut AnyQuery, query: impl InsertIntoQuery)
294 where
295 Self: Sized,
296 {
297 let table = query.get_table();
298 let columns = query.get_columns();
299 let write_head = |out: &mut AnyQuery, context: &mut Context, all: bool| {
301 if !out.is_empty() {
302 out.push('\n');
303 }
304 out.push_str("INSERT INTO ");
305 self.write_table_ref(context, out, table);
306 if !all || !columns.is_empty() {
307 out.push_str(" (");
308 separated_by(
309 out,
310 columns,
311 |out, column| self.write_identifier(context, out, column.name(), true),
312 ", ",
313 );
314 out.push(')');
315 }
316 };
317 let mut context = Context::new(Fragment::SqlInsertInto, table.qualified_columns());
318 let rows = match query.get_values() {
319 Either::Left(rows) => rows,
320 Either::Right(select) => {
321 out.buffer().reserve(32 + columns.len() * 32);
322 write_head(out, &mut context, true);
323 return self.write_select(out, select);
324 }
325 };
326 let mut rows = rows.peekable();
327 if rows.peek().is_none() {
328 return;
329 }
330 out.buffer()
331 .reserve(128 + columns.len() * (32 + rows.size_hint().0 * 16));
332 write_head(out, &mut context, false);
333 out.push_str(" VALUES");
334 let mut context = context.switch_fragment(Fragment::SqlInsertIntoValues);
335 separated_by(
336 out,
337 rows,
338 |out, row| {
339 out.push_str("\n(");
340 separated_by(
341 out,
342 row,
343 |out, cell| cell.write_query(self.as_dyn(), &mut context.current, out),
344 ", ",
345 );
346 out.push(')');
347 },
348 ",",
349 );
350 if query.get_update() {
351 self.write_insert_update_fragment(
352 &mut context.current,
353 out,
354 table.primary_key(),
355 columns.iter(),
356 );
357 }
358 out.push(';');
359 }
360
361 fn write_update<Data>(&self, out: &mut AnyQuery, query: impl UpdateQuery<Data>)
363 where
364 Self: Sized,
365 Data: Dataset,
366 {
367 let table = query.get_from();
368 let assignments = query.get_set();
369 let assignments_count = assignments.clone().count();
370 if assignments_count == 0 {
371 return;
372 }
373 out.buffer().reserve(128 + assignments_count * 32);
374 if !out.is_empty() {
375 out.push('\n');
376 }
377 out.push_str("UPDATE ");
378 let mut context = Context::new(Fragment::SqlUpdate, table.qualified_columns());
379 table.write_table_name(self, &mut context, out);
380 out.push_str("\nSET ");
381 {
382 let mut set = context.switch_fragment(Fragment::SqlUpdateSet);
383 set.current.qualify_columns = false;
385 separated_by(
386 out,
387 assignments,
388 |out, assignment| assignment.write_query(self, &mut set.current, out),
389 ",\n",
390 );
391 }
392 if let Some(condition) = query.get_where()
393 && !condition.accept_visitor(&mut IsTrue, self, &mut context, out)
394 {
395 out.push_str("\nWHERE ");
396 condition.write_query(
397 self,
398 &mut context.switch_fragment(Fragment::SqlUpdateWhere).current,
399 out,
400 );
401 }
402 out.push(';');
403 }
404
405 fn write_delete(&self, out: &mut AnyQuery, from: &dyn Dataset, condition: impl Expression)
407 where
408 Self: Sized,
409 {
410 out.buffer().reserve(128);
411 if !out.is_empty() {
412 out.push('\n');
413 }
414 out.push_str("DELETE FROM ");
415 let mut context = Context::new(Fragment::SqlDeleteFrom, from.qualified_columns());
416 from.write_table_name(self, &mut context, out);
417 out.push_str("\nWHERE ");
418 condition.write_query(
419 self,
420 &mut context
421 .switch_fragment(Fragment::SqlDeleteFromWhere)
422 .current,
423 out,
424 );
425 out.push(';');
426 }
427}
428
429pub struct GenericSqlWriter;
431impl GenericSqlWriter {
432 pub const fn new() -> Self {
434 Self {}
435 }
436}
437impl SqlCoreWriter for GenericSqlWriter {
438 fn as_dyn(&self) -> &dyn SqlWriter {
439 self
440 }
441}
442impl SqlValueWriter for GenericSqlWriter {}
443impl SqlExpressionWriter for GenericSqlWriter {}
444impl SqlFragmentWriter for GenericSqlWriter {}
445impl SqlWriter for GenericSqlWriter {}