limbo_sqlite3_parser/parser/ast/
fmt.rs

1//! AST node format
2use std::fmt::{self, Display, Formatter, Write};
3
4use crate::ast::*;
5use crate::dialect::TokenType::*;
6
7struct FmtTokenStream<'a, 'b> {
8    f: &'a mut Formatter<'b>,
9    spaced: bool,
10}
11
12impl TokenStream for FmtTokenStream<'_, '_> {
13    type Error = fmt::Error;
14
15    fn append(&mut self, ty: TokenType, value: Option<&str>) -> fmt::Result {
16        if !self.spaced {
17            match ty {
18                TK_COMMA | TK_SEMI | TK_RP | TK_DOT => {}
19                _ => {
20                    self.f.write_char(' ')?;
21                    self.spaced = true;
22                }
23            };
24        }
25        if ty == TK_BLOB {
26            self.f.write_char('X')?;
27            self.f.write_char('\'')?;
28            if let Some(str) = value {
29                self.f.write_str(str)?;
30            }
31            return self.f.write_char('\'');
32        } else if let Some(str) = ty.as_str() {
33            self.f.write_str(str)?;
34            self.spaced = ty == TK_LP || ty == TK_DOT; // str should not be whitespace
35        }
36        if let Some(str) = value {
37            // trick for pretty-print
38            self.spaced = str.bytes().all(|b| b.is_ascii_whitespace());
39            /*if !self.spaced {
40                self.f.write_char(' ')?;
41            }*/
42            self.f.write_str(str)
43        } else {
44            Ok(())
45        }
46    }
47}
48
49struct WriteTokenStream<'a, T: fmt::Write> {
50    write: &'a mut T,
51    spaced: bool,
52}
53
54impl<T: fmt::Write> TokenStream for WriteTokenStream<'_, T> {
55    type Error = fmt::Error;
56
57    fn append(&mut self, ty: TokenType, value: Option<&str>) -> fmt::Result {
58        if !self.spaced {
59            match ty {
60                TK_COMMA | TK_SEMI | TK_RP | TK_DOT => {}
61                _ => {
62                    self.write.write_char(' ')?;
63                    self.spaced = true;
64                }
65            };
66        }
67        if ty == TK_BLOB {
68            self.write.write_char('X')?;
69            self.write.write_char('\'')?;
70            if let Some(str) = value {
71                self.write.write_str(str)?;
72            }
73            return self.write.write_char('\'');
74        } else if let Some(str) = ty.as_str() {
75            self.write.write_str(str)?;
76            self.spaced = ty == TK_LP || ty == TK_DOT; // str should not be whitespace
77        }
78        if let Some(str) = value {
79            // trick for pretty-print
80            self.spaced = str.bytes().all(|b| b.is_ascii_whitespace());
81            self.write.write_str(str)
82        } else {
83            Ok(())
84        }
85    }
86}
87
88/// Stream of token
89pub trait TokenStream {
90    /// Potential error raised
91    type Error;
92    /// Push token to this stream
93    fn append(&mut self, ty: TokenType, value: Option<&str>) -> Result<(), Self::Error>;
94}
95
96/// Generate token(s) from AST node
97pub trait ToTokens {
98    /// Send token(s) to the specified stream
99    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error>;
100    /// Format AST node
101    fn to_fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
102        let mut s = FmtTokenStream { f, spaced: true };
103        self.to_tokens(&mut s)
104    }
105    /// Format AST node to string
106    fn format(&self) -> Result<String, fmt::Error> {
107        let mut s = String::new();
108
109        let mut w = WriteTokenStream {
110            write: &mut s,
111            spaced: true,
112        };
113
114        self.to_tokens(&mut w)?;
115
116        Ok(s)
117    }
118}
119
120impl<T: ?Sized + ToTokens> ToTokens for &T {
121    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
122        ToTokens::to_tokens(&**self, s)
123    }
124}
125
126impl ToTokens for String {
127    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
128        s.append(TK_ANY, Some(self.as_ref()))
129    }
130}
131
132impl ToTokens for Cmd {
133    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
134        match self {
135            Self::Explain(stmt) => {
136                s.append(TK_EXPLAIN, None)?;
137                stmt.to_tokens(s)?;
138            }
139            Self::ExplainQueryPlan(stmt) => {
140                s.append(TK_EXPLAIN, None)?;
141                s.append(TK_QUERY, None)?;
142                s.append(TK_PLAN, None)?;
143                stmt.to_tokens(s)?;
144            }
145            Self::Stmt(stmt) => {
146                stmt.to_tokens(s)?;
147            }
148        }
149        s.append(TK_SEMI, None)
150    }
151}
152
153impl Display for Cmd {
154    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
155        self.to_fmt(f)
156    }
157}
158
159impl ToTokens for Stmt {
160    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
161        match self {
162            Self::AlterTable(alter_table) => {
163                let (tbl_name, body) = &**alter_table;
164                s.append(TK_ALTER, None)?;
165                s.append(TK_TABLE, None)?;
166                tbl_name.to_tokens(s)?;
167                body.to_tokens(s)
168            }
169            Self::Analyze(obj_name) => {
170                s.append(TK_ANALYZE, None)?;
171                if let Some(obj_name) = obj_name {
172                    obj_name.to_tokens(s)?;
173                }
174                Ok(())
175            }
176            Self::Attach { expr, db_name, key } => {
177                s.append(TK_ATTACH, None)?;
178                expr.to_tokens(s)?;
179                s.append(TK_AS, None)?;
180                db_name.to_tokens(s)?;
181                if let Some(key) = key {
182                    s.append(TK_KEY, None)?;
183                    key.to_tokens(s)?;
184                }
185                Ok(())
186            }
187            Self::Begin(tx_type, tx_name) => {
188                s.append(TK_BEGIN, None)?;
189                if let Some(tx_type) = tx_type {
190                    tx_type.to_tokens(s)?;
191                }
192                if let Some(tx_name) = tx_name {
193                    s.append(TK_TRANSACTION, None)?;
194                    tx_name.to_tokens(s)?;
195                }
196                Ok(())
197            }
198            Self::Commit(tx_name) => {
199                s.append(TK_COMMIT, None)?;
200                if let Some(tx_name) = tx_name {
201                    s.append(TK_TRANSACTION, None)?;
202                    tx_name.to_tokens(s)?;
203                }
204                Ok(())
205            }
206            Self::CreateIndex {
207                unique,
208                if_not_exists,
209                idx_name,
210                tbl_name,
211                columns,
212                where_clause,
213            } => {
214                s.append(TK_CREATE, None)?;
215                if *unique {
216                    s.append(TK_UNIQUE, None)?;
217                }
218                s.append(TK_INDEX, None)?;
219                if *if_not_exists {
220                    s.append(TK_IF, None)?;
221                    s.append(TK_NOT, None)?;
222                    s.append(TK_EXISTS, None)?;
223                }
224                idx_name.to_tokens(s)?;
225                s.append(TK_ON, None)?;
226                tbl_name.to_tokens(s)?;
227                s.append(TK_LP, None)?;
228                comma(columns, s)?;
229                s.append(TK_RP, None)?;
230                if let Some(where_clause) = where_clause {
231                    s.append(TK_WHERE, None)?;
232                    where_clause.to_tokens(s)?;
233                }
234                Ok(())
235            }
236            Self::CreateTable {
237                temporary,
238                if_not_exists,
239                tbl_name,
240                body,
241            } => {
242                s.append(TK_CREATE, None)?;
243                if *temporary {
244                    s.append(TK_TEMP, None)?;
245                }
246                s.append(TK_TABLE, None)?;
247                if *if_not_exists {
248                    s.append(TK_IF, None)?;
249                    s.append(TK_NOT, None)?;
250                    s.append(TK_EXISTS, None)?;
251                }
252                tbl_name.to_tokens(s)?;
253                body.to_tokens(s)
254            }
255            Self::CreateTrigger(trigger) => {
256                let CreateTrigger {
257                    temporary,
258                    if_not_exists,
259                    trigger_name,
260                    time,
261                    event,
262                    tbl_name,
263                    for_each_row,
264                    when_clause,
265                    commands,
266                } = &**trigger;
267                s.append(TK_CREATE, None)?;
268                if *temporary {
269                    s.append(TK_TEMP, None)?;
270                }
271                s.append(TK_TRIGGER, None)?;
272                if *if_not_exists {
273                    s.append(TK_IF, None)?;
274                    s.append(TK_NOT, None)?;
275                    s.append(TK_EXISTS, None)?;
276                }
277                trigger_name.to_tokens(s)?;
278                if let Some(time) = time {
279                    time.to_tokens(s)?;
280                }
281                event.to_tokens(s)?;
282                s.append(TK_ON, None)?;
283                tbl_name.to_tokens(s)?;
284                if *for_each_row {
285                    s.append(TK_FOR, None)?;
286                    s.append(TK_EACH, None)?;
287                    s.append(TK_ROW, None)?;
288                }
289                if let Some(when_clause) = when_clause {
290                    s.append(TK_WHEN, None)?;
291                    when_clause.to_tokens(s)?;
292                }
293                s.append(TK_BEGIN, Some("\n"))?;
294                for command in commands {
295                    command.to_tokens(s)?;
296                    s.append(TK_SEMI, Some("\n"))?;
297                }
298                s.append(TK_END, None)
299            }
300            Self::CreateView {
301                temporary,
302                if_not_exists,
303                view_name,
304                columns,
305                select,
306            } => {
307                s.append(TK_CREATE, None)?;
308                if *temporary {
309                    s.append(TK_TEMP, None)?;
310                }
311                s.append(TK_VIEW, None)?;
312                if *if_not_exists {
313                    s.append(TK_IF, None)?;
314                    s.append(TK_NOT, None)?;
315                    s.append(TK_EXISTS, None)?;
316                }
317                view_name.to_tokens(s)?;
318                if let Some(columns) = columns {
319                    s.append(TK_LP, None)?;
320                    comma(columns, s)?;
321                    s.append(TK_RP, None)?;
322                }
323                s.append(TK_AS, None)?;
324                select.to_tokens(s)
325            }
326            Self::CreateVirtualTable(create_virtual_table) => {
327                let CreateVirtualTable {
328                    if_not_exists,
329                    tbl_name,
330                    module_name,
331                    args,
332                } = &**create_virtual_table;
333                s.append(TK_CREATE, None)?;
334                s.append(TK_VIRTUAL, None)?;
335                s.append(TK_TABLE, None)?;
336                if *if_not_exists {
337                    s.append(TK_IF, None)?;
338                    s.append(TK_NOT, None)?;
339                    s.append(TK_EXISTS, None)?;
340                }
341                tbl_name.to_tokens(s)?;
342                s.append(TK_USING, None)?;
343                module_name.to_tokens(s)?;
344                s.append(TK_LP, None)?;
345                if let Some(args) = args {
346                    comma(args, s)?;
347                }
348                s.append(TK_RP, None)
349            }
350            Self::Delete(delete) => {
351                let Delete {
352                    with,
353                    tbl_name,
354                    indexed,
355                    where_clause,
356                    returning,
357                    order_by,
358                    limit,
359                } = &**delete;
360                if let Some(with) = with {
361                    with.to_tokens(s)?;
362                }
363                s.append(TK_DELETE, None)?;
364                s.append(TK_FROM, None)?;
365                tbl_name.to_tokens(s)?;
366                if let Some(indexed) = indexed {
367                    indexed.to_tokens(s)?;
368                }
369                if let Some(where_clause) = where_clause {
370                    s.append(TK_WHERE, None)?;
371                    where_clause.to_tokens(s)?;
372                }
373                if let Some(returning) = returning {
374                    s.append(TK_RETURNING, None)?;
375                    comma(returning, s)?;
376                }
377                if let Some(order_by) = order_by {
378                    s.append(TK_ORDER, None)?;
379                    s.append(TK_BY, None)?;
380                    comma(order_by, s)?;
381                }
382                if let Some(limit) = limit {
383                    limit.to_tokens(s)?;
384                }
385                Ok(())
386            }
387            Self::Detach(expr) => {
388                s.append(TK_DETACH, None)?;
389                expr.to_tokens(s)
390            }
391            Self::DropIndex {
392                if_exists,
393                idx_name,
394            } => {
395                s.append(TK_DROP, None)?;
396                s.append(TK_INDEX, None)?;
397                if *if_exists {
398                    s.append(TK_IF, None)?;
399                    s.append(TK_EXISTS, None)?;
400                }
401                idx_name.to_tokens(s)
402            }
403            Self::DropTable {
404                if_exists,
405                tbl_name,
406            } => {
407                s.append(TK_DROP, None)?;
408                s.append(TK_TABLE, None)?;
409                if *if_exists {
410                    s.append(TK_IF, None)?;
411                    s.append(TK_EXISTS, None)?;
412                }
413                tbl_name.to_tokens(s)
414            }
415            Self::DropTrigger {
416                if_exists,
417                trigger_name,
418            } => {
419                s.append(TK_DROP, None)?;
420                s.append(TK_TRIGGER, None)?;
421                if *if_exists {
422                    s.append(TK_IF, None)?;
423                    s.append(TK_EXISTS, None)?;
424                }
425                trigger_name.to_tokens(s)
426            }
427            Self::DropView {
428                if_exists,
429                view_name,
430            } => {
431                s.append(TK_DROP, None)?;
432                s.append(TK_VIEW, None)?;
433                if *if_exists {
434                    s.append(TK_IF, None)?;
435                    s.append(TK_EXISTS, None)?;
436                }
437                view_name.to_tokens(s)
438            }
439            Self::Insert(insert) => {
440                let Insert {
441                    with,
442                    or_conflict,
443                    tbl_name,
444                    columns,
445                    body,
446                    returning,
447                } = &**insert;
448                if let Some(with) = with {
449                    with.to_tokens(s)?;
450                }
451                if let Some(ResolveType::Replace) = or_conflict {
452                    s.append(TK_REPLACE, None)?;
453                } else {
454                    s.append(TK_INSERT, None)?;
455                    if let Some(or_conflict) = or_conflict {
456                        s.append(TK_OR, None)?;
457                        or_conflict.to_tokens(s)?;
458                    }
459                }
460                s.append(TK_INTO, None)?;
461                tbl_name.to_tokens(s)?;
462                if let Some(columns) = columns {
463                    s.append(TK_LP, None)?;
464                    comma(columns.deref(), s)?;
465                    s.append(TK_RP, None)?;
466                }
467                body.to_tokens(s)?;
468                if let Some(returning) = returning {
469                    s.append(TK_RETURNING, None)?;
470                    comma(returning, s)?;
471                }
472                Ok(())
473            }
474            Self::Pragma(name, value) => {
475                s.append(TK_PRAGMA, None)?;
476                name.to_tokens(s)?;
477                if let Some(value) = value {
478                    value.to_tokens(s)?;
479                }
480                Ok(())
481            }
482            Self::Reindex { obj_name } => {
483                s.append(TK_REINDEX, None)?;
484                if let Some(obj_name) = obj_name {
485                    obj_name.to_tokens(s)?;
486                }
487                Ok(())
488            }
489            Self::Release(name) => {
490                s.append(TK_RELEASE, None)?;
491                name.to_tokens(s)
492            }
493            Self::Rollback {
494                tx_name,
495                savepoint_name,
496            } => {
497                s.append(TK_ROLLBACK, None)?;
498                if let Some(tx_name) = tx_name {
499                    s.append(TK_TRANSACTION, None)?;
500                    tx_name.to_tokens(s)?;
501                }
502                if let Some(savepoint_name) = savepoint_name {
503                    s.append(TK_TO, None)?;
504                    savepoint_name.to_tokens(s)?;
505                }
506                Ok(())
507            }
508            Self::Savepoint(name) => {
509                s.append(TK_SAVEPOINT, None)?;
510                name.to_tokens(s)
511            }
512            Self::Select(select) => select.to_tokens(s),
513            Self::Update(update) => {
514                let Update {
515                    with,
516                    or_conflict,
517                    tbl_name,
518                    indexed,
519                    sets,
520                    from,
521                    where_clause,
522                    returning,
523                    order_by,
524                    limit,
525                } = &**update;
526                if let Some(with) = with {
527                    with.to_tokens(s)?;
528                }
529                s.append(TK_UPDATE, None)?;
530                if let Some(or_conflict) = or_conflict {
531                    s.append(TK_OR, None)?;
532                    or_conflict.to_tokens(s)?;
533                }
534                tbl_name.to_tokens(s)?;
535                if let Some(indexed) = indexed {
536                    indexed.to_tokens(s)?;
537                }
538                s.append(TK_SET, None)?;
539                comma(sets, s)?;
540                if let Some(from) = from {
541                    s.append(TK_FROM, None)?;
542                    from.to_tokens(s)?;
543                }
544                if let Some(where_clause) = where_clause {
545                    s.append(TK_WHERE, None)?;
546                    where_clause.to_tokens(s)?;
547                }
548                if let Some(returning) = returning {
549                    s.append(TK_RETURNING, None)?;
550                    comma(returning, s)?;
551                }
552                if let Some(order_by) = order_by {
553                    s.append(TK_ORDER, None)?;
554                    s.append(TK_BY, None)?;
555                    comma(order_by, s)?;
556                }
557                if let Some(limit) = limit {
558                    limit.to_tokens(s)?;
559                }
560                Ok(())
561            }
562            Self::Vacuum(name, expr) => {
563                s.append(TK_VACUUM, None)?;
564                if let Some(ref name) = name {
565                    name.to_tokens(s)?;
566                }
567                if let Some(ref expr) = expr {
568                    s.append(TK_INTO, None)?;
569                    expr.to_tokens(s)?;
570                }
571                Ok(())
572            }
573        }
574    }
575}
576
577impl ToTokens for Expr {
578    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
579        match self {
580            Self::Between {
581                lhs,
582                not,
583                start,
584                end,
585            } => {
586                lhs.to_tokens(s)?;
587                if *not {
588                    s.append(TK_NOT, None)?;
589                }
590                s.append(TK_BETWEEN, None)?;
591                start.to_tokens(s)?;
592                s.append(TK_AND, None)?;
593                end.to_tokens(s)
594            }
595            Self::Binary(lhs, op, rhs) => {
596                lhs.to_tokens(s)?;
597                op.to_tokens(s)?;
598                rhs.to_tokens(s)
599            }
600            Self::Case {
601                base,
602                when_then_pairs,
603                else_expr,
604            } => {
605                s.append(TK_CASE, None)?;
606                if let Some(ref base) = base {
607                    base.to_tokens(s)?;
608                }
609                for (when, then) in when_then_pairs {
610                    s.append(TK_WHEN, None)?;
611                    when.to_tokens(s)?;
612                    s.append(TK_THEN, None)?;
613                    then.to_tokens(s)?;
614                }
615                if let Some(ref else_expr) = else_expr {
616                    s.append(TK_ELSE, None)?;
617                    else_expr.to_tokens(s)?;
618                }
619                s.append(TK_END, None)
620            }
621            Self::Cast { expr, type_name } => {
622                s.append(TK_CAST, None)?;
623                s.append(TK_LP, None)?;
624                expr.to_tokens(s)?;
625                s.append(TK_AS, None)?;
626                if let Some(ref type_name) = type_name {
627                    type_name.to_tokens(s)?;
628                }
629                s.append(TK_RP, None)
630            }
631            Self::Collate(expr, collation) => {
632                expr.to_tokens(s)?;
633                s.append(TK_COLLATE, None)?;
634                double_quote(collation, s)
635            }
636            Self::DoublyQualified(db_name, tbl_name, col_name) => {
637                db_name.to_tokens(s)?;
638                s.append(TK_DOT, None)?;
639                tbl_name.to_tokens(s)?;
640                s.append(TK_DOT, None)?;
641                col_name.to_tokens(s)
642            }
643            Self::Exists(subquery) => {
644                s.append(TK_EXISTS, None)?;
645                s.append(TK_LP, None)?;
646                subquery.to_tokens(s)?;
647                s.append(TK_RP, None)
648            }
649            Self::FunctionCall {
650                name,
651                distinctness,
652                args,
653                order_by,
654                filter_over,
655            } => {
656                name.to_tokens(s)?;
657                s.append(TK_LP, None)?;
658                if let Some(distinctness) = distinctness {
659                    distinctness.to_tokens(s)?;
660                }
661                if let Some(args) = args {
662                    comma(args, s)?;
663                }
664                if let Some(order_by) = order_by {
665                    s.append(TK_ORDER, None)?;
666                    s.append(TK_BY, None)?;
667                    comma(order_by, s)?;
668                }
669                s.append(TK_RP, None)?;
670                if let Some(filter_over) = filter_over {
671                    filter_over.to_tokens(s)?;
672                }
673                Ok(())
674            }
675            Self::FunctionCallStar { name, filter_over } => {
676                name.to_tokens(s)?;
677                s.append(TK_LP, None)?;
678                s.append(TK_STAR, None)?;
679                s.append(TK_RP, None)?;
680                if let Some(filter_over) = filter_over {
681                    filter_over.to_tokens(s)?;
682                }
683                Ok(())
684            }
685            Self::Id(id) => id.to_tokens(s),
686            Self::Column { .. } => Ok(()),
687            Self::InList { lhs, not, rhs } => {
688                lhs.to_tokens(s)?;
689                if *not {
690                    s.append(TK_NOT, None)?;
691                }
692                s.append(TK_IN, None)?;
693                s.append(TK_LP, None)?;
694                if let Some(rhs) = rhs {
695                    comma(rhs, s)?;
696                }
697                s.append(TK_RP, None)
698            }
699            Self::InSelect { lhs, not, rhs } => {
700                lhs.to_tokens(s)?;
701                if *not {
702                    s.append(TK_NOT, None)?;
703                }
704                s.append(TK_IN, None)?;
705                s.append(TK_LP, None)?;
706                rhs.to_tokens(s)?;
707                s.append(TK_RP, None)
708            }
709            Self::InTable {
710                lhs,
711                not,
712                rhs,
713                args,
714            } => {
715                lhs.to_tokens(s)?;
716                if *not {
717                    s.append(TK_NOT, None)?;
718                }
719                s.append(TK_IN, None)?;
720                rhs.to_tokens(s)?;
721                if let Some(args) = args {
722                    s.append(TK_LP, None)?;
723                    comma(args, s)?;
724                    s.append(TK_RP, None)?;
725                }
726                Ok(())
727            }
728            Self::IsNull(sub_expr) => {
729                sub_expr.to_tokens(s)?;
730                s.append(TK_ISNULL, None)
731            }
732            Self::Like {
733                lhs,
734                not,
735                op,
736                rhs,
737                escape,
738            } => {
739                lhs.to_tokens(s)?;
740                if *not {
741                    s.append(TK_NOT, None)?;
742                }
743                op.to_tokens(s)?;
744                rhs.to_tokens(s)?;
745                if let Some(escape) = escape {
746                    s.append(TK_ESCAPE, None)?;
747                    escape.to_tokens(s)?;
748                }
749                Ok(())
750            }
751            Self::Literal(lit) => lit.to_tokens(s),
752            Self::Name(name) => name.to_tokens(s),
753            Self::NotNull(sub_expr) => {
754                sub_expr.to_tokens(s)?;
755                s.append(TK_NOTNULL, None)
756            }
757            Self::Parenthesized(exprs) => {
758                s.append(TK_LP, None)?;
759                comma(exprs, s)?;
760                s.append(TK_RP, None)
761            }
762            Self::Qualified(qualifier, qualified) => {
763                qualifier.to_tokens(s)?;
764                s.append(TK_DOT, None)?;
765                qualified.to_tokens(s)
766            }
767            Self::Raise(rt, err) => {
768                s.append(TK_RAISE, None)?;
769                s.append(TK_LP, None)?;
770                rt.to_tokens(s)?;
771                if let Some(err) = err {
772                    s.append(TK_COMMA, None)?;
773                    err.to_tokens(s)?;
774                }
775                s.append(TK_RP, None)
776            }
777            Self::RowId { .. } => Ok(()),
778            Self::Subquery(query) => {
779                s.append(TK_LP, None)?;
780                query.to_tokens(s)?;
781                s.append(TK_RP, None)
782            }
783            Self::Unary(op, sub_expr) => {
784                op.to_tokens(s)?;
785                sub_expr.to_tokens(s)
786            }
787            Self::Variable(var) => match var.chars().next() {
788                Some(c) if c == '$' || c == '@' || c == '#' || c == ':' => {
789                    s.append(TK_VARIABLE, Some(var))
790                }
791                Some(_) => s.append(TK_VARIABLE, Some(&("?".to_owned() + var))),
792                None => s.append(TK_VARIABLE, Some("?")),
793            },
794        }
795    }
796}
797
798impl Display for Expr {
799    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
800        self.to_fmt(f)
801    }
802}
803
804impl ToTokens for Literal {
805    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
806        match self {
807            Self::Numeric(ref num) => s.append(TK_FLOAT, Some(num)), // TODO Validate TK_FLOAT
808            Self::String(ref str) => s.append(TK_STRING, Some(str)),
809            Self::Blob(ref blob) => s.append(TK_BLOB, Some(blob)),
810            Self::Keyword(ref str) => s.append(TK_ID, Some(str)), // TODO Validate TK_ID
811            Self::Null => s.append(TK_NULL, None),
812            Self::CurrentDate => s.append(TK_CTIME_KW, Some("CURRENT_DATE")),
813            Self::CurrentTime => s.append(TK_CTIME_KW, Some("CURRENT_TIME")),
814            Self::CurrentTimestamp => s.append(TK_CTIME_KW, Some("CURRENT_TIMESTAMP")),
815        }
816    }
817}
818
819impl ToTokens for LikeOperator {
820    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
821        s.append(
822            TK_LIKE_KW,
823            Some(match self {
824                Self::Glob => "GLOB",
825                Self::Like => "LIKE",
826                Self::Match => "MATCH",
827                Self::Regexp => "REGEXP",
828            }),
829        )
830    }
831}
832
833impl ToTokens for Operator {
834    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
835        match self {
836            Self::Add => s.append(TK_PLUS, None),
837            Self::And => s.append(TK_AND, None),
838            Self::ArrowRight => s.append(TK_PTR, Some("->")),
839            Self::ArrowRightShift => s.append(TK_PTR, Some("->>")),
840            Self::BitwiseAnd => s.append(TK_BITAND, None),
841            Self::BitwiseOr => s.append(TK_BITOR, None),
842            Self::BitwiseNot => s.append(TK_BITNOT, None),
843            Self::Concat => s.append(TK_CONCAT, None),
844            Self::Equals => s.append(TK_EQ, None),
845            Self::Divide => s.append(TK_SLASH, None),
846            Self::Greater => s.append(TK_GT, None),
847            Self::GreaterEquals => s.append(TK_GE, None),
848            Self::Is => s.append(TK_IS, None),
849            Self::IsNot => {
850                s.append(TK_IS, None)?;
851                s.append(TK_NOT, None)
852            }
853            Self::LeftShift => s.append(TK_LSHIFT, None),
854            Self::Less => s.append(TK_LT, None),
855            Self::LessEquals => s.append(TK_LE, None),
856            Self::Modulus => s.append(TK_REM, None),
857            Self::Multiply => s.append(TK_STAR, None),
858            Self::NotEquals => s.append(TK_NE, None),
859            Self::Or => s.append(TK_OR, None),
860            Self::RightShift => s.append(TK_RSHIFT, None),
861            Self::Subtract => s.append(TK_MINUS, None),
862        }
863    }
864}
865
866impl ToTokens for UnaryOperator {
867    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
868        s.append(
869            match self {
870                Self::BitwiseNot => TK_BITNOT,
871                Self::Negative => TK_MINUS,
872                Self::Not => TK_NOT,
873                Self::Positive => TK_PLUS,
874            },
875            None,
876        )
877    }
878}
879
880impl ToTokens for Select {
881    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
882        if let Some(ref with) = self.with {
883            with.to_tokens(s)?;
884        }
885        self.body.to_tokens(s)?;
886        if let Some(ref order_by) = self.order_by {
887            s.append(TK_ORDER, None)?;
888            s.append(TK_BY, None)?;
889            comma(order_by, s)?;
890        }
891        if let Some(ref limit) = self.limit {
892            limit.to_tokens(s)?;
893        }
894        Ok(())
895    }
896}
897
898impl ToTokens for SelectBody {
899    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
900        self.select.to_tokens(s)?;
901        if let Some(ref compounds) = self.compounds {
902            for compound in compounds {
903                compound.to_tokens(s)?;
904            }
905        }
906        Ok(())
907    }
908}
909
910impl ToTokens for CompoundSelect {
911    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
912        self.operator.to_tokens(s)?;
913        self.select.to_tokens(s)
914    }
915}
916
917impl ToTokens for CompoundOperator {
918    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
919        match self {
920            Self::Union => s.append(TK_UNION, None),
921            Self::UnionAll => {
922                s.append(TK_UNION, None)?;
923                s.append(TK_ALL, None)
924            }
925            Self::Except => s.append(TK_EXCEPT, None),
926            Self::Intersect => s.append(TK_INTERSECT, None),
927        }
928    }
929}
930
931impl Display for CompoundOperator {
932    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
933        self.to_fmt(f)
934    }
935}
936
937impl ToTokens for OneSelect {
938    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
939        match self {
940            Self::Select(select) => {
941                let SelectInner {
942                    distinctness,
943                    columns,
944                    from,
945                    where_clause,
946                    group_by,
947                    window_clause,
948                } = &**select;
949                s.append(TK_SELECT, None)?;
950                if let Some(ref distinctness) = distinctness {
951                    distinctness.to_tokens(s)?;
952                }
953                comma(columns, s)?;
954                if let Some(ref from) = from {
955                    s.append(TK_FROM, None)?;
956                    from.to_tokens(s)?;
957                }
958                if let Some(ref where_clause) = where_clause {
959                    s.append(TK_WHERE, None)?;
960                    where_clause.to_tokens(s)?;
961                }
962                if let Some(ref group_by) = group_by {
963                    group_by.to_tokens(s)?;
964                }
965                if let Some(ref window_clause) = window_clause {
966                    s.append(TK_WINDOW, None)?;
967                    comma(window_clause, s)?;
968                }
969                Ok(())
970            }
971            Self::Values(values) => {
972                for (i, vals) in values.iter().enumerate() {
973                    if i == 0 {
974                        s.append(TK_VALUES, None)?;
975                    } else {
976                        s.append(TK_COMMA, None)?;
977                    }
978                    s.append(TK_LP, None)?;
979                    comma(vals, s)?;
980                    s.append(TK_RP, None)?;
981                }
982                Ok(())
983            }
984        }
985    }
986}
987
988impl ToTokens for FromClause {
989    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
990        self.select.as_ref().unwrap().to_tokens(s)?;
991        if let Some(ref joins) = self.joins {
992            for join in joins {
993                join.to_tokens(s)?;
994            }
995        }
996        Ok(())
997    }
998}
999
1000impl ToTokens for Distinctness {
1001    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1002        s.append(
1003            match self {
1004                Self::Distinct => TK_DISTINCT,
1005                Self::All => TK_ALL,
1006            },
1007            None,
1008        )
1009    }
1010}
1011
1012impl ToTokens for ResultColumn {
1013    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1014        match self {
1015            Self::Expr(expr, alias) => {
1016                expr.to_tokens(s)?;
1017                if let Some(alias) = alias {
1018                    alias.to_tokens(s)?;
1019                }
1020                Ok(())
1021            }
1022            Self::Star => s.append(TK_STAR, None),
1023            Self::TableStar(tbl_name) => {
1024                tbl_name.to_tokens(s)?;
1025                s.append(TK_DOT, None)?;
1026                s.append(TK_STAR, None)
1027            }
1028        }
1029    }
1030}
1031
1032impl ToTokens for As {
1033    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1034        match self {
1035            Self::As(ref name) => {
1036                s.append(TK_AS, None)?;
1037                name.to_tokens(s)
1038            }
1039            Self::Elided(ref name) => name.to_tokens(s),
1040        }
1041    }
1042}
1043
1044impl ToTokens for JoinedSelectTable {
1045    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1046        self.operator.to_tokens(s)?;
1047        self.table.to_tokens(s)?;
1048        if let Some(ref constraint) = self.constraint {
1049            constraint.to_tokens(s)?;
1050        }
1051        Ok(())
1052    }
1053}
1054
1055impl ToTokens for SelectTable {
1056    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1057        match self {
1058            Self::Table(name, alias, indexed) => {
1059                name.to_tokens(s)?;
1060                if let Some(alias) = alias {
1061                    alias.to_tokens(s)?;
1062                }
1063                if let Some(indexed) = indexed {
1064                    indexed.to_tokens(s)?;
1065                }
1066                Ok(())
1067            }
1068            Self::TableCall(name, exprs, alias) => {
1069                name.to_tokens(s)?;
1070                s.append(TK_LP, None)?;
1071                if let Some(exprs) = exprs {
1072                    comma(exprs, s)?;
1073                }
1074                s.append(TK_RP, None)?;
1075                if let Some(alias) = alias {
1076                    alias.to_tokens(s)?;
1077                }
1078                Ok(())
1079            }
1080            Self::Select(select, alias) => {
1081                s.append(TK_LP, None)?;
1082                select.to_tokens(s)?;
1083                s.append(TK_RP, None)?;
1084                if let Some(alias) = alias {
1085                    alias.to_tokens(s)?;
1086                }
1087                Ok(())
1088            }
1089            Self::Sub(from, alias) => {
1090                s.append(TK_LP, None)?;
1091                from.to_tokens(s)?;
1092                s.append(TK_RP, None)?;
1093                if let Some(alias) = alias {
1094                    alias.to_tokens(s)?;
1095                }
1096                Ok(())
1097            }
1098        }
1099    }
1100}
1101
1102impl ToTokens for JoinOperator {
1103    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1104        match self {
1105            Self::Comma => s.append(TK_COMMA, None),
1106            Self::TypedJoin(join_type) => {
1107                if let Some(ref join_type) = join_type {
1108                    join_type.to_tokens(s)?;
1109                }
1110                s.append(TK_JOIN, None)
1111            }
1112        }
1113    }
1114}
1115
1116impl ToTokens for JoinType {
1117    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1118        if self.contains(Self::NATURAL) {
1119            s.append(TK_JOIN_KW, Some("NATURAL"))?;
1120        }
1121        if self.contains(Self::INNER) {
1122            if self.contains(Self::CROSS) {
1123                s.append(TK_JOIN_KW, Some("CROSS"))?;
1124            }
1125            s.append(TK_JOIN_KW, Some("INNER"))?;
1126        } else {
1127            if self.contains(Self::LEFT) {
1128                if self.contains(Self::RIGHT) {
1129                    s.append(TK_JOIN_KW, Some("FULL"))?;
1130                } else {
1131                    s.append(TK_JOIN_KW, Some("LEFT"))?;
1132                }
1133            } else if self.contains(Self::RIGHT) {
1134                s.append(TK_JOIN_KW, Some("RIGHT"))?;
1135            }
1136            if self.contains(Self::OUTER) {
1137                s.append(TK_JOIN_KW, Some("OUTER"))?;
1138            }
1139        }
1140        Ok(())
1141    }
1142}
1143
1144impl ToTokens for JoinConstraint {
1145    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1146        match self {
1147            Self::On(expr) => {
1148                s.append(TK_ON, None)?;
1149                expr.to_tokens(s)
1150            }
1151            Self::Using(col_names) => {
1152                s.append(TK_USING, None)?;
1153                s.append(TK_LP, None)?;
1154                comma(col_names.deref(), s)?;
1155                s.append(TK_RP, None)
1156            }
1157        }
1158    }
1159}
1160
1161impl ToTokens for GroupBy {
1162    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1163        s.append(TK_GROUP, None)?;
1164        s.append(TK_BY, None)?;
1165        comma(&self.exprs, s)?;
1166        if let Some(ref having) = self.having {
1167            s.append(TK_HAVING, None)?;
1168            having.to_tokens(s)?;
1169        }
1170        Ok(())
1171    }
1172}
1173
1174impl ToTokens for Id {
1175    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1176        double_quote(&self.0, s)
1177    }
1178}
1179
1180impl ToTokens for Name {
1181    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1182        double_quote(self.0.as_str(), s)
1183    }
1184}
1185
1186impl Display for Name {
1187    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
1188        self.to_fmt(f)
1189    }
1190}
1191
1192impl ToTokens for QualifiedName {
1193    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1194        if let Some(ref db_name) = self.db_name {
1195            db_name.to_tokens(s)?;
1196            s.append(TK_DOT, None)?;
1197        }
1198        self.name.to_tokens(s)?;
1199        if let Some(ref alias) = self.alias {
1200            s.append(TK_AS, None)?;
1201            alias.to_tokens(s)?;
1202        }
1203        Ok(())
1204    }
1205}
1206
1207impl ToTokens for AlterTableBody {
1208    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1209        match self {
1210            Self::RenameTo(name) => {
1211                s.append(TK_RENAME, None)?;
1212                s.append(TK_TO, None)?;
1213                name.to_tokens(s)
1214            }
1215            Self::AddColumn(def) => {
1216                s.append(TK_ADD, None)?;
1217                s.append(TK_COLUMNKW, None)?;
1218                def.to_tokens(s)
1219            }
1220            Self::RenameColumn { old, new } => {
1221                s.append(TK_RENAME, None)?;
1222                old.to_tokens(s)?;
1223                s.append(TK_TO, None)?;
1224                new.to_tokens(s)
1225            }
1226            Self::DropColumn(name) => {
1227                s.append(TK_DROP, None)?;
1228                s.append(TK_COLUMNKW, None)?;
1229                name.to_tokens(s)
1230            }
1231        }
1232    }
1233}
1234
1235impl ToTokens for CreateTableBody {
1236    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1237        match self {
1238            Self::ColumnsAndConstraints {
1239                columns,
1240                constraints,
1241                options,
1242            } => {
1243                s.append(TK_LP, None)?;
1244                comma(columns.values(), s)?;
1245                if let Some(constraints) = constraints {
1246                    s.append(TK_COMMA, None)?;
1247                    comma(constraints, s)?;
1248                }
1249                s.append(TK_RP, None)?;
1250                if options.contains(TableOptions::WITHOUT_ROWID) {
1251                    s.append(TK_WITHOUT, None)?;
1252                    s.append(TK_ID, Some("ROWID"))?;
1253                }
1254                if options.contains(TableOptions::STRICT) {
1255                    s.append(TK_ID, Some("STRICT"))?;
1256                }
1257                Ok(())
1258            }
1259            Self::AsSelect(select) => {
1260                s.append(TK_AS, None)?;
1261                select.to_tokens(s)
1262            }
1263        }
1264    }
1265}
1266
1267impl ToTokens for ColumnDefinition {
1268    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1269        self.col_name.to_tokens(s)?;
1270        if let Some(ref col_type) = self.col_type {
1271            col_type.to_tokens(s)?;
1272        }
1273        for constraint in &self.constraints {
1274            constraint.to_tokens(s)?;
1275        }
1276        Ok(())
1277    }
1278}
1279
1280impl ToTokens for NamedColumnConstraint {
1281    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1282        if let Some(ref name) = self.name {
1283            s.append(TK_CONSTRAINT, None)?;
1284            name.to_tokens(s)?;
1285        }
1286        self.constraint.to_tokens(s)
1287    }
1288}
1289
1290impl ToTokens for ColumnConstraint {
1291    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1292        match self {
1293            Self::PrimaryKey {
1294                order,
1295                conflict_clause,
1296                auto_increment,
1297            } => {
1298                s.append(TK_PRIMARY, None)?;
1299                s.append(TK_KEY, None)?;
1300                if let Some(order) = order {
1301                    order.to_tokens(s)?;
1302                }
1303                if let Some(conflict_clause) = conflict_clause {
1304                    s.append(TK_ON, None)?;
1305                    s.append(TK_CONFLICT, None)?;
1306                    conflict_clause.to_tokens(s)?;
1307                }
1308                if *auto_increment {
1309                    s.append(TK_AUTOINCR, None)?;
1310                }
1311                Ok(())
1312            }
1313            Self::NotNull {
1314                nullable,
1315                conflict_clause,
1316            } => {
1317                if !nullable {
1318                    s.append(TK_NOT, None)?;
1319                }
1320                s.append(TK_NULL, None)?;
1321                if let Some(conflict_clause) = conflict_clause {
1322                    s.append(TK_ON, None)?;
1323                    s.append(TK_CONFLICT, None)?;
1324                    conflict_clause.to_tokens(s)?;
1325                }
1326                Ok(())
1327            }
1328            Self::Unique(conflict_clause) => {
1329                s.append(TK_UNIQUE, None)?;
1330                if let Some(conflict_clause) = conflict_clause {
1331                    s.append(TK_ON, None)?;
1332                    s.append(TK_CONFLICT, None)?;
1333                    conflict_clause.to_tokens(s)?;
1334                }
1335                Ok(())
1336            }
1337            Self::Check(expr) => {
1338                s.append(TK_CHECK, None)?;
1339                s.append(TK_LP, None)?;
1340                expr.to_tokens(s)?;
1341                s.append(TK_RP, None)
1342            }
1343            Self::Default(expr) => {
1344                s.append(TK_DEFAULT, None)?;
1345                expr.to_tokens(s)
1346            }
1347            Self::Defer(deref_clause) => deref_clause.to_tokens(s),
1348            Self::Collate { collation_name } => {
1349                s.append(TK_COLLATE, None)?;
1350                collation_name.to_tokens(s)
1351            }
1352            Self::ForeignKey {
1353                clause,
1354                deref_clause,
1355            } => {
1356                s.append(TK_REFERENCES, None)?;
1357                clause.to_tokens(s)?;
1358                if let Some(deref_clause) = deref_clause {
1359                    deref_clause.to_tokens(s)?;
1360                }
1361                Ok(())
1362            }
1363            Self::Generated { expr, typ } => {
1364                s.append(TK_AS, None)?;
1365                s.append(TK_LP, None)?;
1366                expr.to_tokens(s)?;
1367                s.append(TK_RP, None)?;
1368                if let Some(typ) = typ {
1369                    typ.to_tokens(s)?;
1370                }
1371                Ok(())
1372            }
1373        }
1374    }
1375}
1376
1377impl ToTokens for NamedTableConstraint {
1378    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1379        if let Some(ref name) = self.name {
1380            s.append(TK_CONSTRAINT, None)?;
1381            name.to_tokens(s)?;
1382        }
1383        self.constraint.to_tokens(s)
1384    }
1385}
1386
1387impl ToTokens for TableConstraint {
1388    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1389        match self {
1390            Self::PrimaryKey {
1391                columns,
1392                auto_increment,
1393                conflict_clause,
1394            } => {
1395                s.append(TK_PRIMARY, None)?;
1396                s.append(TK_KEY, None)?;
1397                s.append(TK_LP, None)?;
1398                comma(columns, s)?;
1399                if *auto_increment {
1400                    s.append(TK_AUTOINCR, None)?;
1401                }
1402                s.append(TK_RP, None)?;
1403                if let Some(conflict_clause) = conflict_clause {
1404                    s.append(TK_ON, None)?;
1405                    s.append(TK_CONFLICT, None)?;
1406                    conflict_clause.to_tokens(s)?;
1407                }
1408                Ok(())
1409            }
1410            Self::Unique {
1411                columns,
1412                conflict_clause,
1413            } => {
1414                s.append(TK_UNIQUE, None)?;
1415                s.append(TK_LP, None)?;
1416                comma(columns, s)?;
1417                s.append(TK_RP, None)?;
1418                if let Some(conflict_clause) = conflict_clause {
1419                    s.append(TK_ON, None)?;
1420                    s.append(TK_CONFLICT, None)?;
1421                    conflict_clause.to_tokens(s)?;
1422                }
1423                Ok(())
1424            }
1425            Self::Check(expr) => {
1426                s.append(TK_CHECK, None)?;
1427                s.append(TK_LP, None)?;
1428                expr.to_tokens(s)?;
1429                s.append(TK_RP, None)
1430            }
1431            Self::ForeignKey {
1432                columns,
1433                clause,
1434                deref_clause,
1435            } => {
1436                s.append(TK_FOREIGN, None)?;
1437                s.append(TK_KEY, None)?;
1438                s.append(TK_LP, None)?;
1439                comma(columns, s)?;
1440                s.append(TK_RP, None)?;
1441                s.append(TK_REFERENCES, None)?;
1442                clause.to_tokens(s)?;
1443                if let Some(deref_clause) = deref_clause {
1444                    deref_clause.to_tokens(s)?;
1445                }
1446                Ok(())
1447            }
1448        }
1449    }
1450}
1451
1452impl ToTokens for SortOrder {
1453    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1454        s.append(
1455            match self {
1456                Self::Asc => TK_ASC,
1457                Self::Desc => TK_DESC,
1458            },
1459            None,
1460        )
1461    }
1462}
1463
1464impl ToTokens for NullsOrder {
1465    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1466        s.append(TK_NULLS, None)?;
1467        s.append(
1468            match self {
1469                Self::First => TK_FIRST,
1470                Self::Last => TK_LAST,
1471            },
1472            None,
1473        )
1474    }
1475}
1476
1477impl ToTokens for ForeignKeyClause {
1478    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1479        self.tbl_name.to_tokens(s)?;
1480        if let Some(ref columns) = self.columns {
1481            s.append(TK_LP, None)?;
1482            comma(columns, s)?;
1483            s.append(TK_RP, None)?;
1484        }
1485        for arg in &self.args {
1486            arg.to_tokens(s)?;
1487        }
1488        Ok(())
1489    }
1490}
1491
1492impl ToTokens for RefArg {
1493    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1494        match self {
1495            Self::OnDelete(ref action) => {
1496                s.append(TK_ON, None)?;
1497                s.append(TK_DELETE, None)?;
1498                action.to_tokens(s)
1499            }
1500            Self::OnInsert(ref action) => {
1501                s.append(TK_ON, None)?;
1502                s.append(TK_INSERT, None)?;
1503                action.to_tokens(s)
1504            }
1505            Self::OnUpdate(ref action) => {
1506                s.append(TK_ON, None)?;
1507                s.append(TK_UPDATE, None)?;
1508                action.to_tokens(s)
1509            }
1510            Self::Match(ref name) => {
1511                s.append(TK_MATCH, None)?;
1512                name.to_tokens(s)
1513            }
1514        }
1515    }
1516}
1517
1518impl ToTokens for RefAct {
1519    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1520        match self {
1521            Self::SetNull => {
1522                s.append(TK_SET, None)?;
1523                s.append(TK_NULL, None)
1524            }
1525            Self::SetDefault => {
1526                s.append(TK_SET, None)?;
1527                s.append(TK_DEFAULT, None)
1528            }
1529            Self::Cascade => s.append(TK_CASCADE, None),
1530            Self::Restrict => s.append(TK_RESTRICT, None),
1531            Self::NoAction => {
1532                s.append(TK_NO, None)?;
1533                s.append(TK_ACTION, None)
1534            }
1535        }
1536    }
1537}
1538
1539impl ToTokens for DeferSubclause {
1540    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1541        if !self.deferrable {
1542            s.append(TK_NOT, None)?;
1543        }
1544        s.append(TK_DEFERRABLE, None)?;
1545        if let Some(init_deferred) = self.init_deferred {
1546            init_deferred.to_tokens(s)?;
1547        }
1548        Ok(())
1549    }
1550}
1551
1552impl ToTokens for InitDeferredPred {
1553    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1554        s.append(TK_INITIALLY, None)?;
1555        s.append(
1556            match self {
1557                Self::InitiallyDeferred => TK_DEFERRED,
1558                Self::InitiallyImmediate => TK_IMMEDIATE,
1559            },
1560            None,
1561        )
1562    }
1563}
1564
1565impl ToTokens for IndexedColumn {
1566    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1567        self.col_name.to_tokens(s)?;
1568        if let Some(ref collation_name) = self.collation_name {
1569            s.append(TK_COLLATE, None)?;
1570            collation_name.to_tokens(s)?;
1571        }
1572        if let Some(order) = self.order {
1573            order.to_tokens(s)?;
1574        }
1575        Ok(())
1576    }
1577}
1578
1579impl ToTokens for Indexed {
1580    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1581        match self {
1582            Self::IndexedBy(ref name) => {
1583                s.append(TK_INDEXED, None)?;
1584                s.append(TK_BY, None)?;
1585                name.to_tokens(s)
1586            }
1587            Self::NotIndexed => {
1588                s.append(TK_NOT, None)?;
1589                s.append(TK_INDEXED, None)
1590            }
1591        }
1592    }
1593}
1594
1595impl ToTokens for SortedColumn {
1596    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1597        self.expr.to_tokens(s)?;
1598        if let Some(ref order) = self.order {
1599            order.to_tokens(s)?;
1600        }
1601        if let Some(ref nulls) = self.nulls {
1602            nulls.to_tokens(s)?;
1603        }
1604        Ok(())
1605    }
1606}
1607
1608impl ToTokens for Limit {
1609    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1610        s.append(TK_LIMIT, None)?;
1611        self.expr.to_tokens(s)?;
1612        if let Some(ref offset) = self.offset {
1613            s.append(TK_OFFSET, None)?;
1614            offset.to_tokens(s)?;
1615        }
1616        Ok(())
1617    }
1618}
1619
1620impl ToTokens for InsertBody {
1621    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1622        match self {
1623            Self::Select(select, upsert) => {
1624                select.to_tokens(s)?;
1625                if let Some(upsert) = upsert {
1626                    upsert.to_tokens(s)?;
1627                }
1628                Ok(())
1629            }
1630            Self::DefaultValues => {
1631                s.append(TK_DEFAULT, None)?;
1632                s.append(TK_VALUES, None)
1633            }
1634        }
1635    }
1636}
1637
1638impl ToTokens for Set {
1639    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1640        if self.col_names.len() == 1 {
1641            comma(self.col_names.deref(), s)?;
1642        } else {
1643            s.append(TK_LP, None)?;
1644            comma(self.col_names.deref(), s)?;
1645            s.append(TK_RP, None)?;
1646        }
1647        s.append(TK_EQ, None)?;
1648        self.expr.to_tokens(s)
1649    }
1650}
1651
1652impl ToTokens for PragmaBody {
1653    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1654        match self {
1655            Self::Equals(value) => {
1656                s.append(TK_EQ, None)?;
1657                value.to_tokens(s)
1658            }
1659            Self::Call(value) => {
1660                s.append(TK_LP, None)?;
1661                value.to_tokens(s)?;
1662                s.append(TK_RP, None)
1663            }
1664        }
1665    }
1666}
1667
1668impl ToTokens for TriggerTime {
1669    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1670        match self {
1671            Self::Before => s.append(TK_BEFORE, None),
1672            Self::After => s.append(TK_AFTER, None),
1673            Self::InsteadOf => {
1674                s.append(TK_INSTEAD, None)?;
1675                s.append(TK_OF, None)
1676            }
1677        }
1678    }
1679}
1680
1681impl ToTokens for TriggerEvent {
1682    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1683        match self {
1684            Self::Delete => s.append(TK_DELETE, None),
1685            Self::Insert => s.append(TK_INSERT, None),
1686            Self::Update => s.append(TK_UPDATE, None),
1687            Self::UpdateOf(ref col_names) => {
1688                s.append(TK_UPDATE, None)?;
1689                s.append(TK_OF, None)?;
1690                comma(col_names.deref(), s)
1691            }
1692        }
1693    }
1694}
1695
1696impl ToTokens for TriggerCmd {
1697    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1698        match self {
1699            Self::Update(update) => {
1700                let TriggerCmdUpdate {
1701                    or_conflict,
1702                    tbl_name,
1703                    sets,
1704                    from,
1705                    where_clause,
1706                } = &**update;
1707                s.append(TK_UPDATE, None)?;
1708                if let Some(or_conflict) = or_conflict {
1709                    s.append(TK_OR, None)?;
1710                    or_conflict.to_tokens(s)?;
1711                }
1712                tbl_name.to_tokens(s)?;
1713                s.append(TK_SET, None)?;
1714                comma(sets, s)?;
1715                if let Some(from) = from {
1716                    s.append(TK_FROM, None)?;
1717                    from.to_tokens(s)?;
1718                }
1719                if let Some(where_clause) = where_clause {
1720                    s.append(TK_WHERE, None)?;
1721                    where_clause.to_tokens(s)?;
1722                }
1723                Ok(())
1724            }
1725            Self::Insert(insert) => {
1726                let TriggerCmdInsert {
1727                    or_conflict,
1728                    tbl_name,
1729                    col_names,
1730                    select,
1731                    upsert,
1732                    returning,
1733                } = &**insert;
1734                if let Some(ResolveType::Replace) = or_conflict {
1735                    s.append(TK_REPLACE, None)?;
1736                } else {
1737                    s.append(TK_INSERT, None)?;
1738                    if let Some(or_conflict) = or_conflict {
1739                        s.append(TK_OR, None)?;
1740                        or_conflict.to_tokens(s)?;
1741                    }
1742                }
1743                s.append(TK_INTO, None)?;
1744                tbl_name.to_tokens(s)?;
1745                if let Some(col_names) = col_names {
1746                    s.append(TK_LP, None)?;
1747                    comma(col_names.deref(), s)?;
1748                    s.append(TK_RP, None)?;
1749                }
1750                select.to_tokens(s)?;
1751                if let Some(upsert) = upsert {
1752                    upsert.to_tokens(s)?;
1753                }
1754                if let Some(returning) = returning {
1755                    s.append(TK_RETURNING, None)?;
1756                    comma(returning, s)?;
1757                }
1758                Ok(())
1759            }
1760            Self::Delete(delete) => {
1761                s.append(TK_DELETE, None)?;
1762                s.append(TK_FROM, None)?;
1763                delete.tbl_name.to_tokens(s)?;
1764                if let Some(where_clause) = &delete.where_clause {
1765                    s.append(TK_WHERE, None)?;
1766                    where_clause.to_tokens(s)?;
1767                }
1768                Ok(())
1769            }
1770            Self::Select(select) => select.to_tokens(s),
1771        }
1772    }
1773}
1774
1775impl ToTokens for ResolveType {
1776    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1777        s.append(
1778            match self {
1779                Self::Rollback => TK_ROLLBACK,
1780                Self::Abort => TK_ABORT,
1781                Self::Fail => TK_FAIL,
1782                Self::Ignore => TK_IGNORE,
1783                Self::Replace => TK_REPLACE,
1784            },
1785            None,
1786        )
1787    }
1788}
1789
1790impl ToTokens for With {
1791    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1792        s.append(TK_WITH, None)?;
1793        if self.recursive {
1794            s.append(TK_RECURSIVE, None)?;
1795        }
1796        comma(&self.ctes, s)
1797    }
1798}
1799
1800impl ToTokens for CommonTableExpr {
1801    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1802        self.tbl_name.to_tokens(s)?;
1803        if let Some(ref columns) = self.columns {
1804            s.append(TK_LP, None)?;
1805            comma(columns, s)?;
1806            s.append(TK_RP, None)?;
1807        }
1808        s.append(TK_AS, None)?;
1809        match self.materialized {
1810            Materialized::Any => {}
1811            Materialized::Yes => {
1812                s.append(TK_MATERIALIZED, None)?;
1813            }
1814            Materialized::No => {
1815                s.append(TK_NOT, None)?;
1816                s.append(TK_MATERIALIZED, None)?;
1817            }
1818        };
1819        s.append(TK_LP, None)?;
1820        self.select.to_tokens(s)?;
1821        s.append(TK_RP, None)
1822    }
1823}
1824
1825impl ToTokens for Type {
1826    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1827        match self.size {
1828            None => s.append(TK_ID, Some(&self.name)),
1829            Some(ref size) => {
1830                s.append(TK_ID, Some(&self.name))?; // TODO check there is no forbidden chars
1831                s.append(TK_LP, None)?;
1832                size.to_tokens(s)?;
1833                s.append(TK_RP, None)
1834            }
1835        }
1836    }
1837}
1838
1839impl ToTokens for TypeSize {
1840    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1841        match self {
1842            Self::MaxSize(size) => size.to_tokens(s),
1843            Self::TypeSize(size1, size2) => {
1844                size1.to_tokens(s)?;
1845                s.append(TK_COMMA, None)?;
1846                size2.to_tokens(s)
1847            }
1848        }
1849    }
1850}
1851
1852impl ToTokens for TransactionType {
1853    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1854        s.append(
1855            match self {
1856                Self::Deferred => TK_DEFERRED,
1857                Self::Immediate => TK_IMMEDIATE,
1858                Self::Exclusive => TK_EXCLUSIVE,
1859            },
1860            None,
1861        )
1862    }
1863}
1864
1865impl ToTokens for Upsert {
1866    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1867        s.append(TK_ON, None)?;
1868        s.append(TK_CONFLICT, None)?;
1869        if let Some(ref index) = self.index {
1870            index.to_tokens(s)?;
1871        }
1872        self.do_clause.to_tokens(s)?;
1873        if let Some(ref next) = self.next {
1874            next.to_tokens(s)?;
1875        }
1876        Ok(())
1877    }
1878}
1879
1880impl ToTokens for UpsertIndex {
1881    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1882        s.append(TK_LP, None)?;
1883        comma(&self.targets, s)?;
1884        s.append(TK_RP, None)?;
1885        if let Some(ref where_clause) = self.where_clause {
1886            s.append(TK_WHERE, None)?;
1887            where_clause.to_tokens(s)?;
1888        }
1889        Ok(())
1890    }
1891}
1892
1893impl ToTokens for UpsertDo {
1894    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1895        match self {
1896            Self::Set { sets, where_clause } => {
1897                s.append(TK_DO, None)?;
1898                s.append(TK_UPDATE, None)?;
1899                s.append(TK_SET, None)?;
1900                comma(sets, s)?;
1901                if let Some(where_clause) = where_clause {
1902                    s.append(TK_WHERE, None)?;
1903                    where_clause.to_tokens(s)?;
1904                }
1905                Ok(())
1906            }
1907            Self::Nothing => {
1908                s.append(TK_DO, None)?;
1909                s.append(TK_NOTHING, None)
1910            }
1911        }
1912    }
1913}
1914
1915impl ToTokens for FunctionTail {
1916    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1917        if let Some(ref filter_clause) = self.filter_clause {
1918            s.append(TK_FILTER, None)?;
1919            s.append(TK_LP, None)?;
1920            s.append(TK_WHERE, None)?;
1921            filter_clause.to_tokens(s)?;
1922            s.append(TK_RP, None)?;
1923        }
1924        if let Some(ref over_clause) = self.over_clause {
1925            s.append(TK_OVER, None)?;
1926            over_clause.to_tokens(s)?;
1927        }
1928        Ok(())
1929    }
1930}
1931
1932impl ToTokens for Over {
1933    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1934        match self {
1935            Self::Window(ref window) => window.to_tokens(s),
1936            Self::Name(ref name) => name.to_tokens(s),
1937        }
1938    }
1939}
1940
1941impl ToTokens for WindowDef {
1942    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1943        self.name.to_tokens(s)?;
1944        s.append(TK_AS, None)?;
1945        self.window.to_tokens(s)
1946    }
1947}
1948
1949impl ToTokens for Window {
1950    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1951        s.append(TK_LP, None)?;
1952        if let Some(ref base) = self.base {
1953            base.to_tokens(s)?;
1954        }
1955        if let Some(ref partition_by) = self.partition_by {
1956            s.append(TK_PARTITION, None)?;
1957            s.append(TK_BY, None)?;
1958            comma(partition_by, s)?;
1959        }
1960        if let Some(ref order_by) = self.order_by {
1961            s.append(TK_ORDER, None)?;
1962            s.append(TK_BY, None)?;
1963            comma(order_by, s)?;
1964        }
1965        if let Some(ref frame_clause) = self.frame_clause {
1966            frame_clause.to_tokens(s)?;
1967        }
1968        s.append(TK_RP, None)
1969    }
1970}
1971
1972impl ToTokens for FrameClause {
1973    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1974        self.mode.to_tokens(s)?;
1975        if let Some(ref end) = self.end {
1976            s.append(TK_BETWEEN, None)?;
1977            self.start.to_tokens(s)?;
1978            s.append(TK_AND, None)?;
1979            end.to_tokens(s)?;
1980        } else {
1981            self.start.to_tokens(s)?;
1982        }
1983        if let Some(ref exclude) = self.exclude {
1984            s.append(TK_EXCLUDE, None)?;
1985            exclude.to_tokens(s)?;
1986        }
1987        Ok(())
1988    }
1989}
1990
1991impl ToTokens for FrameMode {
1992    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1993        s.append(
1994            match self {
1995                Self::Groups => TK_GROUPS,
1996                Self::Range => TK_RANGE,
1997                Self::Rows => TK_ROWS,
1998            },
1999            None,
2000        )
2001    }
2002}
2003
2004impl ToTokens for FrameBound {
2005    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
2006        match self {
2007            Self::CurrentRow => {
2008                s.append(TK_CURRENT, None)?;
2009                s.append(TK_ROW, None)
2010            }
2011            Self::Following(value) => {
2012                value.to_tokens(s)?;
2013                s.append(TK_FOLLOWING, None)
2014            }
2015            Self::Preceding(value) => {
2016                value.to_tokens(s)?;
2017                s.append(TK_PRECEDING, None)
2018            }
2019            Self::UnboundedFollowing => {
2020                s.append(TK_UNBOUNDED, None)?;
2021                s.append(TK_FOLLOWING, None)
2022            }
2023            Self::UnboundedPreceding => {
2024                s.append(TK_UNBOUNDED, None)?;
2025                s.append(TK_PRECEDING, None)
2026            }
2027        }
2028    }
2029}
2030
2031impl ToTokens for FrameExclude {
2032    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
2033        match self {
2034            Self::NoOthers => {
2035                s.append(TK_NO, None)?;
2036                s.append(TK_OTHERS, None)
2037            }
2038            Self::CurrentRow => {
2039                s.append(TK_CURRENT, None)?;
2040                s.append(TK_ROW, None)
2041            }
2042            Self::Group => s.append(TK_GROUP, None),
2043            Self::Ties => s.append(TK_TIES, None),
2044        }
2045    }
2046}
2047
2048fn comma<I, S: TokenStream>(items: I, s: &mut S) -> Result<(), S::Error>
2049where
2050    I: IntoIterator,
2051    I::Item: ToTokens,
2052{
2053    let iter = items.into_iter();
2054    for (i, item) in iter.enumerate() {
2055        if i != 0 {
2056            s.append(TK_COMMA, None)?;
2057        }
2058        item.to_tokens(s)?;
2059    }
2060    Ok(())
2061}
2062
2063// TK_ID: [...] / `...` / "..." / some keywords / non keywords
2064fn double_quote<S: TokenStream>(name: &str, s: &mut S) -> Result<(), S::Error> {
2065    if name.is_empty() {
2066        return s.append(TK_ID, Some("\"\""));
2067    }
2068    if is_identifier(name) {
2069        // identifier must be quoted when they match a keyword...
2070        /*if is_keyword(name) {
2071            f.write_char('`')?;
2072            f.write_str(name)?;
2073            return f.write_char('`');
2074        }*/
2075        return s.append(TK_ID, Some(name));
2076    }
2077    /*f.write_char('"')?;
2078    for c in name.chars() {
2079        if c == '"' {
2080            f.write_char(c)?;
2081        }
2082        f.write_char(c)?;
2083    }
2084    f.write_char('"')*/
2085    s.append(TK_ID, Some(name))
2086}
limbo_sqlite3_parser/parser/ast/fmt.rs

limbo_sqlite3_parser/parser/ast/
fmt.rs
