sqlite3_parser/parser/ast/
fmt.rs

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

sqlite3_parser/parser/ast/
fmt.rs
