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

sqlite3_parser/parser/ast/
fmt.rs
