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}
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::RenameColumn { old, new } => {
1190                s.append(TK_RENAME, None)?;
1191                old.to_tokens(s)?;
1192                s.append(TK_TO, None)?;
1193                new.to_tokens(s)
1194            }
1195            Self::DropColumn(name) => {
1196                s.append(TK_DROP, None)?;
1197                s.append(TK_COLUMNKW, None)?;
1198                name.to_tokens(s)
1199            }
1200        }
1201    }
1202}
1203
1204impl ToTokens for CreateTableBody {
1205    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1206        match self {
1207            Self::ColumnsAndConstraints {
1208                columns,
1209                constraints,
1210                flags,
1211            } => {
1212                s.append(TK_LP, None)?;
1213                comma(columns.values(), s)?;
1214                if let Some(constraints) = constraints {
1215                    s.append(TK_COMMA, None)?;
1216                    comma(constraints, s)?;
1217                }
1218                s.append(TK_RP, None)?;
1219                if flags.contains(TabFlags::WithoutRowid) {
1220                    s.append(TK_WITHOUT, None)?;
1221                    s.append(TK_ID, Some("ROWID"))?;
1222                }
1223                if flags.contains(TabFlags::Strict) {
1224                    s.append(TK_ID, Some("STRICT"))?;
1225                }
1226                Ok(())
1227            }
1228            Self::AsSelect(select) => {
1229                s.append(TK_AS, None)?;
1230                select.to_tokens(s)
1231            }
1232        }
1233    }
1234}
1235
1236impl ToTokens for ColumnDefinition {
1237    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1238        self.col_name.to_tokens(s)?;
1239        if let Some(ref col_type) = self.col_type {
1240            col_type.to_tokens(s)?;
1241        }
1242        for constraint in &self.constraints {
1243            constraint.to_tokens(s)?;
1244        }
1245        Ok(())
1246    }
1247}
1248
1249impl ToTokens for NamedColumnConstraint {
1250    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1251        if let Some(ref name) = self.name {
1252            s.append(TK_CONSTRAINT, None)?;
1253            name.to_tokens(s)?;
1254        }
1255        self.constraint.to_tokens(s)
1256    }
1257}
1258
1259impl ToTokens for ColumnConstraint {
1260    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1261        match self {
1262            Self::PrimaryKey {
1263                order,
1264                conflict_clause,
1265                auto_increment,
1266            } => {
1267                s.append(TK_PRIMARY, None)?;
1268                s.append(TK_KEY, None)?;
1269                if let Some(order) = order {
1270                    order.to_tokens(s)?;
1271                }
1272                if let Some(conflict_clause) = conflict_clause {
1273                    s.append(TK_ON, None)?;
1274                    s.append(TK_CONFLICT, None)?;
1275                    conflict_clause.to_tokens(s)?;
1276                }
1277                if *auto_increment {
1278                    s.append(TK_AUTOINCR, None)?;
1279                }
1280                Ok(())
1281            }
1282            Self::NotNull {
1283                nullable,
1284                conflict_clause,
1285            } => {
1286                if !nullable {
1287                    s.append(TK_NOT, None)?;
1288                }
1289                s.append(TK_NULL, None)?;
1290                if let Some(conflict_clause) = conflict_clause {
1291                    s.append(TK_ON, None)?;
1292                    s.append(TK_CONFLICT, None)?;
1293                    conflict_clause.to_tokens(s)?;
1294                }
1295                Ok(())
1296            }
1297            Self::Unique(conflict_clause) => {
1298                s.append(TK_UNIQUE, None)?;
1299                if let Some(conflict_clause) = conflict_clause {
1300                    s.append(TK_ON, None)?;
1301                    s.append(TK_CONFLICT, None)?;
1302                    conflict_clause.to_tokens(s)?;
1303                }
1304                Ok(())
1305            }
1306            Self::Check(expr) => {
1307                s.append(TK_CHECK, None)?;
1308                s.append(TK_LP, None)?;
1309                expr.to_tokens(s)?;
1310                s.append(TK_RP, None)
1311            }
1312            Self::Default(expr) => {
1313                s.append(TK_DEFAULT, None)?;
1314                expr.to_tokens(s)
1315            }
1316            Self::Defer(deref_clause) => deref_clause.to_tokens(s),
1317            Self::Collate { collation_name } => {
1318                s.append(TK_COLLATE, None)?;
1319                collation_name.to_tokens(s)
1320            }
1321            Self::ForeignKey {
1322                clause,
1323                deref_clause,
1324            } => {
1325                s.append(TK_REFERENCES, None)?;
1326                clause.to_tokens(s)?;
1327                if let Some(deref_clause) = deref_clause {
1328                    deref_clause.to_tokens(s)?;
1329                }
1330                Ok(())
1331            }
1332            Self::Generated { expr, typ } => {
1333                s.append(TK_AS, None)?;
1334                s.append(TK_LP, None)?;
1335                expr.to_tokens(s)?;
1336                s.append(TK_RP, None)?;
1337                if let Some(typ) = typ {
1338                    typ.to_tokens(s)?;
1339                }
1340                Ok(())
1341            }
1342        }
1343    }
1344}
1345
1346impl ToTokens for NamedTableConstraint {
1347    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1348        if let Some(ref name) = self.name {
1349            s.append(TK_CONSTRAINT, None)?;
1350            name.to_tokens(s)?;
1351        }
1352        self.constraint.to_tokens(s)
1353    }
1354}
1355
1356impl ToTokens for TableConstraint {
1357    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1358        match self {
1359            Self::PrimaryKey {
1360                columns,
1361                auto_increment,
1362                conflict_clause,
1363            } => {
1364                s.append(TK_PRIMARY, None)?;
1365                s.append(TK_KEY, None)?;
1366                s.append(TK_LP, None)?;
1367                comma(columns, s)?;
1368                if *auto_increment {
1369                    s.append(TK_AUTOINCR, None)?;
1370                }
1371                s.append(TK_RP, None)?;
1372                if let Some(conflict_clause) = conflict_clause {
1373                    s.append(TK_ON, None)?;
1374                    s.append(TK_CONFLICT, None)?;
1375                    conflict_clause.to_tokens(s)?;
1376                }
1377                Ok(())
1378            }
1379            Self::Unique {
1380                columns,
1381                conflict_clause,
1382            } => {
1383                s.append(TK_UNIQUE, None)?;
1384                s.append(TK_LP, None)?;
1385                comma(columns, s)?;
1386                s.append(TK_RP, None)?;
1387                if let Some(conflict_clause) = conflict_clause {
1388                    s.append(TK_ON, None)?;
1389                    s.append(TK_CONFLICT, None)?;
1390                    conflict_clause.to_tokens(s)?;
1391                }
1392                Ok(())
1393            }
1394            Self::Check(expr) => {
1395                s.append(TK_CHECK, None)?;
1396                s.append(TK_LP, None)?;
1397                expr.to_tokens(s)?;
1398                s.append(TK_RP, None)
1399            }
1400            Self::ForeignKey {
1401                columns,
1402                clause,
1403                deref_clause,
1404            } => {
1405                s.append(TK_FOREIGN, None)?;
1406                s.append(TK_KEY, None)?;
1407                s.append(TK_LP, None)?;
1408                comma(columns, s)?;
1409                s.append(TK_RP, None)?;
1410                s.append(TK_REFERENCES, None)?;
1411                clause.to_tokens(s)?;
1412                if let Some(deref_clause) = deref_clause {
1413                    deref_clause.to_tokens(s)?;
1414                }
1415                Ok(())
1416            }
1417        }
1418    }
1419}
1420
1421impl ToTokens for SortOrder {
1422    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1423        s.append(
1424            match self {
1425                Self::Asc => TK_ASC,
1426                Self::Desc => TK_DESC,
1427            },
1428            None,
1429        )
1430    }
1431}
1432
1433impl ToTokens for NullsOrder {
1434    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1435        s.append(TK_NULLS, None)?;
1436        s.append(
1437            match self {
1438                Self::First => TK_FIRST,
1439                Self::Last => TK_LAST,
1440            },
1441            None,
1442        )
1443    }
1444}
1445
1446impl ToTokens for ForeignKeyClause {
1447    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1448        self.tbl_name.to_tokens(s)?;
1449        if let Some(ref columns) = self.columns {
1450            s.append(TK_LP, None)?;
1451            comma(columns, s)?;
1452            s.append(TK_RP, None)?;
1453        }
1454        for arg in &self.args {
1455            arg.to_tokens(s)?;
1456        }
1457        Ok(())
1458    }
1459}
1460
1461impl ToTokens for RefArg {
1462    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1463        match self {
1464            Self::OnDelete(ref action) => {
1465                s.append(TK_ON, None)?;
1466                s.append(TK_DELETE, None)?;
1467                action.to_tokens(s)
1468            }
1469            Self::OnInsert(ref action) => {
1470                s.append(TK_ON, None)?;
1471                s.append(TK_INSERT, None)?;
1472                action.to_tokens(s)
1473            }
1474            Self::OnUpdate(ref action) => {
1475                s.append(TK_ON, None)?;
1476                s.append(TK_UPDATE, None)?;
1477                action.to_tokens(s)
1478            }
1479            Self::Match(ref name) => {
1480                s.append(TK_MATCH, None)?;
1481                name.to_tokens(s)
1482            }
1483        }
1484    }
1485}
1486
1487impl ToTokens for RefAct {
1488    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1489        match self {
1490            Self::SetNull => {
1491                s.append(TK_SET, None)?;
1492                s.append(TK_NULL, None)
1493            }
1494            Self::SetDefault => {
1495                s.append(TK_SET, None)?;
1496                s.append(TK_DEFAULT, None)
1497            }
1498            Self::Cascade => s.append(TK_CASCADE, None),
1499            Self::Restrict => s.append(TK_RESTRICT, None),
1500            Self::NoAction => {
1501                s.append(TK_NO, None)?;
1502                s.append(TK_ACTION, None)
1503            }
1504        }
1505    }
1506}
1507
1508impl ToTokens for DeferSubclause {
1509    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1510        if !self.deferrable {
1511            s.append(TK_NOT, None)?;
1512        }
1513        s.append(TK_DEFERRABLE, None)?;
1514        if let Some(init_deferred) = self.init_deferred {
1515            init_deferred.to_tokens(s)?;
1516        }
1517        Ok(())
1518    }
1519}
1520
1521impl ToTokens for InitDeferredPred {
1522    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1523        s.append(TK_INITIALLY, None)?;
1524        s.append(
1525            match self {
1526                Self::InitiallyDeferred => TK_DEFERRED,
1527                Self::InitiallyImmediate => TK_IMMEDIATE,
1528            },
1529            None,
1530        )
1531    }
1532}
1533
1534impl ToTokens for IndexedColumn {
1535    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1536        self.col_name.to_tokens(s)?;
1537        if let Some(ref collation_name) = self.collation_name {
1538            s.append(TK_COLLATE, None)?;
1539            collation_name.to_tokens(s)?;
1540        }
1541        if let Some(order) = self.order {
1542            order.to_tokens(s)?;
1543        }
1544        Ok(())
1545    }
1546}
1547
1548impl ToTokens for Indexed {
1549    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1550        match self {
1551            Self::IndexedBy(ref name) => {
1552                s.append(TK_INDEXED, None)?;
1553                s.append(TK_BY, None)?;
1554                name.to_tokens(s)
1555            }
1556            Self::NotIndexed => {
1557                s.append(TK_NOT, None)?;
1558                s.append(TK_INDEXED, None)
1559            }
1560        }
1561    }
1562}
1563
1564impl ToTokens for SortedColumn {
1565    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1566        self.expr.to_tokens(s)?;
1567        if let Some(ref order) = self.order {
1568            order.to_tokens(s)?;
1569        }
1570        if let Some(ref nulls) = self.nulls {
1571            nulls.to_tokens(s)?;
1572        }
1573        Ok(())
1574    }
1575}
1576
1577impl ToTokens for Limit {
1578    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1579        s.append(TK_LIMIT, None)?;
1580        self.expr.to_tokens(s)?;
1581        if let Some(ref offset) = self.offset {
1582            s.append(TK_OFFSET, None)?;
1583            offset.to_tokens(s)?;
1584        }
1585        Ok(())
1586    }
1587}
1588
1589impl ToTokens for InsertBody {
1590    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1591        match self {
1592            Self::Select(select, upsert) => {
1593                select.to_tokens(s)?;
1594                if let Some(upsert) = upsert {
1595                    upsert.to_tokens(s)?;
1596                }
1597                Ok(())
1598            }
1599            Self::DefaultValues => {
1600                s.append(TK_DEFAULT, None)?;
1601                s.append(TK_VALUES, None)
1602            }
1603        }
1604    }
1605}
1606
1607impl ToTokens for Set {
1608    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1609        if self.col_names.len() == 1 {
1610            comma(self.col_names.deref(), s)?;
1611        } else {
1612            s.append(TK_LP, None)?;
1613            comma(self.col_names.deref(), s)?;
1614            s.append(TK_RP, None)?;
1615        }
1616        s.append(TK_EQ, None)?;
1617        self.expr.to_tokens(s)
1618    }
1619}
1620
1621impl ToTokens for PragmaBody {
1622    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1623        match self {
1624            Self::Equals(value) => {
1625                s.append(TK_EQ, None)?;
1626                value.to_tokens(s)
1627            }
1628            Self::Call(value) => {
1629                s.append(TK_LP, None)?;
1630                value.to_tokens(s)?;
1631                s.append(TK_RP, None)
1632            }
1633        }
1634    }
1635}
1636
1637impl ToTokens for TriggerTime {
1638    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1639        match self {
1640            Self::Before => s.append(TK_BEFORE, None),
1641            Self::After => s.append(TK_AFTER, None),
1642            Self::InsteadOf => {
1643                s.append(TK_INSTEAD, None)?;
1644                s.append(TK_OF, None)
1645            }
1646        }
1647    }
1648}
1649
1650impl ToTokens for TriggerEvent {
1651    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1652        match self {
1653            Self::Delete => s.append(TK_DELETE, None),
1654            Self::Insert => s.append(TK_INSERT, None),
1655            Self::Update => s.append(TK_UPDATE, None),
1656            Self::UpdateOf(ref col_names) => {
1657                s.append(TK_UPDATE, None)?;
1658                s.append(TK_OF, None)?;
1659                comma(col_names.deref(), s)
1660            }
1661        }
1662    }
1663}
1664
1665impl ToTokens for TriggerCmd {
1666    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1667        match self {
1668            Self::Update {
1669                or_conflict,
1670                tbl_name,
1671                sets,
1672                from,
1673                where_clause,
1674            } => {
1675                s.append(TK_UPDATE, None)?;
1676                if let Some(or_conflict) = or_conflict {
1677                    s.append(TK_OR, None)?;
1678                    or_conflict.to_tokens(s)?;
1679                }
1680                tbl_name.to_tokens(s)?;
1681                s.append(TK_SET, None)?;
1682                comma(sets, s)?;
1683                if let Some(from) = from {
1684                    s.append(TK_FROM, None)?;
1685                    from.to_tokens(s)?;
1686                }
1687                if let Some(where_clause) = where_clause {
1688                    s.append(TK_WHERE, None)?;
1689                    where_clause.to_tokens(s)?;
1690                }
1691                Ok(())
1692            }
1693            Self::Insert {
1694                or_conflict,
1695                tbl_name,
1696                col_names,
1697                select,
1698                upsert,
1699            } => {
1700                if let Some(ResolveType::Replace) = or_conflict {
1701                    s.append(TK_REPLACE, None)?;
1702                } else {
1703                    s.append(TK_INSERT, None)?;
1704                    if let Some(or_conflict) = or_conflict {
1705                        s.append(TK_OR, None)?;
1706                        or_conflict.to_tokens(s)?;
1707                    }
1708                }
1709                s.append(TK_INTO, None)?;
1710                tbl_name.to_tokens(s)?;
1711                if let Some(col_names) = col_names {
1712                    s.append(TK_LP, None)?;
1713                    comma(col_names.deref(), s)?;
1714                    s.append(TK_RP, None)?;
1715                }
1716                select.to_tokens(s)?;
1717                if let Some(upsert) = upsert {
1718                    upsert.to_tokens(s)?;
1719                }
1720                Ok(())
1721            }
1722            Self::Delete {
1723                tbl_name,
1724                where_clause,
1725            } => {
1726                s.append(TK_DELETE, None)?;
1727                s.append(TK_FROM, None)?;
1728                tbl_name.to_tokens(s)?;
1729                if let Some(where_clause) = where_clause {
1730                    s.append(TK_WHERE, None)?;
1731                    where_clause.to_tokens(s)?;
1732                }
1733                Ok(())
1734            }
1735            Self::Select(select) => select.to_tokens(s),
1736        }
1737    }
1738}
1739
1740impl ToTokens for ResolveType {
1741    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1742        s.append(
1743            match self {
1744                Self::Rollback => TK_ROLLBACK,
1745                Self::Abort => TK_ABORT,
1746                Self::Fail => TK_FAIL,
1747                Self::Ignore => TK_IGNORE,
1748                Self::Replace => TK_REPLACE,
1749            },
1750            None,
1751        )
1752    }
1753}
1754
1755impl ToTokens for With {
1756    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1757        s.append(TK_WITH, None)?;
1758        if self.recursive {
1759            s.append(TK_RECURSIVE, None)?;
1760        }
1761        comma(&self.ctes, s)
1762    }
1763}
1764
1765impl ToTokens for CommonTableExpr {
1766    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1767        self.tbl_name.to_tokens(s)?;
1768        if let Some(ref columns) = self.columns {
1769            s.append(TK_LP, None)?;
1770            comma(columns, s)?;
1771            s.append(TK_RP, None)?;
1772        }
1773        s.append(TK_AS, None)?;
1774        match self.materialized {
1775            Materialized::Any => {}
1776            Materialized::Yes => {
1777                s.append(TK_MATERIALIZED, None)?;
1778            }
1779            Materialized::No => {
1780                s.append(TK_NOT, None)?;
1781                s.append(TK_MATERIALIZED, None)?;
1782            }
1783        };
1784        s.append(TK_LP, None)?;
1785        self.select.to_tokens(s)?;
1786        s.append(TK_RP, None)
1787    }
1788}
1789
1790impl ToTokens for Type {
1791    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1792        match self.size {
1793            None => s.append(TK_ID, Some(&self.name)),
1794            Some(ref size) => {
1795                s.append(TK_ID, Some(&self.name))?; // TODO check there is no forbidden chars
1796                s.append(TK_LP, None)?;
1797                size.to_tokens(s)?;
1798                s.append(TK_RP, None)
1799            }
1800        }
1801    }
1802}
1803
1804impl ToTokens for TypeSize {
1805    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1806        match self {
1807            Self::MaxSize(size) => size.to_tokens(s),
1808            Self::TypeSize(size1, size2) => {
1809                size1.to_tokens(s)?;
1810                s.append(TK_COMMA, None)?;
1811                size2.to_tokens(s)
1812            }
1813        }
1814    }
1815}
1816
1817impl ToTokens for TransactionType {
1818    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1819        s.append(
1820            match self {
1821                Self::Deferred => TK_DEFERRED,
1822                Self::Immediate => TK_IMMEDIATE,
1823                Self::Exclusive => TK_EXCLUSIVE,
1824            },
1825            None,
1826        )
1827    }
1828}
1829
1830impl ToTokens for Upsert {
1831    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1832        s.append(TK_ON, None)?;
1833        s.append(TK_CONFLICT, None)?;
1834        if let Some(ref index) = self.index {
1835            index.to_tokens(s)?;
1836        }
1837        self.do_clause.to_tokens(s)?;
1838        if let Some(ref next) = self.next {
1839            next.to_tokens(s)?;
1840        }
1841        Ok(())
1842    }
1843}
1844
1845impl ToTokens for UpsertIndex {
1846    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1847        s.append(TK_LP, None)?;
1848        comma(&self.targets, s)?;
1849        s.append(TK_RP, None)?;
1850        if let Some(ref where_clause) = self.where_clause {
1851            s.append(TK_WHERE, None)?;
1852            where_clause.to_tokens(s)?;
1853        }
1854        Ok(())
1855    }
1856}
1857
1858impl ToTokens for UpsertDo {
1859    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1860        match self {
1861            Self::Set { sets, where_clause } => {
1862                s.append(TK_DO, None)?;
1863                s.append(TK_UPDATE, None)?;
1864                s.append(TK_SET, None)?;
1865                comma(sets, s)?;
1866                if let Some(where_clause) = where_clause {
1867                    s.append(TK_WHERE, None)?;
1868                    where_clause.to_tokens(s)?;
1869                }
1870                Ok(())
1871            }
1872            Self::Nothing => {
1873                s.append(TK_DO, None)?;
1874                s.append(TK_NOTHING, None)
1875            }
1876        }
1877    }
1878}
1879
1880impl ToTokens for FunctionTail {
1881    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1882        if let Some(ref filter_clause) = self.filter_clause {
1883            s.append(TK_FILTER, None)?;
1884            s.append(TK_LP, None)?;
1885            s.append(TK_WHERE, None)?;
1886            filter_clause.to_tokens(s)?;
1887            s.append(TK_RP, None)?;
1888        }
1889        if let Some(ref over_clause) = self.over_clause {
1890            s.append(TK_OVER, None)?;
1891            over_clause.to_tokens(s)?;
1892        }
1893        Ok(())
1894    }
1895}
1896
1897impl ToTokens for Over {
1898    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1899        match self {
1900            Self::Window(ref window) => window.to_tokens(s),
1901            Self::Name(ref name) => name.to_tokens(s),
1902        }
1903    }
1904}
1905
1906impl ToTokens for WindowDef {
1907    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1908        self.name.to_tokens(s)?;
1909        s.append(TK_AS, None)?;
1910        self.window.to_tokens(s)
1911    }
1912}
1913
1914impl ToTokens for Window {
1915    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1916        s.append(TK_LP, None)?;
1917        if let Some(ref base) = self.base {
1918            base.to_tokens(s)?;
1919        }
1920        if let Some(ref partition_by) = self.partition_by {
1921            s.append(TK_PARTITION, None)?;
1922            s.append(TK_BY, None)?;
1923            comma(partition_by, s)?;
1924        }
1925        if let Some(ref order_by) = self.order_by {
1926            s.append(TK_ORDER, None)?;
1927            s.append(TK_BY, None)?;
1928            comma(order_by, s)?;
1929        }
1930        if let Some(ref frame_clause) = self.frame_clause {
1931            frame_clause.to_tokens(s)?;
1932        }
1933        s.append(TK_RP, None)
1934    }
1935}
1936
1937impl ToTokens for FrameClause {
1938    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1939        self.mode.to_tokens(s)?;
1940        if let Some(ref end) = self.end {
1941            s.append(TK_BETWEEN, None)?;
1942            self.start.to_tokens(s)?;
1943            s.append(TK_AND, None)?;
1944            end.to_tokens(s)?;
1945        } else {
1946            self.start.to_tokens(s)?;
1947        }
1948        if let Some(ref exclude) = self.exclude {
1949            s.append(TK_EXCLUDE, None)?;
1950            exclude.to_tokens(s)?;
1951        }
1952        Ok(())
1953    }
1954}
1955
1956impl ToTokens for FrameMode {
1957    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1958        s.append(
1959            match self {
1960                Self::Groups => TK_GROUPS,
1961                Self::Range => TK_RANGE,
1962                Self::Rows => TK_ROWS,
1963            },
1964            None,
1965        )
1966    }
1967}
1968
1969impl ToTokens for FrameBound {
1970    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1971        match self {
1972            Self::CurrentRow => {
1973                s.append(TK_CURRENT, None)?;
1974                s.append(TK_ROW, None)
1975            }
1976            Self::Following(value) => {
1977                value.to_tokens(s)?;
1978                s.append(TK_FOLLOWING, None)
1979            }
1980            Self::Preceding(value) => {
1981                value.to_tokens(s)?;
1982                s.append(TK_PRECEDING, None)
1983            }
1984            Self::UnboundedFollowing => {
1985                s.append(TK_UNBOUNDED, None)?;
1986                s.append(TK_FOLLOWING, None)
1987            }
1988            Self::UnboundedPreceding => {
1989                s.append(TK_UNBOUNDED, None)?;
1990                s.append(TK_PRECEDING, None)
1991            }
1992        }
1993    }
1994}
1995
1996impl ToTokens for FrameExclude {
1997    fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error> {
1998        match self {
1999            Self::NoOthers => {
2000                s.append(TK_NO, None)?;
2001                s.append(TK_OTHERS, None)
2002            }
2003            Self::CurrentRow => {
2004                s.append(TK_CURRENT, None)?;
2005                s.append(TK_ROW, None)
2006            }
2007            Self::Group => s.append(TK_GROUP, None),
2008            Self::Ties => s.append(TK_TIES, None),
2009        }
2010    }
2011}
2012
2013fn comma<I, S: TokenStream>(items: I, s: &mut S) -> Result<(), S::Error>
2014where
2015    I: IntoIterator,
2016    I::Item: ToTokens,
2017{
2018    let iter = items.into_iter();
2019    for (i, item) in iter.enumerate() {
2020        if i != 0 {
2021            s.append(TK_COMMA, None)?;
2022        }
2023        item.to_tokens(s)?;
2024    }
2025    Ok(())
2026}
2027
2028// TK_ID: [...] / `...` / "..." / some keywords / non keywords
2029fn double_quote<S: TokenStream>(name: &str, s: &mut S) -> Result<(), S::Error> {
2030    if name.is_empty() {
2031        return s.append(TK_ID, Some("\"\""));
2032    }
2033    if is_identifier(name) {
2034        // identifier must be quoted when they match a keyword...
2035        /*if is_keyword(name) {
2036            f.write_char('`')?;
2037            f.write_str(name)?;
2038            return f.write_char('`');
2039        }*/
2040        return s.append(TK_ID, Some(name));
2041    }
2042    /*f.write_char('"')?;
2043    for c in name.chars() {
2044        if c == '"' {
2045            f.write_char(c)?;
2046        }
2047        f.write_char(c)?;
2048    }
2049    f.write_char('"')*/
2050    s.append(TK_ID, Some(name))
2051}
sqlite3_parser/parser/ast/fmt.rs

sqlite3_parser/parser/ast/
fmt.rs
