Skip to main content

tank_core/writer/
sql_writer.rs

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
9/// SQL dialect printer for complete statements, combining [`SqlCoreWriter`],
10/// [`SqlValueWriter`], [`SqlExpressionWriter`], and [`SqlFragmentWriter`].
11pub trait SqlWriter:
12    SqlCoreWriter + SqlValueWriter + SqlExpressionWriter + SqlFragmentWriter
13{
14    /// Emit BEGIN statement.
15    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    /// Emit COMMIT statement.
25    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    /// Emit ROLLBACK statement.
35    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    /// Emit CREATE SCHEMA.
45    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    /// Emit DROP SCHEMA.
63    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    /// Emit CREATE TABLE with columns and constraints.
81    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    /// Write the `COMMENT ON COLUMN` statement of a single column.
164    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        // Exact length of `\nCOMMENT ON COLUMN "s"."t"."c" IS '...';` when nothing is escaped.
168        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    /// Write DROP TABLE statement.
185    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    /// Write SELECT statement.
204    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    /// Write INSERT statement printing rows of values or a SELECT.
293    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        // A SELECT without named columns fills all the table columns, rows always name theirs.
300        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    /// Write UPDATE statement.
362    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            // A SET target is a bare column name, never a qualified one.
384            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    /// Write DELETE statement.
406    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
429/// Generic SQL writer.
430pub struct GenericSqlWriter;
431impl GenericSqlWriter {
432    /// New generic writer.
433    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 {}