wing_sqlparser/
parser.rs

1// Licensed under the Apache License, Version 2.0 (the "License");
2// you may not use this file except in compliance with the License.
3// You may obtain a copy of the License at
4//
5// http://www.apache.org/licenses/LICENSE-2.0
6//
7// Unless required by applicable law or agreed to in writing, software
8// distributed under the License is distributed on an "AS IS" BASIS,
9// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
10// See the License for the specific language governing permissions and
11// limitations under the License.
12
13//! SQL Parser
14
15#[cfg(not(feature = "std"))]
16use alloc::{
17    boxed::Box,
18    format,
19    string::{String, ToString},
20    vec,
21    vec::Vec,
22};
23use core::fmt;
24
25use log::debug;
26
27use crate::ast::*;
28use crate::dialect::*;
29use crate::keywords::{self, Keyword};
30use crate::tokenizer::*;
31
32#[derive(Debug, Clone, PartialEq)]
33pub enum ParserError {
34    TokenizerError(String),
35    ParserError(String),
36}
37
38// Use `Parser::expected` instead, if possible
39macro_rules! parser_err {
40    ($MSG:expr) => {
41        Err(ParserError::ParserError($MSG.to_string()))
42    };
43}
44
45// Returns a successful result if the optional expression is some
46macro_rules! return_ok_if_some {
47    ($e:expr) => {{
48        if let Some(v) = $e {
49            return Ok(v);
50        }
51    }};
52}
53
54#[derive(PartialEq)]
55pub enum IsOptional {
56    Optional,
57    Mandatory,
58}
59
60use IsOptional::*;
61
62pub enum IsLateral {
63    Lateral,
64    NotLateral,
65}
66
67use IsLateral::*;
68
69pub enum WildcardExpr {
70    Expr(Expr),
71    QualifiedWildcard(ObjectName),
72    Wildcard,
73}
74
75impl From<WildcardExpr> for FunctionArgExpr {
76    fn from(wildcard_expr: WildcardExpr) -> Self {
77        match wildcard_expr {
78            WildcardExpr::Expr(expr) => Self::Expr(expr),
79            WildcardExpr::QualifiedWildcard(prefix) => Self::QualifiedWildcard(prefix),
80            WildcardExpr::Wildcard => Self::Wildcard,
81        }
82    }
83}
84
85impl From<TokenizerError> for ParserError {
86    fn from(e: TokenizerError) -> Self {
87        ParserError::TokenizerError(e.to_string())
88    }
89}
90
91impl fmt::Display for ParserError {
92    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
93        write!(
94            f,
95            "sql parser error: {}",
96            match self {
97                ParserError::TokenizerError(s) => s,
98                ParserError::ParserError(s) => s,
99            }
100        )
101    }
102}
103
104#[cfg(feature = "std")]
105impl std::error::Error for ParserError {}
106
107pub struct Parser<'a> {
108    tokens: Vec<Token>,
109    /// The index of the first unprocessed token in `self.tokens`
110    index: usize,
111    dialect: &'a dyn Dialect,
112}
113
114impl<'a> Parser<'a> {
115    /// Parse the specified tokens
116    pub fn new(tokens: Vec<Token>, dialect: &'a dyn Dialect) -> Self {
117        Parser {
118            tokens,
119            index: 0,
120            dialect,
121        }
122    }
123
124    /// Parse a SQL statement and produce an Abstract Syntax Tree (AST)
125    pub fn parse_sql(dialect: &dyn Dialect, sql: &str) -> Result<Vec<Statement>, ParserError> {
126        let mut tokenizer = Tokenizer::new(dialect, sql);
127        let tokens = tokenizer.tokenize()?;
128        let mut parser = Parser::new(tokens, dialect);
129        let mut stmts = Vec::new();
130        let mut expecting_statement_delimiter = false;
131        debug!("Parsing sql '{}'...", sql);
132        loop {
133            // ignore empty statements (between successive statement delimiters)
134            while parser.consume_token(&Token::SemiColon) {
135                expecting_statement_delimiter = false;
136            }
137            if parser.peek_token() == Token::EOF {
138                break;
139            }
140            if expecting_statement_delimiter {
141                return parser.expected("end of statement", parser.peek_token());
142            }
143
144            let statement = parser.parse_statement()?;
145            stmts.push(statement);
146            expecting_statement_delimiter = true;
147        }
148        Ok(stmts)
149    }
150
151    /// Parse a single top-level statement (such as SELECT, INSERT, CREATE, etc.),
152    /// stopping before the statement separator, if any.
153    pub fn parse_statement(&mut self) -> Result<Statement, ParserError> {
154        match self.next_token() {
155            Token::Word(w) => match w.keyword {
156                Keyword::DESCRIBE => Ok(self.parse_explain(true)?),
157                Keyword::EXPLAIN => Ok(self.parse_explain(false)?),
158                Keyword::ANALYZE => Ok(self.parse_analyze()?),
159                Keyword::SELECT | Keyword::WITH | Keyword::VALUES => {
160                    self.prev_token();
161                    Ok(Statement::Query(Box::new(self.parse_query()?)))
162                }
163                Keyword::TRUNCATE => Ok(self.parse_truncate()?),
164                Keyword::MSCK => Ok(self.parse_msck()?),
165                Keyword::CREATE => Ok(self.parse_create()?),
166                Keyword::DROP => Ok(self.parse_drop()?),
167                Keyword::DELETE => Ok(self.parse_delete()?),
168                Keyword::INSERT => Ok(self.parse_insert()?),
169                Keyword::UPDATE => Ok(self.parse_update()?),
170                Keyword::ALTER => Ok(self.parse_alter()?),
171                Keyword::COPY => Ok(self.parse_copy()?),
172                Keyword::SET => Ok(self.parse_set()?),
173                Keyword::SHOW => Ok(self.parse_show()?),
174                Keyword::GRANT => Ok(self.parse_grant()?),
175                Keyword::REVOKE => Ok(self.parse_revoke()?),
176                Keyword::START => Ok(self.parse_start_transaction()?),
177                // `BEGIN` is a nonstandard but common alias for the
178                // standard `START TRANSACTION` statement. It is supported
179                // by at least PostgreSQL and MySQL.
180                Keyword::BEGIN => Ok(self.parse_begin()?),
181                Keyword::COMMIT => Ok(self.parse_commit()?),
182                Keyword::ROLLBACK => Ok(self.parse_rollback()?),
183                Keyword::ASSERT => Ok(self.parse_assert()?),
184                // `PREPARE`, `EXECUTE` and `DEALLOCATE` are Postgres-specific
185                // syntaxes. They are used for Postgres prepared statement.
186                Keyword::DEALLOCATE => Ok(self.parse_deallocate()?),
187                Keyword::EXECUTE => Ok(self.parse_execute()?),
188                Keyword::PREPARE => Ok(self.parse_prepare()?),
189                Keyword::REPLACE if dialect_of!(self is SQLiteDialect ) => {
190                    self.prev_token();
191                    Ok(self.parse_insert()?)
192                }
193                Keyword::COMMENT if dialect_of!(self is PostgreSqlDialect) => {
194                    Ok(self.parse_comment()?)
195                }
196                _ => self.expected("an SQL statement", Token::Word(w)),
197            },
198            Token::LParen => {
199                self.prev_token();
200                Ok(Statement::Query(Box::new(self.parse_query()?)))
201            }
202            unexpected => self.expected("an SQL statement", unexpected),
203        }
204    }
205
206    pub fn parse_msck(&mut self) -> Result<Statement, ParserError> {
207        let repair = self.parse_keyword(Keyword::REPAIR);
208        self.expect_keyword(Keyword::TABLE)?;
209        let table_name = self.parse_object_name()?;
210        let partition_action = self
211            .maybe_parse(|parser| {
212                let pa = match parser.parse_one_of_keywords(&[
213                    Keyword::ADD,
214                    Keyword::DROP,
215                    Keyword::SYNC,
216                ]) {
217                    Some(Keyword::ADD) => Some(AddDropSync::ADD),
218                    Some(Keyword::DROP) => Some(AddDropSync::DROP),
219                    Some(Keyword::SYNC) => Some(AddDropSync::SYNC),
220                    _ => None,
221                };
222                parser.expect_keyword(Keyword::PARTITIONS)?;
223                Ok(pa)
224            })
225            .unwrap_or_default();
226        Ok(Statement::Msck {
227            repair,
228            table_name,
229            partition_action,
230        })
231    }
232
233    pub fn parse_truncate(&mut self) -> Result<Statement, ParserError> {
234        self.expect_keyword(Keyword::TABLE)?;
235        let table_name = self.parse_object_name()?;
236        let mut partitions = None;
237        if self.parse_keyword(Keyword::PARTITION) {
238            self.expect_token(&Token::LParen)?;
239            partitions = Some(self.parse_comma_separated(Parser::parse_expr)?);
240            self.expect_token(&Token::RParen)?;
241        }
242        Ok(Statement::Truncate {
243            table_name,
244            partitions,
245        })
246    }
247
248    pub fn parse_analyze(&mut self) -> Result<Statement, ParserError> {
249        self.expect_keyword(Keyword::TABLE)?;
250        let table_name = self.parse_object_name()?;
251        let mut for_columns = false;
252        let mut cache_metadata = false;
253        let mut noscan = false;
254        let mut partitions = None;
255        let mut compute_statistics = false;
256        let mut columns = vec![];
257        loop {
258            match self.parse_one_of_keywords(&[
259                Keyword::PARTITION,
260                Keyword::FOR,
261                Keyword::CACHE,
262                Keyword::NOSCAN,
263                Keyword::COMPUTE,
264            ]) {
265                Some(Keyword::PARTITION) => {
266                    self.expect_token(&Token::LParen)?;
267                    partitions = Some(self.parse_comma_separated(Parser::parse_expr)?);
268                    self.expect_token(&Token::RParen)?;
269                }
270                Some(Keyword::NOSCAN) => noscan = true,
271                Some(Keyword::FOR) => {
272                    self.expect_keyword(Keyword::COLUMNS)?;
273
274                    columns = self
275                        .maybe_parse(|parser| {
276                            parser.parse_comma_separated(Parser::parse_identifier)
277                        })
278                        .unwrap_or_default();
279                    for_columns = true
280                }
281                Some(Keyword::CACHE) => {
282                    self.expect_keyword(Keyword::METADATA)?;
283                    cache_metadata = true
284                }
285                Some(Keyword::COMPUTE) => {
286                    self.expect_keyword(Keyword::STATISTICS)?;
287                    compute_statistics = true
288                }
289                _ => break,
290            }
291        }
292
293        Ok(Statement::Analyze {
294            table_name,
295            for_columns,
296            columns,
297            partitions,
298            cache_metadata,
299            noscan,
300            compute_statistics,
301        })
302    }
303
304    /// Parse a new expression including wildcard & qualified wildcard
305    pub fn parse_wildcard_expr(&mut self) -> Result<WildcardExpr, ParserError> {
306        let index = self.index;
307
308        match self.next_token() {
309            Token::Word(w) if self.peek_token() == Token::Period => {
310                let mut id_parts: Vec<Ident> = vec![w.to_ident()];
311
312                while self.consume_token(&Token::Period) {
313                    match self.next_token() {
314                        Token::Word(w) => id_parts.push(w.to_ident()),
315                        Token::Mul => {
316                            return Ok(WildcardExpr::QualifiedWildcard(ObjectName(id_parts)));
317                        }
318                        unexpected => {
319                            return self.expected("an identifier or a '*' after '.'", unexpected);
320                        }
321                    }
322                }
323            }
324            Token::Mul => {
325                return Ok(WildcardExpr::Wildcard);
326            }
327            _ => (),
328        };
329
330        self.index = index;
331        self.parse_expr().map(WildcardExpr::Expr)
332    }
333
334    /// Parse a new expression
335    pub fn parse_expr(&mut self) -> Result<Expr, ParserError> {
336        self.parse_subexpr(0)
337    }
338
339    /// Parse tokens until the precedence changes
340    pub fn parse_subexpr(&mut self, precedence: u8) -> Result<Expr, ParserError> {
341        debug!("parsing expr");
342        let mut expr = self.parse_prefix()?;
343        debug!("prefix: {:?}", expr);
344        loop {
345            let next_precedence = self.get_next_precedence()?;
346            debug!("next precedence: {:?}", next_precedence);
347
348            if precedence >= next_precedence {
349                break;
350            }
351
352            expr = self.parse_infix(expr, next_precedence)?;
353        }
354        Ok(expr)
355    }
356
357    pub fn parse_assert(&mut self) -> Result<Statement, ParserError> {
358        let condition = self.parse_expr()?;
359        let message = if self.parse_keyword(Keyword::AS) {
360            Some(self.parse_expr()?)
361        } else {
362            None
363        };
364
365        Ok(Statement::Assert { condition, message })
366    }
367
368    /// Parse an expression prefix
369    pub fn parse_prefix(&mut self) -> Result<Expr, ParserError> {
370        // PostgreSQL allows any string literal to be preceded by a type name, indicating that the
371        // string literal represents a literal of that type. Some examples:
372        //
373        //      DATE '2020-05-20'
374        //      TIMESTAMP WITH TIME ZONE '2020-05-20 7:43:54'
375        //      BOOL 'true'
376        //
377        // The first two are standard SQL, while the latter is a PostgreSQL extension. Complicating
378        // matters is the fact that INTERVAL string literals may optionally be followed by special
379        // keywords, e.g.:
380        //
381        //      INTERVAL '7' DAY
382        //
383        // Note also that naively `SELECT date` looks like a syntax error because the `date` type
384        // name is not followed by a string literal, but in fact in PostgreSQL it is a valid
385        // expression that should parse as the column name "date".
386        return_ok_if_some!(self.maybe_parse(|parser| {
387            match parser.parse_data_type()? {
388                DataType::Interval => parser.parse_literal_interval(),
389                // PostgreSQL allows almost any identifier to be used as custom data type name,
390                // and we support that in `parse_data_type()`. But unlike Postgres we don't
391                // have a list of globally reserved keywords (since they vary across dialects),
392                // so given `NOT 'a' LIKE 'b'`, we'd accept `NOT` as a possible custom data type
393                // name, resulting in `NOT 'a'` being recognized as a `TypedString` instead of
394                // an unary negation `NOT ('a' LIKE 'b')`. To solve this, we don't accept the
395                // `type 'string'` syntax for the custom data types at all.
396                DataType::Custom(..) => parser_err!("dummy"),
397                data_type => Ok(Expr::TypedString {
398                    data_type,
399                    value: parser.parse_literal_string()?,
400                }),
401            }
402        }));
403
404        let expr = match self.next_token() {
405            Token::Word(w) => match w.keyword {
406                Keyword::TRUE | Keyword::FALSE | Keyword::NULL => {
407                    self.prev_token();
408                    Ok(Expr::Value(self.parse_value()?))
409                }
410                Keyword::CASE => self.parse_case_expr(),
411                Keyword::CAST => self.parse_cast_expr(),
412                Keyword::TRY_CAST => self.parse_try_cast_expr(),
413                Keyword::EXISTS => self.parse_exists_expr(),
414                Keyword::EXTRACT => self.parse_extract_expr(),
415                Keyword::SUBSTRING => self.parse_substring_expr(),
416                Keyword::TRIM => self.parse_trim_expr(),
417                Keyword::INTERVAL => self.parse_literal_interval(),
418                Keyword::LISTAGG => self.parse_listagg_expr(),
419                Keyword::NOT => Ok(Expr::UnaryOp {
420                    op: UnaryOperator::Not,
421                    expr: Box::new(self.parse_subexpr(Self::UNARY_NOT_PREC)?),
422                }),
423                // Here `w` is a word, check if it's a part of a multi-part
424                // identifier, a function call, or a simple identifier:
425                _ => match self.peek_token() {
426                    Token::LParen | Token::Period => {
427                        let mut id_parts: Vec<Ident> = vec![w.to_ident()];
428                        while self.consume_token(&Token::Period) {
429                            match self.next_token() {
430                                Token::Word(w) => id_parts.push(w.to_ident()),
431                                unexpected => {
432                                    return self
433                                        .expected("an identifier or a '*' after '.'", unexpected);
434                                }
435                            }
436                        }
437
438                        if self.consume_token(&Token::LParen) {
439                            self.prev_token();
440                            self.parse_function(ObjectName(id_parts))
441                        } else {
442                            Ok(Expr::CompoundIdentifier(id_parts))
443                        }
444                    }
445                    _ => Ok(Expr::Identifier(w.to_ident())),
446                },
447            }, // End of Token::Word
448            tok @ Token::Minus | tok @ Token::Plus => {
449                let op = if tok == Token::Plus {
450                    UnaryOperator::Plus
451                } else {
452                    UnaryOperator::Minus
453                };
454                Ok(Expr::UnaryOp {
455                    op,
456                    expr: Box::new(self.parse_subexpr(Self::PLUS_MINUS_PREC)?),
457                })
458            }
459            tok @ Token::DoubleExclamationMark
460            | tok @ Token::PGSquareRoot
461            | tok @ Token::PGCubeRoot
462            | tok @ Token::AtSign
463            | tok @ Token::Tilde
464                if dialect_of!(self is PostgreSqlDialect) =>
465            {
466                let op = match tok {
467                    Token::DoubleExclamationMark => UnaryOperator::PGPrefixFactorial,
468                    Token::PGSquareRoot => UnaryOperator::PGSquareRoot,
469                    Token::PGCubeRoot => UnaryOperator::PGCubeRoot,
470                    Token::AtSign => UnaryOperator::PGAbs,
471                    Token::Tilde => UnaryOperator::PGBitwiseNot,
472                    _ => unreachable!(),
473                };
474                Ok(Expr::UnaryOp {
475                    op,
476                    expr: Box::new(self.parse_subexpr(Self::PLUS_MINUS_PREC)?),
477                })
478            }
479            Token::Number(_, _)
480            | Token::SingleQuotedString(_)
481            | Token::NationalStringLiteral(_)
482            | Token::HexStringLiteral(_) => {
483                self.prev_token();
484                Ok(Expr::Value(self.parse_value()?))
485            }
486
487            Token::LParen => {
488                let expr =
489                    if self.parse_keyword(Keyword::SELECT) || self.parse_keyword(Keyword::WITH) {
490                        self.prev_token();
491                        Expr::Subquery(Box::new(self.parse_query()?))
492                    } else {
493                        Expr::Nested(Box::new(self.parse_expr()?))
494                    };
495                self.expect_token(&Token::RParen)?;
496                Ok(expr)
497            }
498            Token::Placeholder(_) => {
499                self.prev_token();
500                Ok(Expr::Value(self.parse_value()?))
501            }
502            unexpected => self.expected("an expression:", unexpected),
503        }?;
504
505        if self.parse_keyword(Keyword::COLLATE) {
506            Ok(Expr::Collate {
507                expr: Box::new(expr),
508                collation: self.parse_object_name()?,
509            })
510        } else {
511            Ok(expr)
512        }
513    }
514
515    pub fn parse_function(&mut self, name: ObjectName) -> Result<Expr, ParserError> {
516        self.expect_token(&Token::LParen)?;
517        let distinct = self.parse_all_or_distinct()?;
518        let args = self.parse_optional_args()?;
519        let over = if self.parse_keyword(Keyword::OVER) {
520            // TBD: support window names (`OVER mywin`) in place of inline specification
521            self.expect_token(&Token::LParen)?;
522            let partition_by = if self.parse_keywords(&[Keyword::PARTITION, Keyword::BY]) {
523                // a list of possibly-qualified column names
524                self.parse_comma_separated(Parser::parse_expr)?
525            } else {
526                vec![]
527            };
528            let order_by = if self.parse_keywords(&[Keyword::ORDER, Keyword::BY]) {
529                self.parse_comma_separated(Parser::parse_order_by_expr)?
530            } else {
531                vec![]
532            };
533            let window_frame = if !self.consume_token(&Token::RParen) {
534                let window_frame = self.parse_window_frame()?;
535                self.expect_token(&Token::RParen)?;
536                Some(window_frame)
537            } else {
538                None
539            };
540
541            Some(WindowSpec {
542                partition_by,
543                order_by,
544                window_frame,
545            })
546        } else {
547            None
548        };
549
550        Ok(Expr::Function(Function {
551            name,
552            args,
553            over,
554            distinct,
555        }))
556    }
557
558    pub fn parse_window_frame_units(&mut self) -> Result<WindowFrameUnits, ParserError> {
559        match self.next_token() {
560            Token::Word(w) => match w.keyword {
561                Keyword::ROWS => Ok(WindowFrameUnits::Rows),
562                Keyword::RANGE => Ok(WindowFrameUnits::Range),
563                Keyword::GROUPS => Ok(WindowFrameUnits::Groups),
564                _ => self.expected("ROWS, RANGE, GROUPS", Token::Word(w))?,
565            },
566            unexpected => self.expected("ROWS, RANGE, GROUPS", unexpected),
567        }
568    }
569
570    pub fn parse_window_frame(&mut self) -> Result<WindowFrame, ParserError> {
571        let units = self.parse_window_frame_units()?;
572        let (start_bound, end_bound) = if self.parse_keyword(Keyword::BETWEEN) {
573            let start_bound = self.parse_window_frame_bound()?;
574            self.expect_keyword(Keyword::AND)?;
575            let end_bound = Some(self.parse_window_frame_bound()?);
576            (start_bound, end_bound)
577        } else {
578            (self.parse_window_frame_bound()?, None)
579        };
580        Ok(WindowFrame {
581            units,
582            start_bound,
583            end_bound,
584        })
585    }
586
587    /// Parse `CURRENT ROW` or `{ <positive number> | UNBOUNDED } { PRECEDING | FOLLOWING }`
588    pub fn parse_window_frame_bound(&mut self) -> Result<WindowFrameBound, ParserError> {
589        if self.parse_keywords(&[Keyword::CURRENT, Keyword::ROW]) {
590            Ok(WindowFrameBound::CurrentRow)
591        } else {
592            let rows = if self.parse_keyword(Keyword::UNBOUNDED) {
593                None
594            } else {
595                Some(self.parse_literal_uint()?)
596            };
597            if self.parse_keyword(Keyword::PRECEDING) {
598                Ok(WindowFrameBound::Preceding(rows))
599            } else if self.parse_keyword(Keyword::FOLLOWING) {
600                Ok(WindowFrameBound::Following(rows))
601            } else {
602                self.expected("PRECEDING or FOLLOWING", self.peek_token())
603            }
604        }
605    }
606
607    /// parse a group by expr. a group by expr can be one of group sets, roll up, cube, or simple
608    /// expr.
609    fn parse_group_by_expr(&mut self) -> Result<Expr, ParserError> {
610        if dialect_of!(self is PostgreSqlDialect) {
611            if self.parse_keywords(&[Keyword::GROUPING, Keyword::SETS]) {
612                self.expect_token(&Token::LParen)?;
613                let result = self.parse_comma_separated(|p| p.parse_tuple(false, true))?;
614                self.expect_token(&Token::RParen)?;
615                Ok(Expr::GroupingSets(result))
616            } else if self.parse_keyword(Keyword::CUBE) {
617                self.expect_token(&Token::LParen)?;
618                let result = self.parse_comma_separated(|p| p.parse_tuple(true, true))?;
619                self.expect_token(&Token::RParen)?;
620                Ok(Expr::Cube(result))
621            } else if self.parse_keyword(Keyword::ROLLUP) {
622                self.expect_token(&Token::LParen)?;
623                let result = self.parse_comma_separated(|p| p.parse_tuple(true, true))?;
624                self.expect_token(&Token::RParen)?;
625                Ok(Expr::Rollup(result))
626            } else {
627                self.parse_expr()
628            }
629        } else {
630            // TODO parse rollup for other dialects
631            self.parse_expr()
632        }
633    }
634
635    /// parse a tuple with `(` and `)`.
636    /// If `lift_singleton` is true, then a singleton tuple is lifted to a tuple of length 1, otherwise it will fail.
637    /// If `allow_empty` is true, then an empty tuple is allowed.
638    fn parse_tuple(
639        &mut self,
640        lift_singleton: bool,
641        allow_empty: bool,
642    ) -> Result<Vec<Expr>, ParserError> {
643        if lift_singleton {
644            if self.consume_token(&Token::LParen) {
645                let result = if allow_empty && self.consume_token(&Token::RParen) {
646                    vec![]
647                } else {
648                    let result = self.parse_comma_separated(Parser::parse_expr)?;
649                    self.expect_token(&Token::RParen)?;
650                    result
651                };
652                Ok(result)
653            } else {
654                Ok(vec![self.parse_expr()?])
655            }
656        } else {
657            self.expect_token(&Token::LParen)?;
658            let result = if allow_empty && self.consume_token(&Token::RParen) {
659                vec![]
660            } else {
661                let result = self.parse_comma_separated(Parser::parse_expr)?;
662                self.expect_token(&Token::RParen)?;
663                result
664            };
665            Ok(result)
666        }
667    }
668
669    pub fn parse_case_expr(&mut self) -> Result<Expr, ParserError> {
670        let mut operand = None;
671        if !self.parse_keyword(Keyword::WHEN) {
672            operand = Some(Box::new(self.parse_expr()?));
673            self.expect_keyword(Keyword::WHEN)?;
674        }
675        let mut conditions = vec![];
676        let mut results = vec![];
677        loop {
678            conditions.push(self.parse_expr()?);
679            self.expect_keyword(Keyword::THEN)?;
680            results.push(self.parse_expr()?);
681            if !self.parse_keyword(Keyword::WHEN) {
682                break;
683            }
684        }
685        let else_result = if self.parse_keyword(Keyword::ELSE) {
686            Some(Box::new(self.parse_expr()?))
687        } else {
688            None
689        };
690        self.expect_keyword(Keyword::END)?;
691        Ok(Expr::Case {
692            operand,
693            conditions,
694            results,
695            else_result,
696        })
697    }
698
699    /// Parse a SQL CAST function e.g. `CAST(expr AS FLOAT)`
700    pub fn parse_cast_expr(&mut self) -> Result<Expr, ParserError> {
701        self.expect_token(&Token::LParen)?;
702        let expr = self.parse_expr()?;
703        self.expect_keyword(Keyword::AS)?;
704        let data_type = self.parse_data_type()?;
705        self.expect_token(&Token::RParen)?;
706        Ok(Expr::Cast {
707            expr: Box::new(expr),
708            data_type,
709        })
710    }
711
712    /// Parse a SQL TRY_CAST function e.g. `TRY_CAST(expr AS FLOAT)`
713    pub fn parse_try_cast_expr(&mut self) -> Result<Expr, ParserError> {
714        self.expect_token(&Token::LParen)?;
715        let expr = self.parse_expr()?;
716        self.expect_keyword(Keyword::AS)?;
717        let data_type = self.parse_data_type()?;
718        self.expect_token(&Token::RParen)?;
719        Ok(Expr::TryCast {
720            expr: Box::new(expr),
721            data_type,
722        })
723    }
724
725    /// Parse a SQL EXISTS expression e.g. `WHERE EXISTS(SELECT ...)`.
726    pub fn parse_exists_expr(&mut self) -> Result<Expr, ParserError> {
727        self.expect_token(&Token::LParen)?;
728        let exists_node = Expr::Exists(Box::new(self.parse_query()?));
729        self.expect_token(&Token::RParen)?;
730        Ok(exists_node)
731    }
732
733    pub fn parse_extract_expr(&mut self) -> Result<Expr, ParserError> {
734        self.expect_token(&Token::LParen)?;
735        let field = self.parse_date_time_field()?;
736        self.expect_keyword(Keyword::FROM)?;
737        let expr = self.parse_expr()?;
738        self.expect_token(&Token::RParen)?;
739        Ok(Expr::Extract {
740            field,
741            expr: Box::new(expr),
742        })
743    }
744
745    pub fn parse_substring_expr(&mut self) -> Result<Expr, ParserError> {
746        // PARSE SUBSTRING (EXPR [FROM 1] [FOR 3])
747        self.expect_token(&Token::LParen)?;
748        let expr = self.parse_expr()?;
749        let mut from_expr = None;
750        if self.parse_keyword(Keyword::FROM) || self.consume_token(&Token::Comma) {
751            from_expr = Some(self.parse_expr()?);
752        }
753
754        let mut to_expr = None;
755        if self.parse_keyword(Keyword::FOR) || self.consume_token(&Token::Comma) {
756            to_expr = Some(self.parse_expr()?);
757        }
758        self.expect_token(&Token::RParen)?;
759
760        Ok(Expr::Substring {
761            expr: Box::new(expr),
762            substring_from: from_expr.map(Box::new),
763            substring_for: to_expr.map(Box::new),
764        })
765    }
766
767    /// TRIM (WHERE 'text' FROM 'text')\
768    /// TRIM ('text')
769    pub fn parse_trim_expr(&mut self) -> Result<Expr, ParserError> {
770        self.expect_token(&Token::LParen)?;
771        let mut where_expr = None;
772        if let Token::Word(word) = self.peek_token() {
773            if [Keyword::BOTH, Keyword::LEADING, Keyword::TRAILING]
774                .iter()
775                .any(|d| word.keyword == *d)
776            {
777                let trim_where = self.parse_trim_where()?;
778                let sub_expr = self.parse_expr()?;
779                self.expect_keyword(Keyword::FROM)?;
780                where_expr = Some((trim_where, Box::new(sub_expr)));
781            }
782        }
783        let expr = self.parse_expr()?;
784        self.expect_token(&Token::RParen)?;
785
786        Ok(Expr::Trim {
787            expr: Box::new(expr),
788            trim_where: where_expr,
789        })
790    }
791
792    pub fn parse_trim_where(&mut self) -> Result<TrimWhereField, ParserError> {
793        match self.next_token() {
794            Token::Word(w) => match w.keyword {
795                Keyword::BOTH => Ok(TrimWhereField::Both),
796                Keyword::LEADING => Ok(TrimWhereField::Leading),
797                Keyword::TRAILING => Ok(TrimWhereField::Trailing),
798                _ => self.expected("trim_where field", Token::Word(w))?,
799            },
800            unexpected => self.expected("trim_where field", unexpected),
801        }
802    }
803
804    /// Parse a SQL LISTAGG expression, e.g. `LISTAGG(...) WITHIN GROUP (ORDER BY ...)`.
805    pub fn parse_listagg_expr(&mut self) -> Result<Expr, ParserError> {
806        self.expect_token(&Token::LParen)?;
807        let distinct = self.parse_all_or_distinct()?;
808        let expr = Box::new(self.parse_expr()?);
809        // While ANSI SQL would would require the separator, Redshift makes this optional. Here we
810        // choose to make the separator optional as this provides the more general implementation.
811        let separator = if self.consume_token(&Token::Comma) {
812            Some(Box::new(self.parse_expr()?))
813        } else {
814            None
815        };
816        let on_overflow = if self.parse_keywords(&[Keyword::ON, Keyword::OVERFLOW]) {
817            if self.parse_keyword(Keyword::ERROR) {
818                Some(ListAggOnOverflow::Error)
819            } else {
820                self.expect_keyword(Keyword::TRUNCATE)?;
821                let filler = match self.peek_token() {
822                    Token::Word(w)
823                        if w.keyword == Keyword::WITH || w.keyword == Keyword::WITHOUT =>
824                    {
825                        None
826                    }
827                    Token::SingleQuotedString(_)
828                    | Token::NationalStringLiteral(_)
829                    | Token::HexStringLiteral(_) => Some(Box::new(self.parse_expr()?)),
830                    unexpected => {
831                        self.expected("either filler, WITH, or WITHOUT in LISTAGG", unexpected)?
832                    }
833                };
834                let with_count = self.parse_keyword(Keyword::WITH);
835                if !with_count && !self.parse_keyword(Keyword::WITHOUT) {
836                    self.expected("either WITH or WITHOUT in LISTAGG", self.peek_token())?;
837                }
838                self.expect_keyword(Keyword::COUNT)?;
839                Some(ListAggOnOverflow::Truncate { filler, with_count })
840            }
841        } else {
842            None
843        };
844        self.expect_token(&Token::RParen)?;
845        // Once again ANSI SQL requires WITHIN GROUP, but Redshift does not. Again we choose the
846        // more general implementation.
847        let within_group = if self.parse_keywords(&[Keyword::WITHIN, Keyword::GROUP]) {
848            self.expect_token(&Token::LParen)?;
849            self.expect_keywords(&[Keyword::ORDER, Keyword::BY])?;
850            let order_by_expr = self.parse_comma_separated(Parser::parse_order_by_expr)?;
851            self.expect_token(&Token::RParen)?;
852            order_by_expr
853        } else {
854            vec![]
855        };
856        Ok(Expr::ListAgg(ListAgg {
857            distinct,
858            expr,
859            separator,
860            on_overflow,
861            within_group,
862        }))
863    }
864
865    // This function parses date/time fields for both the EXTRACT function-like
866    // operator and interval qualifiers. EXTRACT supports a wider set of
867    // date/time fields than interval qualifiers, so this function may need to
868    // be split in two.
869    pub fn parse_date_time_field(&mut self) -> Result<DateTimeField, ParserError> {
870        match self.next_token() {
871            Token::Word(w) => match w.keyword {
872                Keyword::YEAR => Ok(DateTimeField::Year),
873                Keyword::MONTH => Ok(DateTimeField::Month),
874                Keyword::DAY => Ok(DateTimeField::Day),
875                Keyword::HOUR => Ok(DateTimeField::Hour),
876                Keyword::MINUTE => Ok(DateTimeField::Minute),
877                Keyword::SECOND => Ok(DateTimeField::Second),
878                _ => self.expected("date/time field", Token::Word(w))?,
879            },
880            unexpected => self.expected("date/time field", unexpected),
881        }
882    }
883
884    /// Parse an INTERVAL literal.
885    ///
886    /// Some syntactically valid intervals:
887    ///
888    ///   1. `INTERVAL '1' DAY`
889    ///   2. `INTERVAL '1-1' YEAR TO MONTH`
890    ///   3. `INTERVAL '1' SECOND`
891    ///   4. `INTERVAL '1:1:1.1' HOUR (5) TO SECOND (5)`
892    ///   5. `INTERVAL '1.1' SECOND (2, 2)`
893    ///   6. `INTERVAL '1:1' HOUR (5) TO MINUTE (5)`
894    ///
895    /// Note that we do not currently attempt to parse the quoted value.
896    pub fn parse_literal_interval(&mut self) -> Result<Expr, ParserError> {
897        // The SQL standard allows an optional sign before the value string, but
898        // it is not clear if any implementations support that syntax, so we
899        // don't currently try to parse it. (The sign can instead be included
900        // inside the value string.)
901
902        // The first token in an interval is a string literal which specifies
903        // the duration of the interval.
904        let value = self.parse_literal_string()?;
905
906        // Following the string literal is a qualifier which indicates the units
907        // of the duration specified in the string literal.
908        //
909        // Note that PostgreSQL allows omitting the qualifier, so we provide
910        // this more general implemenation.
911        let leading_field = match self.peek_token() {
912            Token::Word(kw)
913                if [
914                    Keyword::YEAR,
915                    Keyword::MONTH,
916                    Keyword::DAY,
917                    Keyword::HOUR,
918                    Keyword::MINUTE,
919                    Keyword::SECOND,
920                ]
921                .iter()
922                .any(|d| kw.keyword == *d) =>
923            {
924                Some(self.parse_date_time_field()?)
925            }
926            _ => None,
927        };
928
929        let (leading_precision, last_field, fsec_precision) =
930            if leading_field == Some(DateTimeField::Second) {
931                // SQL mandates special syntax for `SECOND TO SECOND` literals.
932                // Instead of
933                //     `SECOND [(<leading precision>)] TO SECOND[(<fractional seconds precision>)]`
934                // one must use the special format:
935                //     `SECOND [( <leading precision> [ , <fractional seconds precision>] )]`
936                let last_field = None;
937                let (leading_precision, fsec_precision) = self.parse_optional_precision_scale()?;
938                (leading_precision, last_field, fsec_precision)
939            } else {
940                let leading_precision = self.parse_optional_precision()?;
941                if self.parse_keyword(Keyword::TO) {
942                    let last_field = Some(self.parse_date_time_field()?);
943                    let fsec_precision = if last_field == Some(DateTimeField::Second) {
944                        self.parse_optional_precision()?
945                    } else {
946                        None
947                    };
948                    (leading_precision, last_field, fsec_precision)
949                } else {
950                    (leading_precision, None, None)
951                }
952            };
953
954        Ok(Expr::Value(Value::Interval {
955            value,
956            leading_field,
957            leading_precision,
958            last_field,
959            fractional_seconds_precision: fsec_precision,
960        }))
961    }
962
963    /// Parse an operator following an expression
964    pub fn parse_infix(&mut self, expr: Expr, precedence: u8) -> Result<Expr, ParserError> {
965        let tok = self.next_token();
966        let regular_binary_operator = match &tok {
967            Token::Spaceship => Some(BinaryOperator::Spaceship),
968            Token::DoubleEq => Some(BinaryOperator::Eq),
969            Token::Eq => Some(BinaryOperator::Eq),
970            Token::Neq => Some(BinaryOperator::NotEq),
971            Token::Gt => Some(BinaryOperator::Gt),
972            Token::GtEq => Some(BinaryOperator::GtEq),
973            Token::Lt => Some(BinaryOperator::Lt),
974            Token::LtEq => Some(BinaryOperator::LtEq),
975            Token::Plus => Some(BinaryOperator::Plus),
976            Token::Minus => Some(BinaryOperator::Minus),
977            Token::Mul => Some(BinaryOperator::Multiply),
978            Token::Mod => Some(BinaryOperator::Modulo),
979            Token::StringConcat => Some(BinaryOperator::StringConcat),
980            Token::Pipe => Some(BinaryOperator::BitwiseOr),
981            Token::Caret => Some(BinaryOperator::BitwiseXor),
982            Token::Ampersand => Some(BinaryOperator::BitwiseAnd),
983            Token::Div => Some(BinaryOperator::Divide),
984            Token::ShiftLeft if dialect_of!(self is PostgreSqlDialect) => {
985                Some(BinaryOperator::PGBitwiseShiftLeft)
986            }
987            Token::ShiftRight if dialect_of!(self is PostgreSqlDialect) => {
988                Some(BinaryOperator::PGBitwiseShiftRight)
989            }
990            Token::Sharp if dialect_of!(self is PostgreSqlDialect) => {
991                Some(BinaryOperator::PGBitwiseXor)
992            }
993            Token::Tilde => Some(BinaryOperator::PGRegexMatch),
994            Token::TildeAsterisk => Some(BinaryOperator::PGRegexIMatch),
995            Token::ExclamationMarkTilde => Some(BinaryOperator::PGRegexNotMatch),
996            Token::ExclamationMarkTildeAsterisk => Some(BinaryOperator::PGRegexNotIMatch),
997            Token::Word(w) => match w.keyword {
998                Keyword::AND => Some(BinaryOperator::And),
999                Keyword::OR => Some(BinaryOperator::Or),
1000                Keyword::LIKE => Some(BinaryOperator::Like),
1001                Keyword::ILIKE => Some(BinaryOperator::ILike),
1002                Keyword::NOT => {
1003                    if self.parse_keyword(Keyword::LIKE) {
1004                        Some(BinaryOperator::NotLike)
1005                    } else if self.parse_keyword(Keyword::ILIKE) {
1006                        Some(BinaryOperator::NotILike)
1007                    } else {
1008                        None
1009                    }
1010                }
1011                Keyword::XOR => Some(BinaryOperator::Xor),
1012                _ => None,
1013            },
1014            _ => None,
1015        };
1016
1017        if let Some(op) = regular_binary_operator {
1018            Ok(Expr::BinaryOp {
1019                left: Box::new(expr),
1020                op,
1021                right: Box::new(self.parse_subexpr(precedence)?),
1022            })
1023        } else if let Token::Word(w) = &tok {
1024            match w.keyword {
1025                Keyword::IS => {
1026                    if self.parse_keyword(Keyword::NULL) {
1027                        Ok(Expr::IsNull(Box::new(expr)))
1028                    } else if self.parse_keywords(&[Keyword::NOT, Keyword::NULL]) {
1029                        Ok(Expr::IsNotNull(Box::new(expr)))
1030                    } else if self.parse_keywords(&[Keyword::DISTINCT, Keyword::FROM]) {
1031                        let expr2 = self.parse_expr()?;
1032                        Ok(Expr::IsDistinctFrom(Box::new(expr), Box::new(expr2)))
1033                    } else if self.parse_keywords(&[Keyword::NOT, Keyword::DISTINCT, Keyword::FROM])
1034                    {
1035                        let expr2 = self.parse_expr()?;
1036                        Ok(Expr::IsNotDistinctFrom(Box::new(expr), Box::new(expr2)))
1037                    } else {
1038                        self.expected(
1039                            "[NOT] NULL or [NOT] DISTINCT FROM after IS",
1040                            self.peek_token(),
1041                        )
1042                    }
1043                }
1044                Keyword::NOT | Keyword::IN | Keyword::BETWEEN => {
1045                    self.prev_token();
1046                    let negated = self.parse_keyword(Keyword::NOT);
1047                    if self.parse_keyword(Keyword::IN) {
1048                        self.parse_in(expr, negated)
1049                    } else if self.parse_keyword(Keyword::BETWEEN) {
1050                        self.parse_between(expr, negated)
1051                    } else {
1052                        self.expected("IN or BETWEEN after NOT", self.peek_token())
1053                    }
1054                }
1055                // Can only happen if `get_next_precedence` got out of sync with this function
1056                _ => parser_err!(format!("No infix parser for token {:?}", tok)),
1057            }
1058        } else if Token::DoubleColon == tok {
1059            self.parse_pg_cast(expr)
1060        } else if Token::ExclamationMark == tok {
1061            // PostgreSQL factorial operation
1062            Ok(Expr::UnaryOp {
1063                op: UnaryOperator::PGPostfixFactorial,
1064                expr: Box::new(expr),
1065            })
1066        } else if Token::LBracket == tok {
1067            self.parse_map_access(expr)
1068        } else {
1069            // Can only happen if `get_next_precedence` got out of sync with this function
1070            parser_err!(format!("No infix parser for token {:?}", tok))
1071        }
1072    }
1073
1074    pub fn parse_map_access(&mut self, expr: Expr) -> Result<Expr, ParserError> {
1075        let key = self.parse_map_key()?;
1076        let tok = self.consume_token(&Token::RBracket);
1077        debug!("Tok: {}", tok);
1078        let mut key_parts: Vec<Expr> = vec![key];
1079        while self.consume_token(&Token::LBracket) {
1080            let key = self.parse_map_key()?;
1081            let tok = self.consume_token(&Token::RBracket);
1082            debug!("Tok: {}", tok);
1083            key_parts.push(key);
1084        }
1085        match expr {
1086            e @ Expr::Identifier(_) | e @ Expr::CompoundIdentifier(_) => Ok(Expr::MapAccess {
1087                column: Box::new(e),
1088                keys: key_parts,
1089            }),
1090            _ => Ok(expr),
1091        }
1092    }
1093
1094    /// Parses the parens following the `[ NOT ] IN` operator
1095    pub fn parse_in(&mut self, expr: Expr, negated: bool) -> Result<Expr, ParserError> {
1096        self.expect_token(&Token::LParen)?;
1097        let in_op = if self.parse_keyword(Keyword::SELECT) || self.parse_keyword(Keyword::WITH) {
1098            self.prev_token();
1099            Expr::InSubquery {
1100                expr: Box::new(expr),
1101                subquery: Box::new(self.parse_query()?),
1102                negated,
1103            }
1104        } else {
1105            Expr::InList {
1106                expr: Box::new(expr),
1107                list: self.parse_comma_separated(Parser::parse_expr)?,
1108                negated,
1109            }
1110        };
1111        self.expect_token(&Token::RParen)?;
1112        Ok(in_op)
1113    }
1114
1115    /// Parses `BETWEEN <low> AND <high>`, assuming the `BETWEEN` keyword was already consumed
1116    pub fn parse_between(&mut self, expr: Expr, negated: bool) -> Result<Expr, ParserError> {
1117        // Stop parsing subexpressions for <low> and <high> on tokens with
1118        // precedence lower than that of `BETWEEN`, such as `AND`, `IS`, etc.
1119        let low = self.parse_subexpr(Self::BETWEEN_PREC)?;
1120        self.expect_keyword(Keyword::AND)?;
1121        let high = self.parse_subexpr(Self::BETWEEN_PREC)?;
1122        Ok(Expr::Between {
1123            expr: Box::new(expr),
1124            negated,
1125            low: Box::new(low),
1126            high: Box::new(high),
1127        })
1128    }
1129
1130    /// Parse a postgresql casting style which is in the form of `expr::datatype`
1131    pub fn parse_pg_cast(&mut self, expr: Expr) -> Result<Expr, ParserError> {
1132        Ok(Expr::Cast {
1133            expr: Box::new(expr),
1134            data_type: self.parse_data_type()?,
1135        })
1136    }
1137
1138    const UNARY_NOT_PREC: u8 = 15;
1139    const BETWEEN_PREC: u8 = 20;
1140    const PLUS_MINUS_PREC: u8 = 30;
1141
1142    /// Get the precedence of the next token
1143    pub fn get_next_precedence(&self) -> Result<u8, ParserError> {
1144        let token = self.peek_token();
1145        debug!("get_next_precedence() {:?}", token);
1146        match token {
1147            Token::Word(w) if w.keyword == Keyword::OR => Ok(5),
1148            Token::Word(w) if w.keyword == Keyword::AND => Ok(10),
1149            Token::Word(w) if w.keyword == Keyword::XOR => Ok(24),
1150            Token::Word(w) if w.keyword == Keyword::NOT => match self.peek_nth_token(1) {
1151                // The precedence of NOT varies depending on keyword that
1152                // follows it. If it is followed by IN, BETWEEN, or LIKE,
1153                // it takes on the precedence of those tokens. Otherwise it
1154                // is not an infix operator, and therefore has zero
1155                // precedence.
1156                Token::Word(w) if w.keyword == Keyword::IN => Ok(Self::BETWEEN_PREC),
1157                Token::Word(w) if w.keyword == Keyword::BETWEEN => Ok(Self::BETWEEN_PREC),
1158                Token::Word(w) if w.keyword == Keyword::LIKE => Ok(Self::BETWEEN_PREC),
1159                Token::Word(w) if w.keyword == Keyword::ILIKE => Ok(Self::BETWEEN_PREC),
1160                _ => Ok(0),
1161            },
1162            Token::Word(w) if w.keyword == Keyword::IS => Ok(17),
1163            Token::Word(w) if w.keyword == Keyword::IN => Ok(Self::BETWEEN_PREC),
1164            Token::Word(w) if w.keyword == Keyword::BETWEEN => Ok(Self::BETWEEN_PREC),
1165            Token::Word(w) if w.keyword == Keyword::LIKE => Ok(Self::BETWEEN_PREC),
1166            Token::Word(w) if w.keyword == Keyword::ILIKE => Ok(Self::BETWEEN_PREC),
1167            Token::Eq
1168            | Token::Lt
1169            | Token::LtEq
1170            | Token::Neq
1171            | Token::Gt
1172            | Token::GtEq
1173            | Token::DoubleEq
1174            | Token::Tilde
1175            | Token::TildeAsterisk
1176            | Token::ExclamationMarkTilde
1177            | Token::ExclamationMarkTildeAsterisk
1178            | Token::Spaceship => Ok(20),
1179            Token::Pipe => Ok(21),
1180            Token::Caret | Token::Sharp | Token::ShiftRight | Token::ShiftLeft => Ok(22),
1181            Token::Ampersand => Ok(23),
1182            Token::Plus | Token::Minus => Ok(Self::PLUS_MINUS_PREC),
1183            Token::Mul | Token::Div | Token::Mod | Token::StringConcat => Ok(40),
1184            Token::DoubleColon => Ok(50),
1185            Token::ExclamationMark => Ok(50),
1186            Token::LBracket | Token::RBracket => Ok(10),
1187            _ => Ok(0),
1188        }
1189    }
1190
1191    /// Return the first non-whitespace token that has not yet been processed
1192    /// (or None if reached end-of-file)
1193    pub fn peek_token(&self) -> Token {
1194        self.peek_nth_token(0)
1195    }
1196
1197    /// Return nth non-whitespace token that has not yet been processed
1198    pub fn peek_nth_token(&self, mut n: usize) -> Token {
1199        let mut index = self.index;
1200        loop {
1201            index += 1;
1202            match self.tokens.get(index - 1) {
1203                Some(Token::Whitespace(_)) => continue,
1204                non_whitespace => {
1205                    if n == 0 {
1206                        return non_whitespace.cloned().unwrap_or(Token::EOF);
1207                    }
1208                    n -= 1;
1209                }
1210            }
1211        }
1212    }
1213
1214    /// Return the first non-whitespace token that has not yet been processed
1215    /// (or None if reached end-of-file) and mark it as processed. OK to call
1216    /// repeatedly after reaching EOF.
1217    pub fn next_token(&mut self) -> Token {
1218        loop {
1219            self.index += 1;
1220            match self.tokens.get(self.index - 1) {
1221                Some(Token::Whitespace(_)) => continue,
1222                token => return token.cloned().unwrap_or(Token::EOF),
1223            }
1224        }
1225    }
1226
1227    /// Return the first unprocessed token, possibly whitespace.
1228    pub fn next_token_no_skip(&mut self) -> Option<&Token> {
1229        self.index += 1;
1230        self.tokens.get(self.index - 1)
1231    }
1232
1233    /// Push back the last one non-whitespace token. Must be called after
1234    /// `next_token()`, otherwise might panic. OK to call after
1235    /// `next_token()` indicates an EOF.
1236    pub fn prev_token(&mut self) {
1237        loop {
1238            assert!(self.index > 0);
1239            self.index -= 1;
1240            if let Some(Token::Whitespace(_)) = self.tokens.get(self.index) {
1241                continue;
1242            }
1243            return;
1244        }
1245    }
1246
1247    /// Report unexpected token
1248    fn expected<T>(&self, expected: &str, found: Token) -> Result<T, ParserError> {
1249        parser_err!(format!("Expected {}, found: {}", expected, found))
1250    }
1251
1252    /// Look for an expected keyword and consume it if it exists
1253    #[must_use]
1254    pub fn parse_keyword(&mut self, expected: Keyword) -> bool {
1255        match self.peek_token() {
1256            Token::Word(w) if expected == w.keyword => {
1257                self.next_token();
1258                true
1259            }
1260            _ => false,
1261        }
1262    }
1263
1264    /// Look for an expected sequence of keywords and consume them if they exist
1265    #[must_use]
1266    pub fn parse_keywords(&mut self, keywords: &[Keyword]) -> bool {
1267        let index = self.index;
1268        for &keyword in keywords {
1269            if !self.parse_keyword(keyword) {
1270                // println!("parse_keywords aborting .. did not find {:?}", keyword);
1271                // reset index and return immediately
1272                self.index = index;
1273                return false;
1274            }
1275        }
1276        true
1277    }
1278
1279    /// Look for one of the given keywords and return the one that matches.
1280    #[must_use]
1281    pub fn parse_one_of_keywords(&mut self, keywords: &[Keyword]) -> Option<Keyword> {
1282        match self.peek_token() {
1283            Token::Word(w) => {
1284                keywords
1285                    .iter()
1286                    .find(|keyword| **keyword == w.keyword)
1287                    .map(|keyword| {
1288                        self.next_token();
1289                        *keyword
1290                    })
1291            }
1292            _ => None,
1293        }
1294    }
1295
1296    /// Bail out if the current token is not one of the expected keywords, or consume it if it is
1297    pub fn expect_one_of_keywords(&mut self, keywords: &[Keyword]) -> Result<Keyword, ParserError> {
1298        if let Some(keyword) = self.parse_one_of_keywords(keywords) {
1299            Ok(keyword)
1300        } else {
1301            let keywords: Vec<String> = keywords.iter().map(|x| format!("{:?}", x)).collect();
1302            self.expected(
1303                &format!("one of {}", keywords.join(" or ")),
1304                self.peek_token(),
1305            )
1306        }
1307    }
1308
1309    /// Bail out if the current token is not an expected keyword, or consume it if it is
1310    pub fn expect_keyword(&mut self, expected: Keyword) -> Result<(), ParserError> {
1311        if self.parse_keyword(expected) {
1312            Ok(())
1313        } else {
1314            self.expected(format!("{:?}", &expected).as_str(), self.peek_token())
1315        }
1316    }
1317
1318    /// Bail out if the following tokens are not the expected sequence of
1319    /// keywords, or consume them if they are.
1320    pub fn expect_keywords(&mut self, expected: &[Keyword]) -> Result<(), ParserError> {
1321        for &kw in expected {
1322            self.expect_keyword(kw)?;
1323        }
1324        Ok(())
1325    }
1326
1327    /// Consume the next token if it matches the expected token, otherwise return false
1328    #[must_use]
1329    pub fn consume_token(&mut self, expected: &Token) -> bool {
1330        if self.peek_token() == *expected {
1331            self.next_token();
1332            true
1333        } else {
1334            false
1335        }
1336    }
1337
1338    /// Bail out if the current token is not an expected keyword, or consume it if it is
1339    pub fn expect_token(&mut self, expected: &Token) -> Result<(), ParserError> {
1340        if self.consume_token(expected) {
1341            Ok(())
1342        } else {
1343            self.expected(&expected.to_string(), self.peek_token())
1344        }
1345    }
1346
1347    /// Parse a comma-separated list of 1+ items accepted by `F`
1348    pub fn parse_comma_separated<T, F>(&mut self, mut f: F) -> Result<Vec<T>, ParserError>
1349    where
1350        F: FnMut(&mut Parser<'a>) -> Result<T, ParserError>,
1351    {
1352        let mut values = vec![];
1353        loop {
1354            values.push(f(self)?);
1355            if !self.consume_token(&Token::Comma) {
1356                break;
1357            }
1358        }
1359        Ok(values)
1360    }
1361
1362    /// Run a parser method `f`, reverting back to the current position
1363    /// if unsuccessful.
1364    #[must_use]
1365    fn maybe_parse<T, F>(&mut self, mut f: F) -> Option<T>
1366    where
1367        F: FnMut(&mut Parser) -> Result<T, ParserError>,
1368    {
1369        let index = self.index;
1370        if let Ok(t) = f(self) {
1371            Some(t)
1372        } else {
1373            self.index = index;
1374            None
1375        }
1376    }
1377
1378    /// Parse either `ALL` or `DISTINCT`. Returns `true` if `DISTINCT` is parsed and results in a
1379    /// `ParserError` if both `ALL` and `DISTINCT` are fround.
1380    pub fn parse_all_or_distinct(&mut self) -> Result<bool, ParserError> {
1381        let all = self.parse_keyword(Keyword::ALL);
1382        let distinct = self.parse_keyword(Keyword::DISTINCT);
1383        if all && distinct {
1384            return parser_err!("Cannot specify both ALL and DISTINCT".to_string());
1385        } else {
1386            Ok(distinct)
1387        }
1388    }
1389
1390    /// Parse a SQL CREATE statement
1391    pub fn parse_create(&mut self) -> Result<Statement, ParserError> {
1392        let or_replace = self.parse_keywords(&[Keyword::OR, Keyword::REPLACE]);
1393        let temporary = self
1394            .parse_one_of_keywords(&[Keyword::TEMP, Keyword::TEMPORARY])
1395            .is_some();
1396        if self.parse_keyword(Keyword::TABLE) {
1397            self.parse_create_table(or_replace, temporary)
1398        } else if self.parse_keyword(Keyword::MATERIALIZED) || self.parse_keyword(Keyword::VIEW) {
1399            self.prev_token();
1400            self.parse_create_view(or_replace)
1401        } else if self.parse_keyword(Keyword::EXTERNAL) {
1402            self.parse_create_external_table(or_replace)
1403        } else if or_replace {
1404            self.expected(
1405                "[EXTERNAL] TABLE or [MATERIALIZED] VIEW after CREATE OR REPLACE",
1406                self.peek_token(),
1407            )
1408        } else if self.parse_keyword(Keyword::INDEX) {
1409            self.parse_create_index(false)
1410        } else if self.parse_keywords(&[Keyword::UNIQUE, Keyword::INDEX]) {
1411            self.parse_create_index(true)
1412        } else if self.parse_keyword(Keyword::VIRTUAL) {
1413            self.parse_create_virtual_table()
1414        } else if self.parse_keyword(Keyword::SCHEMA) {
1415            self.parse_create_schema()
1416        } else {
1417            self.expected("an object type after CREATE", self.peek_token())
1418        }
1419    }
1420
1421    /// SQLite-specific `CREATE VIRTUAL TABLE`
1422    pub fn parse_create_virtual_table(&mut self) -> Result<Statement, ParserError> {
1423        self.expect_keyword(Keyword::TABLE)?;
1424        let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]);
1425        let table_name = self.parse_object_name()?;
1426        self.expect_keyword(Keyword::USING)?;
1427        let module_name = self.parse_identifier()?;
1428        // SQLite docs note that module "arguments syntax is sufficiently
1429        // general that the arguments can be made to appear as column
1430        // definitions in a traditional CREATE TABLE statement", but
1431        // we don't implement that.
1432        let module_args = self.parse_parenthesized_column_list(Optional)?;
1433        Ok(Statement::CreateVirtualTable {
1434            name: table_name,
1435            if_not_exists,
1436            module_name,
1437            module_args,
1438        })
1439    }
1440
1441    pub fn parse_create_schema(&mut self) -> Result<Statement, ParserError> {
1442        let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]);
1443        let schema_name = self.parse_object_name()?;
1444        Ok(Statement::CreateSchema {
1445            schema_name,
1446            if_not_exists,
1447        })
1448    }
1449
1450    pub fn parse_create_database(&mut self) -> Result<Statement, ParserError> {
1451        let ine = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]);
1452        let db_name = self.parse_object_name()?;
1453        let mut location = None;
1454        let mut managed_location = None;
1455        loop {
1456            match self.parse_one_of_keywords(&[Keyword::LOCATION, Keyword::MANAGEDLOCATION]) {
1457                Some(Keyword::LOCATION) => location = Some(self.parse_literal_string()?),
1458                Some(Keyword::MANAGEDLOCATION) => {
1459                    managed_location = Some(self.parse_literal_string()?)
1460                }
1461                _ => break,
1462            }
1463        }
1464        Ok(Statement::CreateDatabase {
1465            db_name,
1466            if_not_exists: ine,
1467            location,
1468            managed_location,
1469        })
1470    }
1471
1472    pub fn parse_create_external_table(
1473        &mut self,
1474        or_replace: bool,
1475    ) -> Result<Statement, ParserError> {
1476        self.expect_keyword(Keyword::TABLE)?;
1477        let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]);
1478        let table_name = self.parse_object_name()?;
1479        let (columns, constraints) = self.parse_columns()?;
1480
1481        let hive_distribution = self.parse_hive_distribution()?;
1482        let hive_formats = self.parse_hive_formats()?;
1483
1484        let file_format = if let Some(ff) = &hive_formats.storage {
1485            match ff {
1486                HiveIOFormat::FileFormat { format } => Some(format.clone()),
1487                _ => None,
1488            }
1489        } else {
1490            None
1491        };
1492        let location = hive_formats.location.clone();
1493        let table_properties = self.parse_options(Keyword::TBLPROPERTIES)?;
1494        Ok(Statement::CreateTable {
1495            name: table_name,
1496            columns,
1497            constraints,
1498            hive_distribution,
1499            hive_formats: Some(hive_formats),
1500            with_options: vec![],
1501            table_properties,
1502            or_replace,
1503            if_not_exists,
1504            external: true,
1505            temporary: false,
1506            file_format,
1507            location,
1508            query: None,
1509            without_rowid: false,
1510            like: None,
1511        })
1512    }
1513
1514    pub fn parse_file_format(&mut self) -> Result<FileFormat, ParserError> {
1515        match self.next_token() {
1516            Token::Word(w) => match w.keyword {
1517                Keyword::AVRO => Ok(FileFormat::AVRO),
1518                Keyword::JSONFILE => Ok(FileFormat::JSONFILE),
1519                Keyword::ORC => Ok(FileFormat::ORC),
1520                Keyword::PARQUET => Ok(FileFormat::PARQUET),
1521                Keyword::RCFILE => Ok(FileFormat::RCFILE),
1522                Keyword::SEQUENCEFILE => Ok(FileFormat::SEQUENCEFILE),
1523                Keyword::TEXTFILE => Ok(FileFormat::TEXTFILE),
1524                _ => self.expected("fileformat", Token::Word(w)),
1525            },
1526            unexpected => self.expected("fileformat", unexpected),
1527        }
1528    }
1529
1530    pub fn parse_create_view(&mut self, or_replace: bool) -> Result<Statement, ParserError> {
1531        let materialized = self.parse_keyword(Keyword::MATERIALIZED);
1532        self.expect_keyword(Keyword::VIEW)?;
1533        // Many dialects support `OR ALTER` right after `CREATE`, but we don't (yet).
1534        // ANSI SQL and Postgres support RECURSIVE here, but we don't support it either.
1535        let name = self.parse_object_name()?;
1536        let columns = self.parse_parenthesized_column_list(Optional)?;
1537        let with_options = self.parse_options(Keyword::WITH)?;
1538        self.expect_keyword(Keyword::AS)?;
1539        let query = Box::new(self.parse_query()?);
1540        // Optional `WITH [ CASCADED | LOCAL ] CHECK OPTION` is widely supported here.
1541        Ok(Statement::CreateView {
1542            name,
1543            columns,
1544            query,
1545            materialized,
1546            or_replace,
1547            with_options,
1548        })
1549    }
1550
1551    pub fn parse_drop(&mut self) -> Result<Statement, ParserError> {
1552        let object_type = if self.parse_keyword(Keyword::TABLE) {
1553            ObjectType::Table
1554        } else if self.parse_keyword(Keyword::VIEW) {
1555            ObjectType::View
1556        } else if self.parse_keyword(Keyword::INDEX) {
1557            ObjectType::Index
1558        } else if self.parse_keyword(Keyword::SCHEMA) {
1559            ObjectType::Schema
1560        } else {
1561            return self.expected("TABLE, VIEW, INDEX or SCHEMA after DROP", self.peek_token());
1562        };
1563        // Many dialects support the non standard `IF EXISTS` clause and allow
1564        // specifying multiple objects to delete in a single statement
1565        let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]);
1566        let names = self.parse_comma_separated(Parser::parse_object_name)?;
1567        let cascade = self.parse_keyword(Keyword::CASCADE);
1568        let restrict = self.parse_keyword(Keyword::RESTRICT);
1569        let purge = self.parse_keyword(Keyword::PURGE);
1570        if cascade && restrict {
1571            return parser_err!("Cannot specify both CASCADE and RESTRICT in DROP");
1572        }
1573        Ok(Statement::Drop {
1574            object_type,
1575            if_exists,
1576            names,
1577            cascade,
1578            purge,
1579        })
1580    }
1581
1582    pub fn parse_create_index(&mut self, unique: bool) -> Result<Statement, ParserError> {
1583        let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]);
1584        let index_name = self.parse_object_name()?;
1585        self.expect_keyword(Keyword::ON)?;
1586        let table_name = self.parse_object_name()?;
1587        self.expect_token(&Token::LParen)?;
1588        let columns = self.parse_comma_separated(Parser::parse_order_by_expr)?;
1589        self.expect_token(&Token::RParen)?;
1590        Ok(Statement::CreateIndex {
1591            name: index_name,
1592            table_name,
1593            columns,
1594            unique,
1595            if_not_exists,
1596        })
1597    }
1598
1599    //TODO: Implement parsing for Skewed and Clustered
1600    pub fn parse_hive_distribution(&mut self) -> Result<HiveDistributionStyle, ParserError> {
1601        if self.parse_keywords(&[Keyword::PARTITIONED, Keyword::BY]) {
1602            self.expect_token(&Token::LParen)?;
1603            let columns = self.parse_comma_separated(Parser::parse_column_def)?;
1604            self.expect_token(&Token::RParen)?;
1605            Ok(HiveDistributionStyle::PARTITIONED { columns })
1606        } else {
1607            Ok(HiveDistributionStyle::NONE)
1608        }
1609    }
1610
1611    pub fn parse_hive_formats(&mut self) -> Result<HiveFormat, ParserError> {
1612        let mut hive_format = HiveFormat::default();
1613        loop {
1614            match self.parse_one_of_keywords(&[Keyword::ROW, Keyword::STORED, Keyword::LOCATION]) {
1615                Some(Keyword::ROW) => {
1616                    hive_format.row_format = Some(self.parse_row_format()?);
1617                }
1618                Some(Keyword::STORED) => {
1619                    self.expect_keyword(Keyword::AS)?;
1620                    if self.parse_keyword(Keyword::INPUTFORMAT) {
1621                        let input_format = self.parse_expr()?;
1622                        self.expect_keyword(Keyword::OUTPUTFORMAT)?;
1623                        let output_format = self.parse_expr()?;
1624                        hive_format.storage = Some(HiveIOFormat::IOF {
1625                            input_format,
1626                            output_format,
1627                        });
1628                    } else {
1629                        let format = self.parse_file_format()?;
1630                        hive_format.storage = Some(HiveIOFormat::FileFormat { format });
1631                    }
1632                }
1633                Some(Keyword::LOCATION) => {
1634                    hive_format.location = Some(self.parse_literal_string()?);
1635                }
1636                None => break,
1637                _ => break,
1638            }
1639        }
1640
1641        Ok(hive_format)
1642    }
1643
1644    pub fn parse_row_format(&mut self) -> Result<HiveRowFormat, ParserError> {
1645        self.expect_keyword(Keyword::FORMAT)?;
1646        match self.parse_one_of_keywords(&[Keyword::SERDE, Keyword::DELIMITED]) {
1647            Some(Keyword::SERDE) => {
1648                let class = self.parse_literal_string()?;
1649                Ok(HiveRowFormat::SERDE { class })
1650            }
1651            _ => Ok(HiveRowFormat::DELIMITED),
1652        }
1653    }
1654
1655    pub fn parse_create_table(
1656        &mut self,
1657        or_replace: bool,
1658        temporary: bool,
1659    ) -> Result<Statement, ParserError> {
1660        let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]);
1661        let table_name = self.parse_object_name()?;
1662        let like = if self.parse_keyword(Keyword::LIKE) || self.parse_keyword(Keyword::ILIKE) {
1663            self.parse_object_name().ok()
1664        } else {
1665            None
1666        };
1667        // parse optional column list (schema)
1668        let (columns, constraints) = self.parse_columns()?;
1669
1670        // SQLite supports `WITHOUT ROWID` at the end of `CREATE TABLE`
1671        let without_rowid = self.parse_keywords(&[Keyword::WITHOUT, Keyword::ROWID]);
1672
1673        let hive_distribution = self.parse_hive_distribution()?;
1674        let hive_formats = self.parse_hive_formats()?;
1675        // PostgreSQL supports `WITH ( options )`, before `AS`
1676        let with_options = self.parse_options(Keyword::WITH)?;
1677        let table_properties = self.parse_options(Keyword::TBLPROPERTIES)?;
1678        // Parse optional `AS ( query )`
1679        let query = if self.parse_keyword(Keyword::AS) {
1680            Some(Box::new(self.parse_query()?))
1681        } else {
1682            None
1683        };
1684
1685        Ok(Statement::CreateTable {
1686            name: table_name,
1687            temporary,
1688            columns,
1689            constraints,
1690            with_options,
1691            table_properties,
1692            or_replace,
1693            if_not_exists,
1694            hive_distribution,
1695            hive_formats: Some(hive_formats),
1696            external: false,
1697            file_format: None,
1698            location: None,
1699            query,
1700            without_rowid,
1701            like,
1702        })
1703    }
1704
1705    fn parse_columns(&mut self) -> Result<(Vec<ColumnDef>, Vec<TableConstraint>), ParserError> {
1706        let mut columns = vec![];
1707        let mut constraints = vec![];
1708        if !self.consume_token(&Token::LParen) || self.consume_token(&Token::RParen) {
1709            return Ok((columns, constraints));
1710        }
1711
1712        loop {
1713            if let Some(constraint) = self.parse_optional_table_constraint()? {
1714                constraints.push(constraint);
1715            } else if let Token::Word(_) = self.peek_token() {
1716                columns.push(self.parse_column_def()?);
1717            } else {
1718                return self.expected("column name or constraint definition", self.peek_token());
1719            }
1720            let comma = self.consume_token(&Token::Comma);
1721            if self.consume_token(&Token::RParen) {
1722                // allow a trailing comma, even though it's not in standard
1723                break;
1724            } else if !comma {
1725                return self.expected("',' or ')' after column definition", self.peek_token());
1726            }
1727        }
1728
1729        Ok((columns, constraints))
1730    }
1731
1732    fn parse_column_def(&mut self) -> Result<ColumnDef, ParserError> {
1733        let name = self.parse_identifier()?;
1734        let data_type = self.parse_data_type()?;
1735        let collation = if self.parse_keyword(Keyword::COLLATE) {
1736            Some(self.parse_object_name()?)
1737        } else {
1738            None
1739        };
1740        let mut options = vec![];
1741        loop {
1742            if self.parse_keyword(Keyword::CONSTRAINT) {
1743                let name = Some(self.parse_identifier()?);
1744                if let Some(option) = self.parse_optional_column_option()? {
1745                    options.push(ColumnOptionDef { name, option });
1746                } else {
1747                    return self.expected(
1748                        "constraint details after CONSTRAINT <name>",
1749                        self.peek_token(),
1750                    );
1751                }
1752            } else if let Some(option) = self.parse_optional_column_option()? {
1753                options.push(ColumnOptionDef { name: None, option });
1754            } else {
1755                break;
1756            };
1757        }
1758        Ok(ColumnDef {
1759            name,
1760            data_type,
1761            collation,
1762            options,
1763        })
1764    }
1765
1766    pub fn parse_optional_column_option(&mut self) -> Result<Option<ColumnOption>, ParserError> {
1767        if self.parse_keywords(&[Keyword::NOT, Keyword::NULL]) {
1768            Ok(Some(ColumnOption::NotNull))
1769        } else if self.parse_keyword(Keyword::NULL) {
1770            Ok(Some(ColumnOption::Null))
1771        } else if self.parse_keyword(Keyword::DEFAULT) {
1772            Ok(Some(ColumnOption::Default(self.parse_expr()?)))
1773        } else if self.parse_keywords(&[Keyword::PRIMARY, Keyword::KEY]) {
1774            Ok(Some(ColumnOption::Unique { is_primary: true }))
1775        } else if self.parse_keyword(Keyword::UNIQUE) {
1776            Ok(Some(ColumnOption::Unique { is_primary: false }))
1777        } else if self.parse_keyword(Keyword::REFERENCES) {
1778            let foreign_table = self.parse_object_name()?;
1779            // PostgreSQL allows omitting the column list and
1780            // uses the primary key column of the foreign table by default
1781            let referred_columns = self.parse_parenthesized_column_list(Optional)?;
1782            let mut on_delete = None;
1783            let mut on_update = None;
1784            loop {
1785                if on_delete.is_none() && self.parse_keywords(&[Keyword::ON, Keyword::DELETE]) {
1786                    on_delete = Some(self.parse_referential_action()?);
1787                } else if on_update.is_none()
1788                    && self.parse_keywords(&[Keyword::ON, Keyword::UPDATE])
1789                {
1790                    on_update = Some(self.parse_referential_action()?);
1791                } else {
1792                    break;
1793                }
1794            }
1795            Ok(Some(ColumnOption::ForeignKey {
1796                foreign_table,
1797                referred_columns,
1798                on_delete,
1799                on_update,
1800            }))
1801        } else if self.parse_keyword(Keyword::CHECK) {
1802            self.expect_token(&Token::LParen)?;
1803            let expr = self.parse_expr()?;
1804            self.expect_token(&Token::RParen)?;
1805            Ok(Some(ColumnOption::Check(expr)))
1806        } else if self.parse_keyword(Keyword::AUTO_INCREMENT)
1807            && dialect_of!(self is MySqlDialect |  GenericDialect)
1808        {
1809            // Support AUTO_INCREMENT for MySQL
1810            Ok(Some(ColumnOption::DialectSpecific(vec![
1811                Token::make_keyword("AUTO_INCREMENT"),
1812            ])))
1813        } else if self.parse_keyword(Keyword::AUTOINCREMENT)
1814            && dialect_of!(self is SQLiteDialect |  GenericDialect)
1815        {
1816            // Support AUTOINCREMENT for SQLite
1817            Ok(Some(ColumnOption::DialectSpecific(vec![
1818                Token::make_keyword("AUTOINCREMENT"),
1819            ])))
1820        } else {
1821            Ok(None)
1822        }
1823    }
1824
1825    pub fn parse_referential_action(&mut self) -> Result<ReferentialAction, ParserError> {
1826        if self.parse_keyword(Keyword::RESTRICT) {
1827            Ok(ReferentialAction::Restrict)
1828        } else if self.parse_keyword(Keyword::CASCADE) {
1829            Ok(ReferentialAction::Cascade)
1830        } else if self.parse_keywords(&[Keyword::SET, Keyword::NULL]) {
1831            Ok(ReferentialAction::SetNull)
1832        } else if self.parse_keywords(&[Keyword::NO, Keyword::ACTION]) {
1833            Ok(ReferentialAction::NoAction)
1834        } else if self.parse_keywords(&[Keyword::SET, Keyword::DEFAULT]) {
1835            Ok(ReferentialAction::SetDefault)
1836        } else {
1837            self.expected(
1838                "one of RESTRICT, CASCADE, SET NULL, NO ACTION or SET DEFAULT",
1839                self.peek_token(),
1840            )
1841        }
1842    }
1843
1844    pub fn parse_optional_table_constraint(
1845        &mut self,
1846    ) -> Result<Option<TableConstraint>, ParserError> {
1847        let name = if self.parse_keyword(Keyword::CONSTRAINT) {
1848            Some(self.parse_identifier()?)
1849        } else {
1850            None
1851        };
1852        match self.next_token() {
1853            Token::Word(w) if w.keyword == Keyword::PRIMARY || w.keyword == Keyword::UNIQUE => {
1854                let is_primary = w.keyword == Keyword::PRIMARY;
1855                if is_primary {
1856                    self.expect_keyword(Keyword::KEY)?;
1857                }
1858                let columns = self.parse_parenthesized_column_list(Mandatory)?;
1859                Ok(Some(TableConstraint::Unique {
1860                    name,
1861                    columns,
1862                    is_primary,
1863                }))
1864            }
1865            Token::Word(w) if w.keyword == Keyword::FOREIGN => {
1866                self.expect_keyword(Keyword::KEY)?;
1867                let columns = self.parse_parenthesized_column_list(Mandatory)?;
1868                self.expect_keyword(Keyword::REFERENCES)?;
1869                let foreign_table = self.parse_object_name()?;
1870                let referred_columns = self.parse_parenthesized_column_list(Mandatory)?;
1871                let mut on_delete = None;
1872                let mut on_update = None;
1873                loop {
1874                    if on_delete.is_none() && self.parse_keywords(&[Keyword::ON, Keyword::DELETE]) {
1875                        on_delete = Some(self.parse_referential_action()?);
1876                    } else if on_update.is_none()
1877                        && self.parse_keywords(&[Keyword::ON, Keyword::UPDATE])
1878                    {
1879                        on_update = Some(self.parse_referential_action()?);
1880                    } else {
1881                        break;
1882                    }
1883                }
1884                Ok(Some(TableConstraint::ForeignKey {
1885                    name,
1886                    columns,
1887                    foreign_table,
1888                    referred_columns,
1889                    on_delete,
1890                    on_update,
1891                }))
1892            }
1893            Token::Word(w) if w.keyword == Keyword::CHECK => {
1894                self.expect_token(&Token::LParen)?;
1895                let expr = Box::new(self.parse_expr()?);
1896                self.expect_token(&Token::RParen)?;
1897                Ok(Some(TableConstraint::Check { name, expr }))
1898            }
1899            unexpected => {
1900                if name.is_some() {
1901                    self.expected("PRIMARY, UNIQUE, FOREIGN, or CHECK", unexpected)
1902                } else {
1903                    self.prev_token();
1904                    Ok(None)
1905                }
1906            }
1907        }
1908    }
1909
1910    pub fn parse_options(&mut self, keyword: Keyword) -> Result<Vec<SqlOption>, ParserError> {
1911        if self.parse_keyword(keyword) {
1912            self.expect_token(&Token::LParen)?;
1913            let options = self.parse_comma_separated(Parser::parse_sql_option)?;
1914            self.expect_token(&Token::RParen)?;
1915            Ok(options)
1916        } else {
1917            Ok(vec![])
1918        }
1919    }
1920
1921    pub fn parse_sql_option(&mut self) -> Result<SqlOption, ParserError> {
1922        let name = self.parse_identifier()?;
1923        self.expect_token(&Token::Eq)?;
1924        let value = self.parse_value()?;
1925        Ok(SqlOption { name, value })
1926    }
1927
1928    pub fn parse_alter(&mut self) -> Result<Statement, ParserError> {
1929        self.expect_keyword(Keyword::TABLE)?;
1930        let _ = self.parse_keyword(Keyword::ONLY);
1931        let table_name = self.parse_object_name()?;
1932        let operation = if self.parse_keyword(Keyword::ADD) {
1933            if let Some(constraint) = self.parse_optional_table_constraint()? {
1934                AlterTableOperation::AddConstraint(constraint)
1935            } else {
1936                let if_not_exists =
1937                    self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]);
1938                if self.parse_keyword(Keyword::PARTITION) {
1939                    self.expect_token(&Token::LParen)?;
1940                    let partitions = self.parse_comma_separated(Parser::parse_expr)?;
1941                    self.expect_token(&Token::RParen)?;
1942                    AlterTableOperation::AddPartitions {
1943                        if_not_exists,
1944                        new_partitions: partitions,
1945                    }
1946                } else {
1947                    let _ = self.parse_keyword(Keyword::COLUMN);
1948                    let column_def = self.parse_column_def()?;
1949                    AlterTableOperation::AddColumn { column_def }
1950                }
1951            }
1952        } else if self.parse_keyword(Keyword::RENAME) {
1953            if dialect_of!(self is PostgreSqlDialect) && self.parse_keyword(Keyword::CONSTRAINT) {
1954                let old_name = self.parse_identifier()?;
1955                self.expect_keyword(Keyword::TO)?;
1956                let new_name = self.parse_identifier()?;
1957                AlterTableOperation::RenameConstraint { old_name, new_name }
1958            } else if self.parse_keyword(Keyword::TO) {
1959                let table_name = self.parse_object_name()?;
1960                AlterTableOperation::RenameTable { table_name }
1961            } else {
1962                let _ = self.parse_keyword(Keyword::COLUMN);
1963                let old_column_name = self.parse_identifier()?;
1964                self.expect_keyword(Keyword::TO)?;
1965                let new_column_name = self.parse_identifier()?;
1966                AlterTableOperation::RenameColumn {
1967                    old_column_name,
1968                    new_column_name,
1969                }
1970            }
1971        } else if self.parse_keyword(Keyword::DROP) {
1972            if self.parse_keywords(&[Keyword::IF, Keyword::EXISTS, Keyword::PARTITION]) {
1973                self.expect_token(&Token::LParen)?;
1974                let partitions = self.parse_comma_separated(Parser::parse_expr)?;
1975                self.expect_token(&Token::RParen)?;
1976                AlterTableOperation::DropPartitions {
1977                    partitions,
1978                    if_exists: true,
1979                }
1980            } else if self.parse_keyword(Keyword::PARTITION) {
1981                self.expect_token(&Token::LParen)?;
1982                let partitions = self.parse_comma_separated(Parser::parse_expr)?;
1983                self.expect_token(&Token::RParen)?;
1984                AlterTableOperation::DropPartitions {
1985                    partitions,
1986                    if_exists: false,
1987                }
1988            } else {
1989                let _ = self.parse_keyword(Keyword::COLUMN);
1990                let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]);
1991                let column_name = self.parse_identifier()?;
1992                let cascade = self.parse_keyword(Keyword::CASCADE);
1993                AlterTableOperation::DropColumn {
1994                    column_name,
1995                    if_exists,
1996                    cascade,
1997                }
1998            }
1999        } else if self.parse_keyword(Keyword::PARTITION) {
2000            self.expect_token(&Token::LParen)?;
2001            let before = self.parse_comma_separated(Parser::parse_expr)?;
2002            self.expect_token(&Token::RParen)?;
2003            self.expect_keyword(Keyword::RENAME)?;
2004            self.expect_keywords(&[Keyword::TO, Keyword::PARTITION])?;
2005            self.expect_token(&Token::LParen)?;
2006            let renames = self.parse_comma_separated(Parser::parse_expr)?;
2007            self.expect_token(&Token::RParen)?;
2008            AlterTableOperation::RenamePartitions {
2009                old_partitions: before,
2010                new_partitions: renames,
2011            }
2012        } else if self.parse_keyword(Keyword::CHANGE) {
2013            let _ = self.parse_keyword(Keyword::COLUMN);
2014            let old_name = self.parse_identifier()?;
2015            let new_name = self.parse_identifier()?;
2016            let data_type = self.parse_data_type()?;
2017            let mut options = vec![];
2018            while let Some(option) = self.parse_optional_column_option()? {
2019                options.push(option);
2020            }
2021
2022            AlterTableOperation::ChangeColumn {
2023                old_name,
2024                new_name,
2025                data_type,
2026                options,
2027            }
2028        } else if self.parse_keyword(Keyword::ALTER) {
2029            let _ = self.parse_keyword(Keyword::COLUMN);
2030            let column_name = self.parse_identifier()?;
2031            let is_postgresql = dialect_of!(self is PostgreSqlDialect);
2032
2033            let op = if self.parse_keywords(&[Keyword::SET, Keyword::NOT, Keyword::NULL]) {
2034                AlterColumnOperation::SetNotNull {}
2035            } else if self.parse_keywords(&[Keyword::DROP, Keyword::NOT, Keyword::NULL]) {
2036                AlterColumnOperation::DropNotNull {}
2037            } else if self.parse_keywords(&[Keyword::SET, Keyword::DEFAULT]) {
2038                AlterColumnOperation::SetDefault {
2039                    value: self.parse_expr()?,
2040                }
2041            } else if self.parse_keywords(&[Keyword::DROP, Keyword::DEFAULT]) {
2042                AlterColumnOperation::DropDefault {}
2043            } else if self.parse_keywords(&[Keyword::SET, Keyword::DATA, Keyword::TYPE])
2044                || (is_postgresql && self.parse_keyword(Keyword::TYPE))
2045            {
2046                let data_type = self.parse_data_type()?;
2047                let using = if is_postgresql && self.parse_keyword(Keyword::USING) {
2048                    Some(self.parse_expr()?)
2049                } else {
2050                    None
2051                };
2052                AlterColumnOperation::SetDataType { data_type, using }
2053            } else {
2054                return self.expected(
2055                    "SET/DROP NOT NULL, SET DEFAULT, SET DATA TYPE after ALTER COLUMN",
2056                    self.peek_token(),
2057                );
2058            };
2059            AlterTableOperation::AlterColumn { column_name, op }
2060        } else {
2061            return self.expected(
2062                "ADD, RENAME, PARTITION or DROP after ALTER TABLE",
2063                self.peek_token(),
2064            );
2065        };
2066        Ok(Statement::AlterTable {
2067            name: table_name,
2068            operation,
2069        })
2070    }
2071
2072    /// Parse a copy statement
2073    pub fn parse_copy(&mut self) -> Result<Statement, ParserError> {
2074        let table_name = self.parse_object_name()?;
2075        let columns = self.parse_parenthesized_column_list(Optional)?;
2076        self.expect_keywords(&[Keyword::FROM, Keyword::STDIN])?;
2077        self.expect_token(&Token::SemiColon)?;
2078        let values = self.parse_tsv();
2079        Ok(Statement::Copy {
2080            table_name,
2081            columns,
2082            values,
2083        })
2084    }
2085
2086    /// Parse a tab separated values in
2087    /// COPY payload
2088    fn parse_tsv(&mut self) -> Vec<Option<String>> {
2089        self.parse_tab_value()
2090    }
2091
2092    fn parse_tab_value(&mut self) -> Vec<Option<String>> {
2093        let mut values = vec![];
2094        let mut content = String::from("");
2095        while let Some(t) = self.next_token_no_skip() {
2096            match t {
2097                Token::Whitespace(Whitespace::Tab) => {
2098                    values.push(Some(content.to_string()));
2099                    content.clear();
2100                }
2101                Token::Whitespace(Whitespace::Newline) => {
2102                    values.push(Some(content.to_string()));
2103                    content.clear();
2104                }
2105                Token::Backslash => {
2106                    if self.consume_token(&Token::Period) {
2107                        return values;
2108                    }
2109                    if let Token::Word(w) = self.next_token() {
2110                        if w.value == "N" {
2111                            values.push(None);
2112                        }
2113                    }
2114                }
2115                _ => {
2116                    content.push_str(&t.to_string());
2117                }
2118            }
2119        }
2120        values
2121    }
2122
2123    /// Parse a literal value (numbers, strings, date/time, booleans)
2124    fn parse_value(&mut self) -> Result<Value, ParserError> {
2125        match self.next_token() {
2126            Token::Word(w) => match w.keyword {
2127                Keyword::TRUE => Ok(Value::Boolean(true)),
2128                Keyword::FALSE => Ok(Value::Boolean(false)),
2129                Keyword::NULL => Ok(Value::Null),
2130                Keyword::NoKeyword if w.quote_style.is_some() => match w.quote_style {
2131                    Some('"') => Ok(Value::DoubleQuotedString(w.value)),
2132                    Some('\'') => Ok(Value::SingleQuotedString(w.value)),
2133                    _ => self.expected("A value?", Token::Word(w))?,
2134                },
2135                _ => self.expected("a concrete value", Token::Word(w)),
2136            },
2137            // The call to n.parse() returns a bigdecimal when the
2138            // bigdecimal feature is enabled, and is otherwise a no-op
2139            // (i.e., it returns the input string).
2140            Token::Number(ref n, l) => match n.parse() {
2141                Ok(n) => Ok(Value::Number(n, l)),
2142                Err(e) => parser_err!(format!("Could not parse '{}' as number: {}", n, e)),
2143            },
2144            Token::SingleQuotedString(ref s) => Ok(Value::SingleQuotedString(s.to_string())),
2145            Token::NationalStringLiteral(ref s) => Ok(Value::NationalStringLiteral(s.to_string())),
2146            Token::HexStringLiteral(ref s) => Ok(Value::HexStringLiteral(s.to_string())),
2147            Token::Placeholder(ref s) => Ok(Value::Placeholder(s.to_string())),
2148            unexpected => self.expected("a value", unexpected),
2149        }
2150    }
2151
2152    pub fn parse_number_value(&mut self) -> Result<Value, ParserError> {
2153        match self.parse_value()? {
2154            v @ Value::Number(_, _) => Ok(v),
2155            _ => {
2156                self.prev_token();
2157                self.expected("literal number", self.peek_token())
2158            }
2159        }
2160    }
2161
2162    /// Parse an unsigned literal integer/long
2163    pub fn parse_literal_uint(&mut self) -> Result<u64, ParserError> {
2164        match self.next_token() {
2165            Token::Number(s, _) => s.parse::<u64>().map_err(|e| {
2166                ParserError::ParserError(format!("Could not parse '{}' as u64: {}", s, e))
2167            }),
2168            unexpected => self.expected("literal int", unexpected),
2169        }
2170    }
2171
2172    /// Parse a literal string
2173    pub fn parse_literal_string(&mut self) -> Result<String, ParserError> {
2174        match self.next_token() {
2175            Token::Word(Word { value, keyword, .. }) if keyword == Keyword::NoKeyword => Ok(value),
2176            Token::SingleQuotedString(s) => Ok(s),
2177            unexpected => self.expected("literal string", unexpected),
2178        }
2179    }
2180
2181    /// Parse a map key string
2182    pub fn parse_map_key(&mut self) -> Result<Expr, ParserError> {
2183        match self.next_token() {
2184            Token::Word(Word { value, keyword, .. }) if keyword == Keyword::NoKeyword => {
2185                if self.peek_token() == Token::LParen {
2186                    return self.parse_function(ObjectName(vec![Ident::new(value)]));
2187                }
2188                Ok(Expr::Value(Value::SingleQuotedString(value)))
2189            }
2190            Token::SingleQuotedString(s) => Ok(Expr::Value(Value::SingleQuotedString(s))),
2191            #[cfg(not(feature = "bigdecimal"))]
2192            Token::Number(s, _) => Ok(Expr::Value(Value::Number(s, false))),
2193            #[cfg(feature = "bigdecimal")]
2194            Token::Number(s, _) => Ok(Expr::Value(Value::Number(s.parse().unwrap(), false))),
2195            unexpected => self.expected("literal string, number or function", unexpected),
2196        }
2197    }
2198
2199    /// Parse a SQL datatype (in the context of a CREATE TABLE statement for example)
2200    pub fn parse_data_type(&mut self) -> Result<DataType, ParserError> {
2201        match self.next_token() {
2202            Token::Word(w) => match w.keyword {
2203                Keyword::BOOLEAN => Ok(DataType::Boolean),
2204                Keyword::FLOAT => Ok(DataType::Float(self.parse_optional_precision()?)),
2205                Keyword::REAL => Ok(DataType::Real),
2206                Keyword::DOUBLE => {
2207                    let _ = self.parse_keyword(Keyword::PRECISION);
2208                    Ok(DataType::Double)
2209                }
2210                Keyword::TINYINT => Ok(DataType::TinyInt(self.parse_optional_precision()?)),
2211                Keyword::SMALLINT => Ok(DataType::SmallInt(self.parse_optional_precision()?)),
2212                Keyword::INT | Keyword::INTEGER => {
2213                    Ok(DataType::Int(self.parse_optional_precision()?))
2214                }
2215                Keyword::BIGINT => Ok(DataType::BigInt(self.parse_optional_precision()?)),
2216                Keyword::VARCHAR => Ok(DataType::Varchar(self.parse_optional_precision()?)),
2217                Keyword::CHAR | Keyword::CHARACTER => {
2218                    if self.parse_keyword(Keyword::VARYING) {
2219                        Ok(DataType::Varchar(self.parse_optional_precision()?))
2220                    } else {
2221                        Ok(DataType::Char(self.parse_optional_precision()?))
2222                    }
2223                }
2224                Keyword::UUID => Ok(DataType::Uuid),
2225                Keyword::DATE => Ok(DataType::Date),
2226                Keyword::TIMESTAMP => {
2227                    // TBD: we throw away "with/without timezone" information
2228                    if self.parse_keyword(Keyword::WITH) || self.parse_keyword(Keyword::WITHOUT) {
2229                        self.expect_keywords(&[Keyword::TIME, Keyword::ZONE])?;
2230                    }
2231                    Ok(DataType::Timestamp)
2232                }
2233                Keyword::TIME => {
2234                    // TBD: we throw away "with/without timezone" information
2235                    if self.parse_keyword(Keyword::WITH) || self.parse_keyword(Keyword::WITHOUT) {
2236                        self.expect_keywords(&[Keyword::TIME, Keyword::ZONE])?;
2237                    }
2238                    Ok(DataType::Time)
2239                }
2240                // Interval types can be followed by a complicated interval
2241                // qualifier that we don't currently support. See
2242                // parse_interval_literal for a taste.
2243                Keyword::INTERVAL => Ok(DataType::Interval),
2244                Keyword::REGCLASS => Ok(DataType::Regclass),
2245                Keyword::STRING => Ok(DataType::String),
2246                Keyword::TEXT => {
2247                    if self.consume_token(&Token::LBracket) {
2248                        // Note: this is postgresql-specific
2249                        self.expect_token(&Token::RBracket)?;
2250                        Ok(DataType::Array(Box::new(DataType::Text)))
2251                    } else {
2252                        Ok(DataType::Text)
2253                    }
2254                }
2255                Keyword::BYTEA => Ok(DataType::Bytea),
2256                Keyword::NUMERIC | Keyword::DECIMAL | Keyword::DEC => {
2257                    let (precision, scale) = self.parse_optional_precision_scale()?;
2258                    Ok(DataType::Decimal(precision, scale))
2259                }
2260                _ => {
2261                    self.prev_token();
2262                    let type_name = self.parse_object_name()?;
2263                    Ok(DataType::Custom(type_name))
2264                }
2265            },
2266            unexpected => self.expected("a data type name", unexpected),
2267        }
2268    }
2269
2270    /// Parse `AS identifier` (or simply `identifier` if it's not a reserved keyword)
2271    /// Some examples with aliases: `SELECT 1 foo`, `SELECT COUNT(*) AS cnt`,
2272    /// `SELECT ... FROM t1 foo, t2 bar`, `SELECT ... FROM (...) AS bar`
2273    pub fn parse_optional_alias(
2274        &mut self,
2275        reserved_kwds: &[Keyword],
2276    ) -> Result<Option<Ident>, ParserError> {
2277        let after_as = self.parse_keyword(Keyword::AS);
2278        match self.next_token() {
2279            // Accept any identifier after `AS` (though many dialects have restrictions on
2280            // keywords that may appear here). If there's no `AS`: don't parse keywords,
2281            // which may start a construct allowed in this position, to be parsed as aliases.
2282            // (For example, in `FROM t1 JOIN` the `JOIN` will always be parsed as a keyword,
2283            // not an alias.)
2284            Token::Word(w) if after_as || !reserved_kwds.contains(&w.keyword) => {
2285                Ok(Some(w.to_ident()))
2286            }
2287            // MSSQL supports single-quoted strings as aliases for columns
2288            // We accept them as table aliases too, although MSSQL does not.
2289            //
2290            // Note, that this conflicts with an obscure rule from the SQL
2291            // standard, which we don't implement:
2292            // https://crate.io/docs/sql-99/en/latest/chapters/07.html#character-string-literal-s
2293            //    "[Obscure Rule] SQL allows you to break a long <character
2294            //    string literal> up into two or more smaller <character string
2295            //    literal>s, split by a <separator> that includes a newline
2296            //    character. When it sees such a <literal>, your DBMS will
2297            //    ignore the <separator> and treat the multiple strings as
2298            //    a single <literal>."
2299            Token::SingleQuotedString(s) => Ok(Some(Ident::with_quote('\'', s))),
2300            not_an_ident => {
2301                if after_as {
2302                    return self.expected("an identifier after AS", not_an_ident);
2303                }
2304                self.prev_token();
2305                Ok(None) // no alias found
2306            }
2307        }
2308    }
2309
2310    /// Parse `AS identifier` when the AS is describing a table-valued object,
2311    /// like in `... FROM generate_series(1, 10) AS t (col)`. In this case
2312    /// the alias is allowed to optionally name the columns in the table, in
2313    /// addition to the table itself.
2314    pub fn parse_optional_table_alias(
2315        &mut self,
2316        reserved_kwds: &[Keyword],
2317    ) -> Result<Option<TableAlias>, ParserError> {
2318        match self.parse_optional_alias(reserved_kwds)? {
2319            Some(name) => {
2320                let columns = self.parse_parenthesized_column_list(Optional)?;
2321                Ok(Some(TableAlias { name, columns }))
2322            }
2323            None => Ok(None),
2324        }
2325    }
2326
2327    /// Parse a possibly qualified, possibly quoted identifier, e.g.
2328    /// `foo` or `myschema."table"
2329    pub fn parse_object_name(&mut self) -> Result<ObjectName, ParserError> {
2330        let mut idents = vec![];
2331        loop {
2332            idents.push(self.parse_identifier()?);
2333            if !self.consume_token(&Token::Period) {
2334                break;
2335            }
2336        }
2337        Ok(ObjectName(idents))
2338    }
2339
2340    /// Parse identifiers strictly i.e. don't parse keywords
2341    pub fn parse_identifiers_non_keywords(&mut self) -> Result<Vec<Ident>, ParserError> {
2342        let mut idents = vec![];
2343        loop {
2344            match self.peek_token() {
2345                Token::Word(w) => {
2346                    if w.keyword != Keyword::NoKeyword {
2347                        break;
2348                    }
2349
2350                    idents.push(w.to_ident());
2351                }
2352                Token::EOF | Token::Eq => break,
2353                _ => {}
2354            }
2355
2356            self.next_token();
2357        }
2358
2359        Ok(idents)
2360    }
2361
2362    /// Parse identifiers
2363    pub fn parse_identifiers(&mut self) -> Result<Vec<Ident>, ParserError> {
2364        let mut idents = vec![];
2365        loop {
2366            match self.next_token() {
2367                Token::Word(w) => {
2368                    idents.push(w.to_ident());
2369                }
2370                Token::EOF => break,
2371                _ => {}
2372            }
2373        }
2374
2375        Ok(idents)
2376    }
2377
2378    /// Parse a simple one-word identifier (possibly quoted, possibly a keyword)
2379    pub fn parse_identifier(&mut self) -> Result<Ident, ParserError> {
2380        match self.next_token() {
2381            Token::Word(w) => Ok(w.to_ident()),
2382            Token::SingleQuotedString(s) => Ok(Ident::with_quote('\'', s)),
2383            unexpected => self.expected("identifier", unexpected),
2384        }
2385    }
2386
2387    /// Parse a parenthesized comma-separated list of unqualified, possibly quoted identifiers
2388    pub fn parse_parenthesized_column_list(
2389        &mut self,
2390        optional: IsOptional,
2391    ) -> Result<Vec<Ident>, ParserError> {
2392        if self.consume_token(&Token::LParen) {
2393            let cols = self.parse_comma_separated(Parser::parse_identifier)?;
2394            self.expect_token(&Token::RParen)?;
2395            Ok(cols)
2396        } else if optional == Optional {
2397            Ok(vec![])
2398        } else {
2399            self.expected("a list of columns in parentheses", self.peek_token())
2400        }
2401    }
2402
2403    pub fn parse_optional_precision(&mut self) -> Result<Option<u64>, ParserError> {
2404        if self.consume_token(&Token::LParen) {
2405            let n = self.parse_literal_uint()?;
2406            self.expect_token(&Token::RParen)?;
2407            Ok(Some(n))
2408        } else {
2409            Ok(None)
2410        }
2411    }
2412
2413    pub fn parse_optional_precision_scale(
2414        &mut self,
2415    ) -> Result<(Option<u64>, Option<u64>), ParserError> {
2416        if self.consume_token(&Token::LParen) {
2417            let n = self.parse_literal_uint()?;
2418            let scale = if self.consume_token(&Token::Comma) {
2419                Some(self.parse_literal_uint()?)
2420            } else {
2421                None
2422            };
2423            self.expect_token(&Token::RParen)?;
2424            Ok((Some(n), scale))
2425        } else {
2426            Ok((None, None))
2427        }
2428    }
2429
2430    pub fn parse_delete(&mut self) -> Result<Statement, ParserError> {
2431        self.expect_keyword(Keyword::FROM)?;
2432        let table_name = self.parse_object_name()?;
2433        let selection = if self.parse_keyword(Keyword::WHERE) {
2434            Some(self.parse_expr()?)
2435        } else {
2436            None
2437        };
2438
2439        Ok(Statement::Delete {
2440            table_name,
2441            selection,
2442        })
2443    }
2444
2445    pub fn parse_explain(&mut self, describe_alias: bool) -> Result<Statement, ParserError> {
2446        let analyze = self.parse_keyword(Keyword::ANALYZE);
2447        let verbose = self.parse_keyword(Keyword::VERBOSE);
2448
2449        if let Some(statement) = self.maybe_parse(|parser| parser.parse_statement()) {
2450            Ok(Statement::Explain {
2451                describe_alias,
2452                analyze,
2453                verbose,
2454                statement: Box::new(statement),
2455            })
2456        } else {
2457            let table_name = self.parse_object_name()?;
2458
2459            Ok(Statement::ExplainTable {
2460                describe_alias,
2461                table_name,
2462            })
2463        }
2464    }
2465
2466    /// Parse a query expression, i.e. a `SELECT` statement optionally
2467    /// preceeded with some `WITH` CTE declarations and optionally followed
2468    /// by `ORDER BY`. Unlike some other parse_... methods, this one doesn't
2469    /// expect the initial keyword to be already consumed
2470    pub fn parse_query(&mut self) -> Result<Query, ParserError> {
2471        let with = if self.parse_keyword(Keyword::WITH) {
2472            Some(With {
2473                recursive: self.parse_keyword(Keyword::RECURSIVE),
2474                cte_tables: self.parse_comma_separated(Parser::parse_cte)?,
2475            })
2476        } else {
2477            None
2478        };
2479
2480        if !self.parse_keyword(Keyword::INSERT) {
2481            let body = self.parse_query_body(0)?;
2482
2483            let order_by = if self.parse_keywords(&[Keyword::ORDER, Keyword::BY]) {
2484                self.parse_comma_separated(Parser::parse_order_by_expr)?
2485            } else {
2486                vec![]
2487            };
2488
2489            let limit = if self.parse_keyword(Keyword::LIMIT) {
2490                self.parse_limit()?
2491            } else {
2492                None
2493            };
2494
2495            let offset = if self.parse_keyword(Keyword::OFFSET) {
2496                Some(self.parse_offset()?)
2497            } else {
2498                None
2499            };
2500
2501            let fetch = if self.parse_keyword(Keyword::FETCH) {
2502                Some(self.parse_fetch()?)
2503            } else {
2504                None
2505            };
2506
2507            let lock = if self.parse_keyword(Keyword::FOR) {
2508                Some(self.parse_lock()?)
2509            } else {
2510                None
2511            };
2512
2513            Ok(Query {
2514                with,
2515                body,
2516                order_by,
2517                limit,
2518                offset,
2519                fetch,
2520                lock,
2521            })
2522        } else {
2523            let insert = self.parse_insert()?;
2524
2525            Ok(Query {
2526                with,
2527                body: SetExpr::Insert(insert),
2528                limit: None,
2529                order_by: vec![],
2530                offset: None,
2531                fetch: None,
2532                lock: None,
2533            })
2534        }
2535    }
2536
2537    /// Parse a CTE (`alias [( col1, col2, ... )] AS (subquery)`)
2538    fn parse_cte(&mut self) -> Result<Cte, ParserError> {
2539        let name = self.parse_identifier()?;
2540
2541        let mut cte = if self.parse_keyword(Keyword::AS) {
2542            self.expect_token(&Token::LParen)?;
2543            let query = self.parse_query()?;
2544            self.expect_token(&Token::RParen)?;
2545            let alias = TableAlias {
2546                name,
2547                columns: vec![],
2548            };
2549            Cte {
2550                alias,
2551                query,
2552                from: None,
2553            }
2554        } else {
2555            let columns = self.parse_parenthesized_column_list(Optional)?;
2556            self.expect_keyword(Keyword::AS)?;
2557            self.expect_token(&Token::LParen)?;
2558            let query = self.parse_query()?;
2559            self.expect_token(&Token::RParen)?;
2560            let alias = TableAlias { name, columns };
2561            Cte {
2562                alias,
2563                query,
2564                from: None,
2565            }
2566        };
2567        if self.parse_keyword(Keyword::FROM) {
2568            cte.from = Some(self.parse_identifier()?);
2569        }
2570        Ok(cte)
2571    }
2572
2573    /// Parse a "query body", which is an expression with roughly the
2574    /// following grammar:
2575    /// ```text
2576    ///   query_body ::= restricted_select | '(' subquery ')' | set_operation
2577    ///   restricted_select ::= 'SELECT' [expr_list] [ from ] [ where ] [ groupby_having ]
2578    ///   subquery ::= query_body [ order_by_limit ]
2579    ///   set_operation ::= query_body { 'UNION' | 'EXCEPT' | 'INTERSECT' } [ 'ALL' ] query_body
2580    /// ```
2581    fn parse_query_body(&mut self, precedence: u8) -> Result<SetExpr, ParserError> {
2582        // We parse the expression using a Pratt parser, as in `parse_expr()`.
2583        // Start by parsing a restricted SELECT or a `(subquery)`:
2584        let mut expr = if self.parse_keyword(Keyword::SELECT) {
2585            SetExpr::Select(Box::new(self.parse_select()?))
2586        } else if self.consume_token(&Token::LParen) {
2587            // CTEs are not allowed here, but the parser currently accepts them
2588            let subquery = self.parse_query()?;
2589            self.expect_token(&Token::RParen)?;
2590            SetExpr::Query(Box::new(subquery))
2591        } else if self.parse_keyword(Keyword::VALUES) {
2592            SetExpr::Values(self.parse_values()?)
2593        } else {
2594            return self.expected(
2595                "SELECT, VALUES, or a subquery in the query body",
2596                self.peek_token(),
2597            );
2598        };
2599
2600        loop {
2601            // The query can be optionally followed by a set operator:
2602            let op = self.parse_set_operator(&self.peek_token());
2603            let next_precedence = match op {
2604                // UNION and EXCEPT have the same binding power and evaluate left-to-right
2605                Some(SetOperator::Union) | Some(SetOperator::Except) => 10,
2606                // INTERSECT has higher precedence than UNION/EXCEPT
2607                Some(SetOperator::Intersect) => 20,
2608                // Unexpected token or EOF => stop parsing the query body
2609                None => break,
2610            };
2611            if precedence >= next_precedence {
2612                break;
2613            }
2614            self.next_token(); // skip past the set operator
2615            expr = SetExpr::SetOperation {
2616                left: Box::new(expr),
2617                op: op.unwrap(),
2618                all: self.parse_keyword(Keyword::ALL),
2619                right: Box::new(self.parse_query_body(next_precedence)?),
2620            };
2621        }
2622
2623        Ok(expr)
2624    }
2625
2626    fn parse_set_operator(&mut self, token: &Token) -> Option<SetOperator> {
2627        match token {
2628            Token::Word(w) if w.keyword == Keyword::UNION => Some(SetOperator::Union),
2629            Token::Word(w) if w.keyword == Keyword::EXCEPT => Some(SetOperator::Except),
2630            Token::Word(w) if w.keyword == Keyword::INTERSECT => Some(SetOperator::Intersect),
2631            _ => None,
2632        }
2633    }
2634
2635    /// Parse a restricted `SELECT` statement (no CTEs / `UNION` / `ORDER BY`),
2636    /// assuming the initial `SELECT` was already consumed
2637    pub fn parse_select(&mut self) -> Result<Select, ParserError> {
2638        let distinct = self.parse_all_or_distinct()?;
2639
2640        let top = if self.parse_keyword(Keyword::TOP) {
2641            Some(self.parse_top()?)
2642        } else {
2643            None
2644        };
2645
2646        let projection = self.parse_comma_separated(Parser::parse_select_item)?;
2647
2648        // Note that for keywords to be properly handled here, they need to be
2649        // added to `RESERVED_FOR_COLUMN_ALIAS` / `RESERVED_FOR_TABLE_ALIAS`,
2650        // otherwise they may be parsed as an alias as part of the `projection`
2651        // or `from`.
2652
2653        let from = if self.parse_keyword(Keyword::FROM) {
2654            self.parse_comma_separated(Parser::parse_table_and_joins)?
2655        } else {
2656            vec![]
2657        };
2658        let mut lateral_views = vec![];
2659        loop {
2660            if self.parse_keywords(&[Keyword::LATERAL, Keyword::VIEW]) {
2661                let outer = self.parse_keyword(Keyword::OUTER);
2662                let lateral_view = self.parse_expr()?;
2663                let lateral_view_name = self.parse_object_name()?;
2664                let lateral_col_alias = self
2665                    .parse_comma_separated(|parser| {
2666                        parser.parse_optional_alias(&[
2667                            Keyword::WHERE,
2668                            Keyword::GROUP,
2669                            Keyword::CLUSTER,
2670                            Keyword::HAVING,
2671                            Keyword::LATERAL,
2672                        ]) // This couldn't possibly be a bad idea
2673                    })?
2674                    .into_iter()
2675                    .flatten()
2676                    .collect();
2677
2678                lateral_views.push(LateralView {
2679                    lateral_view,
2680                    lateral_view_name,
2681                    lateral_col_alias,
2682                    outer,
2683                });
2684            } else {
2685                break;
2686            }
2687        }
2688
2689        let selection = if self.parse_keyword(Keyword::WHERE) {
2690            Some(self.parse_expr()?)
2691        } else {
2692            None
2693        };
2694
2695        let group_by = if self.parse_keywords(&[Keyword::GROUP, Keyword::BY]) {
2696            self.parse_comma_separated(Parser::parse_group_by_expr)?
2697        } else {
2698            vec![]
2699        };
2700
2701        let cluster_by = if self.parse_keywords(&[Keyword::CLUSTER, Keyword::BY]) {
2702            self.parse_comma_separated(Parser::parse_expr)?
2703        } else {
2704            vec![]
2705        };
2706
2707        let distribute_by = if self.parse_keywords(&[Keyword::DISTRIBUTE, Keyword::BY]) {
2708            self.parse_comma_separated(Parser::parse_expr)?
2709        } else {
2710            vec![]
2711        };
2712
2713        let sort_by = if self.parse_keywords(&[Keyword::SORT, Keyword::BY]) {
2714            self.parse_comma_separated(Parser::parse_expr)?
2715        } else {
2716            vec![]
2717        };
2718
2719        let having = if self.parse_keyword(Keyword::HAVING) {
2720            Some(self.parse_expr()?)
2721        } else {
2722            None
2723        };
2724
2725        Ok(Select {
2726            distinct,
2727            top,
2728            projection,
2729            from,
2730            lateral_views,
2731            selection,
2732            group_by,
2733            cluster_by,
2734            distribute_by,
2735            sort_by,
2736            having,
2737        })
2738    }
2739
2740    pub fn parse_set(&mut self) -> Result<Statement, ParserError> {
2741        let modifier =
2742            self.parse_one_of_keywords(&[Keyword::SESSION, Keyword::LOCAL, Keyword::HIVEVAR]);
2743        if let Some(Keyword::HIVEVAR) = modifier {
2744            self.expect_token(&Token::Colon)?;
2745        }
2746        let variable = self.parse_identifier()?;
2747        if self.consume_token(&Token::Eq) || self.parse_keyword(Keyword::TO) {
2748            let mut values = vec![];
2749            loop {
2750                let token = self.peek_token();
2751                let value = match (self.parse_value(), token) {
2752                    (Ok(value), _) => SetVariableValue::Literal(value),
2753                    (Err(_), Token::Word(ident)) => SetVariableValue::Ident(ident.to_ident()),
2754                    (Err(_), unexpected) => self.expected("variable value", unexpected)?,
2755                };
2756                values.push(value);
2757                if self.consume_token(&Token::Comma) {
2758                    continue;
2759                }
2760                return Ok(Statement::SetVariable {
2761                    local: modifier == Some(Keyword::LOCAL),
2762                    hivevar: Some(Keyword::HIVEVAR) == modifier,
2763                    variable,
2764                    value: values,
2765                });
2766            }
2767        } else if variable.value == "CHARACTERISTICS" {
2768            self.expect_keywords(&[Keyword::AS, Keyword::TRANSACTION])?;
2769            Ok(Statement::SetTransaction {
2770                modes: self.parse_transaction_modes()?,
2771                snapshot: None,
2772                session: true,
2773            })
2774        } else if variable.value == "TRANSACTION" && modifier.is_none() {
2775            if self.parse_keyword(Keyword::SNAPSHOT) {
2776                let snaphot_id = self.parse_value()?;
2777                return Ok(Statement::SetTransaction {
2778                    modes: vec![],
2779                    snapshot: Some(snaphot_id),
2780                    session: false,
2781                });
2782            }
2783            Ok(Statement::SetTransaction {
2784                modes: self.parse_transaction_modes()?,
2785                snapshot: None,
2786                session: false,
2787            })
2788        } else {
2789            self.expected("equals sign or TO", self.peek_token())
2790        }
2791    }
2792
2793    pub fn parse_show(&mut self) -> Result<Statement, ParserError> {
2794        if self
2795            .parse_one_of_keywords(&[
2796                Keyword::EXTENDED,
2797                Keyword::FULL,
2798                Keyword::COLUMNS,
2799                Keyword::FIELDS,
2800            ])
2801            .is_some()
2802        {
2803            self.prev_token();
2804            Ok(self.parse_show_columns()?)
2805        } else if self.parse_one_of_keywords(&[Keyword::CREATE]).is_some() {
2806            Ok(self.parse_show_create()?)
2807        } else {
2808            Ok(Statement::ShowVariable {
2809                variable: self.parse_identifiers()?,
2810            })
2811        }
2812    }
2813
2814    fn parse_show_create(&mut self) -> Result<Statement, ParserError> {
2815        let obj_type = match self.expect_one_of_keywords(&[
2816            Keyword::TABLE,
2817            Keyword::TRIGGER,
2818            Keyword::FUNCTION,
2819            Keyword::PROCEDURE,
2820            Keyword::EVENT,
2821        ])? {
2822            Keyword::TABLE => Ok(ShowCreateObject::Table),
2823            Keyword::TRIGGER => Ok(ShowCreateObject::Trigger),
2824            Keyword::FUNCTION => Ok(ShowCreateObject::Function),
2825            Keyword::PROCEDURE => Ok(ShowCreateObject::Procedure),
2826            Keyword::EVENT => Ok(ShowCreateObject::Event),
2827            keyword => Err(ParserError::ParserError(format!(
2828                "Unable to map keyword to ShowCreateObject: {:?}",
2829                keyword
2830            ))),
2831        }?;
2832
2833        let obj_name = self.parse_object_name()?;
2834
2835        Ok(Statement::ShowCreate { obj_type, obj_name })
2836    }
2837
2838    fn parse_show_columns(&mut self) -> Result<Statement, ParserError> {
2839        let extended = self.parse_keyword(Keyword::EXTENDED);
2840        let full = self.parse_keyword(Keyword::FULL);
2841        self.expect_one_of_keywords(&[Keyword::COLUMNS, Keyword::FIELDS])?;
2842        self.expect_one_of_keywords(&[Keyword::FROM, Keyword::IN])?;
2843        let table_name = self.parse_object_name()?;
2844        // MySQL also supports FROM <database> here. In other words, MySQL
2845        // allows both FROM <table> FROM <database> and FROM <database>.<table>,
2846        // while we only support the latter for now.
2847        let filter = self.parse_show_statement_filter()?;
2848        Ok(Statement::ShowColumns {
2849            extended,
2850            full,
2851            table_name,
2852            filter,
2853        })
2854    }
2855
2856    fn parse_show_statement_filter(&mut self) -> Result<Option<ShowStatementFilter>, ParserError> {
2857        if self.parse_keyword(Keyword::LIKE) {
2858            Ok(Some(ShowStatementFilter::Like(
2859                self.parse_literal_string()?,
2860            )))
2861        } else if self.parse_keyword(Keyword::ILIKE) {
2862            Ok(Some(ShowStatementFilter::ILike(
2863                self.parse_literal_string()?,
2864            )))
2865        } else if self.parse_keyword(Keyword::WHERE) {
2866            Ok(Some(ShowStatementFilter::Where(self.parse_expr()?)))
2867        } else {
2868            Ok(None)
2869        }
2870    }
2871
2872    pub fn parse_table_and_joins(&mut self) -> Result<TableWithJoins, ParserError> {
2873        let relation = self.parse_table_factor()?;
2874
2875        // Note that for keywords to be properly handled here, they need to be
2876        // added to `RESERVED_FOR_TABLE_ALIAS`, otherwise they may be parsed as
2877        // a table alias.
2878        let mut joins = vec![];
2879        loop {
2880            let join = if self.parse_keyword(Keyword::CROSS) {
2881                let join_operator = if self.parse_keyword(Keyword::JOIN) {
2882                    JoinOperator::CrossJoin
2883                } else if self.parse_keyword(Keyword::APPLY) {
2884                    // MSSQL extension, similar to CROSS JOIN LATERAL
2885                    JoinOperator::CrossApply
2886                } else {
2887                    return self.expected("JOIN or APPLY after CROSS", self.peek_token());
2888                };
2889                Join {
2890                    relation: self.parse_table_factor()?,
2891                    join_operator,
2892                }
2893            } else if self.parse_keyword(Keyword::OUTER) {
2894                // MSSQL extension, similar to LEFT JOIN LATERAL .. ON 1=1
2895                self.expect_keyword(Keyword::APPLY)?;
2896                Join {
2897                    relation: self.parse_table_factor()?,
2898                    join_operator: JoinOperator::OuterApply,
2899                }
2900            } else {
2901                let natural = self.parse_keyword(Keyword::NATURAL);
2902                let peek_keyword = if let Token::Word(w) = self.peek_token() {
2903                    w.keyword
2904                } else {
2905                    Keyword::NoKeyword
2906                };
2907
2908                let join_operator_type = match peek_keyword {
2909                    Keyword::INNER | Keyword::JOIN => {
2910                        let _ = self.parse_keyword(Keyword::INNER);
2911                        self.expect_keyword(Keyword::JOIN)?;
2912                        JoinOperator::Inner
2913                    }
2914                    kw @ Keyword::LEFT | kw @ Keyword::RIGHT | kw @ Keyword::FULL => {
2915                        let _ = self.next_token();
2916                        let _ = self.parse_keyword(Keyword::OUTER);
2917                        self.expect_keyword(Keyword::JOIN)?;
2918                        match kw {
2919                            Keyword::LEFT => JoinOperator::LeftOuter,
2920                            Keyword::RIGHT => JoinOperator::RightOuter,
2921                            Keyword::FULL => JoinOperator::FullOuter,
2922                            _ => unreachable!(),
2923                        }
2924                    }
2925                    Keyword::OUTER => {
2926                        return self.expected("LEFT, RIGHT, or FULL", self.peek_token());
2927                    }
2928                    _ if natural => {
2929                        return self.expected("a join type after NATURAL", self.peek_token());
2930                    }
2931                    _ => break,
2932                };
2933                let relation = self.parse_table_factor()?;
2934                let join_constraint = self.parse_join_constraint(natural)?;
2935                Join {
2936                    relation,
2937                    join_operator: join_operator_type(join_constraint),
2938                }
2939            };
2940            joins.push(join);
2941        }
2942        Ok(TableWithJoins { relation, joins })
2943    }
2944
2945    /// A table name or a parenthesized subquery, followed by optional `[AS] alias`
2946    pub fn parse_table_factor(&mut self) -> Result<TableFactor, ParserError> {
2947        if self.parse_keyword(Keyword::LATERAL) {
2948            // LATERAL must always be followed by a subquery.
2949            if !self.consume_token(&Token::LParen) {
2950                self.expected("subquery after LATERAL", self.peek_token())?;
2951            }
2952            self.parse_derived_table_factor(Lateral)
2953        } else if self.parse_keyword(Keyword::TABLE) {
2954            // parse table function (SELECT * FROM TABLE (<expr>) [ AS <alias> ])
2955            self.expect_token(&Token::LParen)?;
2956            let expr = self.parse_expr()?;
2957            self.expect_token(&Token::RParen)?;
2958            let alias = self.parse_optional_table_alias(keywords::RESERVED_FOR_TABLE_ALIAS)?;
2959            Ok(TableFactor::TableFunction { expr, alias })
2960        } else if self.consume_token(&Token::LParen) {
2961            // A left paren introduces either a derived table (i.e., a subquery)
2962            // or a nested join. It's nearly impossible to determine ahead of
2963            // time which it is... so we just try to parse both.
2964            //
2965            // Here's an example that demonstrates the complexity:
2966            //                     /-------------------------------------------------------\
2967            //                     | /-----------------------------------\                 |
2968            //     SELECT * FROM ( ( ( (SELECT 1) UNION (SELECT 2) ) AS t1 NATURAL JOIN t2 ) )
2969            //                   ^ ^ ^ ^
2970            //                   | | | |
2971            //                   | | | |
2972            //                   | | | (4) belongs to a SetExpr::Query inside the subquery
2973            //                   | | (3) starts a derived table (subquery)
2974            //                   | (2) starts a nested join
2975            //                   (1) an additional set of parens around a nested join
2976            //
2977
2978            // If the recently consumed '(' starts a derived table, the call to
2979            // `parse_derived_table_factor` below will return success after parsing the
2980            // subquery, followed by the closing ')', and the alias of the derived table.
2981            // In the example above this is case (3).
2982            return_ok_if_some!(
2983                self.maybe_parse(|parser| parser.parse_derived_table_factor(NotLateral))
2984            );
2985            // A parsing error from `parse_derived_table_factor` indicates that the '(' we've
2986            // recently consumed does not start a derived table (cases 1, 2, or 4).
2987            // `maybe_parse` will ignore such an error and rewind to be after the opening '('.
2988
2989            // Inside the parentheses we expect to find an (A) table factor
2990            // followed by some joins or (B) another level of nesting.
2991            let mut table_and_joins = self.parse_table_and_joins()?;
2992
2993            #[allow(clippy::if_same_then_else)]
2994            if !table_and_joins.joins.is_empty() {
2995                self.expect_token(&Token::RParen)?;
2996                Ok(TableFactor::NestedJoin(Box::new(table_and_joins))) // (A)
2997            } else if let TableFactor::NestedJoin(_) = &table_and_joins.relation {
2998                // (B): `table_and_joins` (what we found inside the parentheses)
2999                // is a nested join `(foo JOIN bar)`, not followed by other joins.
3000                self.expect_token(&Token::RParen)?;
3001                Ok(TableFactor::NestedJoin(Box::new(table_and_joins)))
3002            } else if dialect_of!(self is SnowflakeDialect | GenericDialect) {
3003                // Dialect-specific behavior: Snowflake diverges from the
3004                // standard and from most of the other implementations by
3005                // allowing extra parentheses not only around a join (B), but
3006                // around lone table names (e.g. `FROM (mytable [AS alias])`)
3007                // and around derived tables (e.g. `FROM ((SELECT ...)
3008                // [AS alias])`) as well.
3009                self.expect_token(&Token::RParen)?;
3010
3011                if let Some(outer_alias) =
3012                    self.parse_optional_table_alias(keywords::RESERVED_FOR_TABLE_ALIAS)?
3013                {
3014                    // Snowflake also allows specifying an alias *after* parens
3015                    // e.g. `FROM (mytable) AS alias`
3016                    match &mut table_and_joins.relation {
3017                        TableFactor::Derived { alias, .. }
3018                        | TableFactor::Table { alias, .. }
3019                        | TableFactor::TableFunction { alias, .. } => {
3020                            // but not `FROM (mytable AS alias1) AS alias2`.
3021                            if let Some(inner_alias) = alias {
3022                                return Err(ParserError::ParserError(format!(
3023                                    "duplicate alias {}",
3024                                    inner_alias
3025                                )));
3026                            }
3027                            // Act as if the alias was specified normally next
3028                            // to the table name: `(mytable) AS alias` ->
3029                            // `(mytable AS alias)`
3030                            alias.replace(outer_alias);
3031                        }
3032                        TableFactor::NestedJoin(_) => unreachable!(),
3033                    };
3034                }
3035                // Do not store the extra set of parens in the AST
3036                Ok(table_and_joins.relation)
3037            } else {
3038                // The SQL spec prohibits derived tables and bare tables from
3039                // appearing alone in parentheses (e.g. `FROM (mytable)`)
3040                self.expected("joined table", self.peek_token())
3041            }
3042        } else {
3043            let name = self.parse_object_name()?;
3044            // Postgres, MSSQL: table-valued functions:
3045            let args = if self.consume_token(&Token::LParen) {
3046                self.parse_optional_args()?
3047            } else {
3048                vec![]
3049            };
3050            let alias = self.parse_optional_table_alias(keywords::RESERVED_FOR_TABLE_ALIAS)?;
3051            // MSSQL-specific table hints:
3052            let mut with_hints = vec![];
3053            if self.parse_keyword(Keyword::WITH) {
3054                if self.consume_token(&Token::LParen) {
3055                    with_hints = self.parse_comma_separated(Parser::parse_expr)?;
3056                    self.expect_token(&Token::RParen)?;
3057                } else {
3058                    // rewind, as WITH may belong to the next statement's CTE
3059                    self.prev_token();
3060                }
3061            };
3062            Ok(TableFactor::Table {
3063                name,
3064                alias,
3065                args,
3066                with_hints,
3067            })
3068        }
3069    }
3070
3071    pub fn parse_derived_table_factor(
3072        &mut self,
3073        lateral: IsLateral,
3074    ) -> Result<TableFactor, ParserError> {
3075        let subquery = Box::new(self.parse_query()?);
3076        self.expect_token(&Token::RParen)?;
3077        let alias = self.parse_optional_table_alias(keywords::RESERVED_FOR_TABLE_ALIAS)?;
3078        Ok(TableFactor::Derived {
3079            lateral: match lateral {
3080                Lateral => true,
3081                NotLateral => false,
3082            },
3083            subquery,
3084            alias,
3085        })
3086    }
3087
3088    fn parse_join_constraint(&mut self, natural: bool) -> Result<JoinConstraint, ParserError> {
3089        if natural {
3090            Ok(JoinConstraint::Natural)
3091        } else if self.parse_keyword(Keyword::ON) {
3092            let constraint = self.parse_expr()?;
3093            Ok(JoinConstraint::On(constraint))
3094        } else if self.parse_keyword(Keyword::USING) {
3095            let columns = self.parse_parenthesized_column_list(Mandatory)?;
3096            Ok(JoinConstraint::Using(columns))
3097        } else {
3098            Ok(JoinConstraint::None)
3099            //self.expected("ON, or USING after JOIN", self.peek_token())
3100        }
3101    }
3102
3103    /// Parse a GRANT statement.
3104    pub fn parse_grant(&mut self) -> Result<Statement, ParserError> {
3105        let (privileges, objects) = self.parse_grant_revoke_privileges_objects()?;
3106
3107        self.expect_keyword(Keyword::TO)?;
3108        let grantees = self.parse_comma_separated(Parser::parse_identifier)?;
3109
3110        let with_grant_option =
3111            self.parse_keywords(&[Keyword::WITH, Keyword::GRANT, Keyword::OPTION]);
3112
3113        let granted_by = self
3114            .parse_keywords(&[Keyword::GRANTED, Keyword::BY])
3115            .then(|| self.parse_identifier().unwrap());
3116
3117        Ok(Statement::Grant {
3118            privileges,
3119            objects,
3120            grantees,
3121            with_grant_option,
3122            granted_by,
3123        })
3124    }
3125
3126    fn parse_grant_revoke_privileges_objects(
3127        &mut self,
3128    ) -> Result<(Privileges, GrantObjects), ParserError> {
3129        let privileges = if self.parse_keyword(Keyword::ALL) {
3130            Privileges::All {
3131                with_privileges_keyword: self.parse_keyword(Keyword::PRIVILEGES),
3132            }
3133        } else {
3134            Privileges::Actions(
3135                self.parse_comma_separated(Parser::parse_grant_permission)?
3136                    .into_iter()
3137                    .map(|(kw, columns)| match kw {
3138                        Keyword::DELETE => Action::Delete,
3139                        Keyword::INSERT => Action::Insert { columns },
3140                        Keyword::REFERENCES => Action::References { columns },
3141                        Keyword::SELECT => Action::Select { columns },
3142                        Keyword::TRIGGER => Action::Trigger,
3143                        Keyword::TRUNCATE => Action::Truncate,
3144                        Keyword::UPDATE => Action::Update { columns },
3145                        Keyword::USAGE => Action::Usage,
3146                        _ => unreachable!(),
3147                    })
3148                    .collect(),
3149            )
3150        };
3151
3152        self.expect_keyword(Keyword::ON)?;
3153
3154        let objects = if self.parse_keywords(&[
3155            Keyword::ALL,
3156            Keyword::TABLES,
3157            Keyword::IN,
3158            Keyword::SCHEMA,
3159        ]) {
3160            GrantObjects::AllTablesInSchema {
3161                schemas: self.parse_comma_separated(Parser::parse_object_name)?,
3162            }
3163        } else if self.parse_keywords(&[
3164            Keyword::ALL,
3165            Keyword::SEQUENCES,
3166            Keyword::IN,
3167            Keyword::SCHEMA,
3168        ]) {
3169            GrantObjects::AllSequencesInSchema {
3170                schemas: self.parse_comma_separated(Parser::parse_object_name)?,
3171            }
3172        } else {
3173            let object_type =
3174                self.parse_one_of_keywords(&[Keyword::SEQUENCE, Keyword::SCHEMA, Keyword::TABLE]);
3175            let objects = self.parse_comma_separated(Parser::parse_object_name);
3176            match object_type {
3177                Some(Keyword::SCHEMA) => GrantObjects::Schemas(objects?),
3178                Some(Keyword::SEQUENCE) => GrantObjects::Sequences(objects?),
3179                Some(Keyword::TABLE) | None => GrantObjects::Tables(objects?),
3180                _ => unreachable!(),
3181            }
3182        };
3183
3184        Ok((privileges, objects))
3185    }
3186
3187    fn parse_grant_permission(&mut self) -> Result<(Keyword, Option<Vec<Ident>>), ParserError> {
3188        if let Some(kw) = self.parse_one_of_keywords(&[
3189            Keyword::CONNECT,
3190            Keyword::CREATE,
3191            Keyword::DELETE,
3192            Keyword::EXECUTE,
3193            Keyword::INSERT,
3194            Keyword::REFERENCES,
3195            Keyword::SELECT,
3196            Keyword::TEMPORARY,
3197            Keyword::TRIGGER,
3198            Keyword::TRUNCATE,
3199            Keyword::UPDATE,
3200            Keyword::USAGE,
3201        ]) {
3202            let columns = match kw {
3203                Keyword::INSERT | Keyword::REFERENCES | Keyword::SELECT | Keyword::UPDATE => {
3204                    let columns = self.parse_parenthesized_column_list(Optional)?;
3205                    if columns.is_empty() {
3206                        None
3207                    } else {
3208                        Some(columns)
3209                    }
3210                }
3211                _ => None,
3212            };
3213            Ok((kw, columns))
3214        } else {
3215            self.expected("a privilege keyword", self.peek_token())?
3216        }
3217    }
3218
3219    /// Parse a REVOKE statement
3220    pub fn parse_revoke(&mut self) -> Result<Statement, ParserError> {
3221        let (privileges, objects) = self.parse_grant_revoke_privileges_objects()?;
3222
3223        self.expect_keyword(Keyword::FROM)?;
3224        let grantees = self.parse_comma_separated(Parser::parse_identifier)?;
3225
3226        let granted_by = self
3227            .parse_keywords(&[Keyword::GRANTED, Keyword::BY])
3228            .then(|| self.parse_identifier().unwrap());
3229
3230        let cascade = self.parse_keyword(Keyword::CASCADE);
3231        let restrict = self.parse_keyword(Keyword::RESTRICT);
3232        if cascade && restrict {
3233            return parser_err!("Cannot specify both CASCADE and RESTRICT in REVOKE");
3234        }
3235
3236        Ok(Statement::Revoke {
3237            privileges,
3238            objects,
3239            grantees,
3240            granted_by,
3241            cascade,
3242        })
3243    }
3244
3245    /// Parse an INSERT statement
3246    pub fn parse_insert(&mut self) -> Result<Statement, ParserError> {
3247        let or = if !dialect_of!(self is SQLiteDialect) {
3248            None
3249        } else if self.parse_keywords(&[Keyword::OR, Keyword::REPLACE]) {
3250            Some(SqliteOnConflict::Replace)
3251        } else if self.parse_keywords(&[Keyword::OR, Keyword::ROLLBACK]) {
3252            Some(SqliteOnConflict::Rollback)
3253        } else if self.parse_keywords(&[Keyword::OR, Keyword::ABORT]) {
3254            Some(SqliteOnConflict::Abort)
3255        } else if self.parse_keywords(&[Keyword::OR, Keyword::FAIL]) {
3256            Some(SqliteOnConflict::Fail)
3257        } else if self.parse_keywords(&[Keyword::OR, Keyword::IGNORE]) {
3258            Some(SqliteOnConflict::Ignore)
3259        } else if self.parse_keyword(Keyword::REPLACE) {
3260            Some(SqliteOnConflict::Replace)
3261        } else {
3262            None
3263        };
3264        let action = self.expect_one_of_keywords(&[Keyword::INTO, Keyword::OVERWRITE])?;
3265        let overwrite = action == Keyword::OVERWRITE;
3266        let local = self.parse_keyword(Keyword::LOCAL);
3267
3268        if self.parse_keyword(Keyword::DIRECTORY) {
3269            let path = self.parse_literal_string()?;
3270            let file_format = if self.parse_keywords(&[Keyword::STORED, Keyword::AS]) {
3271                Some(self.parse_file_format()?)
3272            } else {
3273                None
3274            };
3275            let source = Box::new(self.parse_query()?);
3276            Ok(Statement::Directory {
3277                local,
3278                path,
3279                overwrite,
3280                file_format,
3281                source,
3282            })
3283        } else {
3284            // Hive lets you put table here regardless
3285            let table = self.parse_keyword(Keyword::TABLE);
3286            let table_name = self.parse_object_name()?;
3287            let columns = self.parse_parenthesized_column_list(Optional)?;
3288
3289            let partitioned = if self.parse_keyword(Keyword::PARTITION) {
3290                self.expect_token(&Token::LParen)?;
3291                let r = Some(self.parse_comma_separated(Parser::parse_expr)?);
3292                self.expect_token(&Token::RParen)?;
3293                r
3294            } else {
3295                None
3296            };
3297
3298            // Hive allows you to specify columns after partitions as well if you want.
3299            let after_columns = self.parse_parenthesized_column_list(Optional)?;
3300
3301            let source = Box::new(self.parse_query()?);
3302            let on = if self.parse_keyword(Keyword::ON) {
3303                self.expect_keyword(Keyword::DUPLICATE)?;
3304                self.expect_keyword(Keyword::KEY)?;
3305                self.expect_keyword(Keyword::UPDATE)?;
3306                let l = self.parse_comma_separated(Parser::parse_assignment)?;
3307
3308                Some(OnInsert::DuplicateKeyUpdate(l))
3309            } else {
3310                None
3311            };
3312
3313            Ok(Statement::Insert {
3314                or,
3315                table_name,
3316                overwrite,
3317                partitioned,
3318                columns,
3319                after_columns,
3320                source,
3321                table,
3322                on,
3323            })
3324        }
3325    }
3326
3327    pub fn parse_update(&mut self) -> Result<Statement, ParserError> {
3328        let table = self.parse_table_and_joins()?;
3329        self.expect_keyword(Keyword::SET)?;
3330        let assignments = self.parse_comma_separated(Parser::parse_assignment)?;
3331        let selection = if self.parse_keyword(Keyword::WHERE) {
3332            Some(self.parse_expr()?)
3333        } else {
3334            None
3335        };
3336        Ok(Statement::Update {
3337            table,
3338            assignments,
3339            selection,
3340        })
3341    }
3342
3343    /// Parse a `var = expr` assignment, used in an UPDATE statement
3344    pub fn parse_assignment(&mut self) -> Result<Assignment, ParserError> {
3345        let id = self.parse_identifiers_non_keywords()?;
3346        self.expect_token(&Token::Eq)?;
3347        let value = self.parse_expr()?;
3348        Ok(Assignment { id, value })
3349    }
3350
3351    fn parse_function_args(&mut self) -> Result<FunctionArg, ParserError> {
3352        if self.peek_nth_token(1) == Token::RArrow {
3353            let name = self.parse_identifier()?;
3354
3355            self.expect_token(&Token::RArrow)?;
3356            let arg = self.parse_wildcard_expr()?.into();
3357
3358            Ok(FunctionArg::Named { name, arg })
3359        } else {
3360            Ok(FunctionArg::Unnamed(self.parse_wildcard_expr()?.into()))
3361        }
3362    }
3363
3364    pub fn parse_optional_args(&mut self) -> Result<Vec<FunctionArg>, ParserError> {
3365        if self.consume_token(&Token::RParen) {
3366            Ok(vec![])
3367        } else {
3368            let args = self.parse_comma_separated(Parser::parse_function_args)?;
3369            self.expect_token(&Token::RParen)?;
3370            Ok(args)
3371        }
3372    }
3373
3374    /// Parse a comma-delimited list of projections after SELECT
3375    pub fn parse_select_item(&mut self) -> Result<SelectItem, ParserError> {
3376        match self.parse_wildcard_expr()? {
3377            WildcardExpr::Expr(expr) => self
3378                .parse_optional_alias(keywords::RESERVED_FOR_COLUMN_ALIAS)
3379                .map(|alias| match alias {
3380                    Some(alias) => SelectItem::ExprWithAlias { expr, alias },
3381                    None => SelectItem::UnnamedExpr(expr),
3382                }),
3383            WildcardExpr::QualifiedWildcard(prefix) => Ok(SelectItem::QualifiedWildcard(prefix)),
3384            WildcardExpr::Wildcard => Ok(SelectItem::Wildcard),
3385        }
3386    }
3387
3388    /// Parse an expression, optionally followed by ASC or DESC (used in ORDER BY)
3389    pub fn parse_order_by_expr(&mut self) -> Result<OrderByExpr, ParserError> {
3390        let expr = self.parse_expr()?;
3391
3392        let asc = if self.parse_keyword(Keyword::ASC) {
3393            Some(true)
3394        } else if self.parse_keyword(Keyword::DESC) {
3395            Some(false)
3396        } else {
3397            None
3398        };
3399
3400        let nulls_first = if self.parse_keywords(&[Keyword::NULLS, Keyword::FIRST]) {
3401            Some(true)
3402        } else if self.parse_keywords(&[Keyword::NULLS, Keyword::LAST]) {
3403            Some(false)
3404        } else {
3405            None
3406        };
3407
3408        Ok(OrderByExpr {
3409            expr,
3410            asc,
3411            nulls_first,
3412        })
3413    }
3414
3415    /// Parse a TOP clause, MSSQL equivalent of LIMIT,
3416    /// that follows after SELECT [DISTINCT].
3417    pub fn parse_top(&mut self) -> Result<Top, ParserError> {
3418        let quantity = if self.consume_token(&Token::LParen) {
3419            let quantity = self.parse_expr()?;
3420            self.expect_token(&Token::RParen)?;
3421            Some(quantity)
3422        } else {
3423            Some(Expr::Value(self.parse_number_value()?))
3424        };
3425
3426        let percent = self.parse_keyword(Keyword::PERCENT);
3427
3428        let with_ties = self.parse_keywords(&[Keyword::WITH, Keyword::TIES]);
3429
3430        Ok(Top {
3431            with_ties,
3432            percent,
3433            quantity,
3434        })
3435    }
3436
3437    /// Parse a LIMIT clause
3438    pub fn parse_limit(&mut self) -> Result<Option<Expr>, ParserError> {
3439        if self.parse_keyword(Keyword::ALL) {
3440            Ok(None)
3441        } else {
3442            Ok(Some(Expr::Value(self.parse_number_value()?)))
3443        }
3444    }
3445
3446    /// Parse an OFFSET clause
3447    pub fn parse_offset(&mut self) -> Result<Offset, ParserError> {
3448        let value = Expr::Value(self.parse_number_value()?);
3449        let rows = if self.parse_keyword(Keyword::ROW) {
3450            OffsetRows::Row
3451        } else if self.parse_keyword(Keyword::ROWS) {
3452            OffsetRows::Rows
3453        } else {
3454            OffsetRows::None
3455        };
3456        Ok(Offset { value, rows })
3457    }
3458
3459    /// Parse a FETCH clause
3460    pub fn parse_fetch(&mut self) -> Result<Fetch, ParserError> {
3461        self.expect_one_of_keywords(&[Keyword::FIRST, Keyword::NEXT])?;
3462        let (quantity, percent) = if self
3463            .parse_one_of_keywords(&[Keyword::ROW, Keyword::ROWS])
3464            .is_some()
3465        {
3466            (None, false)
3467        } else {
3468            let quantity = Expr::Value(self.parse_value()?);
3469            let percent = self.parse_keyword(Keyword::PERCENT);
3470            self.expect_one_of_keywords(&[Keyword::ROW, Keyword::ROWS])?;
3471            (Some(quantity), percent)
3472        };
3473        let with_ties = if self.parse_keyword(Keyword::ONLY) {
3474            false
3475        } else if self.parse_keywords(&[Keyword::WITH, Keyword::TIES]) {
3476            true
3477        } else {
3478            return self.expected("one of ONLY or WITH TIES", self.peek_token());
3479        };
3480        Ok(Fetch {
3481            with_ties,
3482            percent,
3483            quantity,
3484        })
3485    }
3486
3487    /// Parse a FOR UPDATE/FOR SHARE clause
3488    pub fn parse_lock(&mut self) -> Result<LockType, ParserError> {
3489        match self.expect_one_of_keywords(&[Keyword::UPDATE, Keyword::SHARE])? {
3490            Keyword::UPDATE => Ok(LockType::Exclusive),
3491            Keyword::SHARE => Ok(LockType::Shared),
3492            _ => unreachable!(),
3493        }
3494    }
3495
3496    pub fn parse_values(&mut self) -> Result<Values, ParserError> {
3497        let values = self.parse_comma_separated(|parser| {
3498            parser.expect_token(&Token::LParen)?;
3499            let exprs = parser.parse_comma_separated(Parser::parse_expr)?;
3500            parser.expect_token(&Token::RParen)?;
3501            Ok(exprs)
3502        })?;
3503        Ok(Values(values))
3504    }
3505
3506    pub fn parse_start_transaction(&mut self) -> Result<Statement, ParserError> {
3507        self.expect_keyword(Keyword::TRANSACTION)?;
3508        Ok(Statement::StartTransaction {
3509            modes: self.parse_transaction_modes()?,
3510        })
3511    }
3512
3513    pub fn parse_begin(&mut self) -> Result<Statement, ParserError> {
3514        let _ = self.parse_one_of_keywords(&[Keyword::TRANSACTION, Keyword::WORK]);
3515        Ok(Statement::StartTransaction {
3516            modes: self.parse_transaction_modes()?,
3517        })
3518    }
3519
3520    pub fn parse_transaction_modes(&mut self) -> Result<Vec<TransactionMode>, ParserError> {
3521        let mut modes = vec![];
3522        let mut required = false;
3523        loop {
3524            let mode = if self.parse_keywords(&[Keyword::ISOLATION, Keyword::LEVEL]) {
3525                let iso_level = if self.parse_keywords(&[Keyword::READ, Keyword::UNCOMMITTED]) {
3526                    TransactionIsolationLevel::ReadUncommitted
3527                } else if self.parse_keywords(&[Keyword::READ, Keyword::COMMITTED]) {
3528                    TransactionIsolationLevel::ReadCommitted
3529                } else if self.parse_keywords(&[Keyword::REPEATABLE, Keyword::READ]) {
3530                    TransactionIsolationLevel::RepeatableRead
3531                } else if self.parse_keyword(Keyword::SERIALIZABLE) {
3532                    TransactionIsolationLevel::Serializable
3533                } else {
3534                    self.expected("isolation level", self.peek_token())?
3535                };
3536                TransactionMode::IsolationLevel(iso_level)
3537            } else if self.parse_keywords(&[Keyword::READ, Keyword::ONLY]) {
3538                TransactionMode::AccessMode(TransactionAccessMode::ReadOnly)
3539            } else if self.parse_keywords(&[Keyword::READ, Keyword::WRITE]) {
3540                TransactionMode::AccessMode(TransactionAccessMode::ReadWrite)
3541            } else if required {
3542                self.expected("transaction mode", self.peek_token())?
3543            } else {
3544                break;
3545            };
3546            modes.push(mode);
3547            // ANSI requires a comma after each transaction mode, but
3548            // PostgreSQL, for historical reasons, does not. We follow
3549            // PostgreSQL in making the comma optional, since that is strictly
3550            // more general.
3551            required = self.consume_token(&Token::Comma);
3552        }
3553        Ok(modes)
3554    }
3555
3556    pub fn parse_commit(&mut self) -> Result<Statement, ParserError> {
3557        Ok(Statement::Commit {
3558            chain: self.parse_commit_rollback_chain()?,
3559        })
3560    }
3561
3562    pub fn parse_rollback(&mut self) -> Result<Statement, ParserError> {
3563        Ok(Statement::Rollback {
3564            chain: self.parse_commit_rollback_chain()?,
3565        })
3566    }
3567
3568    pub fn parse_commit_rollback_chain(&mut self) -> Result<bool, ParserError> {
3569        let _ = self.parse_one_of_keywords(&[Keyword::TRANSACTION, Keyword::WORK]);
3570        if self.parse_keyword(Keyword::AND) {
3571            let chain = !self.parse_keyword(Keyword::NO);
3572            self.expect_keyword(Keyword::CHAIN)?;
3573            Ok(chain)
3574        } else {
3575            Ok(false)
3576        }
3577    }
3578
3579    fn parse_deallocate(&mut self) -> Result<Statement, ParserError> {
3580        let prepare = self.parse_keyword(Keyword::PREPARE);
3581        let name = self.parse_identifier()?;
3582        Ok(Statement::Deallocate { name, prepare })
3583    }
3584
3585    fn parse_execute(&mut self) -> Result<Statement, ParserError> {
3586        let name = self.parse_identifier()?;
3587
3588        let mut parameters = vec![];
3589        if self.consume_token(&Token::LParen) {
3590            parameters = self.parse_comma_separated(Parser::parse_expr)?;
3591            self.expect_token(&Token::RParen)?;
3592        }
3593
3594        Ok(Statement::Execute { name, parameters })
3595    }
3596
3597    fn parse_prepare(&mut self) -> Result<Statement, ParserError> {
3598        let name = self.parse_identifier()?;
3599
3600        let mut data_types = vec![];
3601        if self.consume_token(&Token::LParen) {
3602            data_types = self.parse_comma_separated(Parser::parse_data_type)?;
3603            self.expect_token(&Token::RParen)?;
3604        }
3605
3606        self.expect_keyword(Keyword::AS)?;
3607        let statement = Box::new(self.parse_statement()?);
3608        Ok(Statement::Prepare {
3609            name,
3610            data_types,
3611            statement,
3612        })
3613    }
3614
3615    fn parse_comment(&mut self) -> Result<Statement, ParserError> {
3616        self.expect_keyword(Keyword::ON)?;
3617        let token = self.next_token();
3618
3619        let (object_type, object_name) = match token {
3620            Token::Word(w) if w.keyword == Keyword::COLUMN => {
3621                let object_name = self.parse_object_name()?;
3622                (CommentObject::Column, object_name)
3623            }
3624            Token::Word(w) if w.keyword == Keyword::TABLE => {
3625                let object_name = self.parse_object_name()?;
3626                (CommentObject::Table, object_name)
3627            }
3628            _ => self.expected("comment object_type", token)?,
3629        };
3630
3631        self.expect_keyword(Keyword::IS)?;
3632        let comment = if self.parse_keyword(Keyword::NULL) {
3633            None
3634        } else {
3635            Some(self.parse_literal_string()?)
3636        };
3637        Ok(Statement::Comment {
3638            object_type,
3639            object_name,
3640            comment,
3641        })
3642    }
3643}
3644
3645impl Word {
3646    pub fn to_ident(&self) -> Ident {
3647        Ident {
3648            value: self.value.clone(),
3649            quote_style: self.quote_style,
3650        }
3651    }
3652}
3653
3654#[cfg(test)]
3655mod tests {
3656    use super::*;
3657    use crate::test_utils::all_dialects;
3658
3659    #[test]
3660    fn test_prev_index() {
3661        let sql = "SELECT version";
3662        all_dialects().run_parser_method(sql, |parser| {
3663            assert_eq!(parser.peek_token(), Token::make_keyword("SELECT"));
3664            assert_eq!(parser.next_token(), Token::make_keyword("SELECT"));
3665            parser.prev_token();
3666            assert_eq!(parser.next_token(), Token::make_keyword("SELECT"));
3667            assert_eq!(parser.next_token(), Token::make_word("version", None));
3668            parser.prev_token();
3669            assert_eq!(parser.peek_token(), Token::make_word("version", None));
3670            assert_eq!(parser.next_token(), Token::make_word("version", None));
3671            assert_eq!(parser.peek_token(), Token::EOF);
3672            parser.prev_token();
3673            assert_eq!(parser.next_token(), Token::make_word("version", None));
3674            assert_eq!(parser.next_token(), Token::EOF);
3675            assert_eq!(parser.next_token(), Token::EOF);
3676            parser.prev_token();
3677        });
3678    }
3679}