mz_sql_parser/
parser.rs

1// Copyright 2018 sqlparser-rs contributors. All rights reserved.
2// Copyright Materialize, Inc. and contributors. All rights reserved.
3//
4// This file is derived from the sqlparser-rs project, available at
5// https://github.com/andygrove/sqlparser-rs. It was incorporated
6// directly into Materialize on December 21, 2019.
7//
8// Licensed under the Apache License, Version 2.0 (the "License");
9// you may not use this file except in compliance with the License.
10// You may obtain a copy of the License in the LICENSE file at the
11// root of this repository, or online at
12//
13//     http://www.apache.org/licenses/LICENSE-2.0
14//
15// Unless required by applicable law or agreed to in writing, software
16// distributed under the License is distributed on an "AS IS" BASIS,
17// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18// See the License for the specific language governing permissions and
19// limitations under the License.
20
21//! SQL Parser
22
23use std::collections::BTreeMap;
24use std::error::Error;
25use std::fmt;
26
27use IsLateral::*;
28use IsOptional::*;
29use bytesize::ByteSize;
30use itertools::Itertools;
31use mz_ore::cast::CastFrom;
32use mz_ore::collections::CollectionExt;
33use mz_ore::option::OptionExt;
34use mz_ore::stack::{CheckedRecursion, RecursionGuard, RecursionLimitError};
35use mz_sql_lexer::keywords::*;
36use mz_sql_lexer::lexer::{self, IdentString, LexerError, PosToken, Token};
37use serde::{Deserialize, Serialize};
38use tracing::{debug, warn};
39
40use crate::ast::display::AstDisplay;
41use crate::ast::*;
42use crate::ident;
43
44// NOTE(benesch): this recursion limit was chosen based on the maximum amount of
45// nesting I've ever seen in a production SQL query (i.e., about a dozen) times
46// a healthy factor to be conservative.
47const RECURSION_LIMIT: usize = 128;
48
49/// Maximum allowed size for a batch of statements in bytes: 1MB.
50pub const MAX_STATEMENT_BATCH_SIZE: usize = 1_000_000;
51
52/// Keywords that indicate the start of a (sub)query.
53const QUERY_START_KEYWORDS: &[Keyword] = &[WITH, SELECT, SHOW, TABLE, VALUES];
54
55/// Keywords that indicate the start of an `ANY` or `ALL` subquery operation.
56const ANY_ALL_KEYWORDS: &[Keyword] = &[ANY, ALL, SOME];
57
58// Use `Parser::expected` instead, if possible
59macro_rules! parser_err {
60    ($parser:expr, $pos:expr, $MSG:expr) => {
61        Err($parser.error($pos, $MSG.to_string()))
62    };
63    ($parser:expr, $pos:expr, $($arg:tt)*) => {
64        Err($parser.error($pos, format!($($arg)*)))
65    };
66}
67
68/// The result of successfully parsing a statement:
69/// both the AST and the SQL text that it corresponds to
70#[derive(Debug, Clone)]
71pub struct StatementParseResult<'a> {
72    pub ast: Statement<Raw>,
73    pub sql: &'a str,
74}
75
76impl<'a> StatementParseResult<'a> {
77    pub fn new(ast: Statement<Raw>, sql: &'a str) -> Self {
78        Self { ast, sql }
79    }
80}
81
82trait ParserStatementErrorMapper<T> {
83    /// Wrap a `ParserError` within a `ParserStatementError` alongside the provided `StatementKind`
84    fn map_parser_err(self, statement_kind: StatementKind) -> Result<T, ParserStatementError>;
85
86    /// Wrap a `ParserError` within a `ParserStatementError` without an accompanying
87    /// `StatementKind`.
88    ///
89    /// This should be used when we do not know what specific statement is being parsed.
90    fn map_no_statement_parser_err(self) -> Result<T, ParserStatementError>;
91}
92
93impl<T> ParserStatementErrorMapper<T> for Result<T, ParserError> {
94    fn map_parser_err(self, statement: StatementKind) -> Result<T, ParserStatementError> {
95        self.map_err(|error| ParserStatementError {
96            error,
97            statement: Some(statement),
98        })
99    }
100
101    fn map_no_statement_parser_err(self) -> Result<T, ParserStatementError> {
102        self.map_err(|error| ParserStatementError {
103            error,
104            statement: None,
105        })
106    }
107}
108
109/// Parses a SQL string containing zero or more SQL statements.
110/// Statements larger than [`MAX_STATEMENT_BATCH_SIZE`] are rejected.
111///
112/// The outer Result is for errors related to the statement size. The inner Result is for
113/// errors during the parsing.
114#[mz_ore::instrument(target = "compiler", level = "trace", name = "sql_to_ast")]
115pub fn parse_statements_with_limit(
116    sql: &str,
117) -> Result<Result<Vec<StatementParseResult<'_>>, ParserStatementError>, String> {
118    if sql.bytes().count() > MAX_STATEMENT_BATCH_SIZE {
119        return Err(format!(
120            "statement batch size cannot exceed {}",
121            ByteSize::b(u64::cast_from(MAX_STATEMENT_BATCH_SIZE))
122        ));
123    }
124    Ok(parse_statements(sql))
125}
126
127/// Parses a SQL string containing zero or more SQL statements.
128#[mz_ore::instrument(target = "compiler", level = "trace", name = "sql_to_ast")]
129pub fn parse_statements(sql: &str) -> Result<Vec<StatementParseResult<'_>>, ParserStatementError> {
130    let tokens = lexer::lex(sql).map_err(|error| ParserStatementError {
131        error: error.into(),
132        statement: None,
133    })?;
134    let res = Parser::new(sql, tokens).parse_statements();
135    // Don't trace sensitive raw sql, so we can only trace after parsing, and then can only output
136    // redacted statements.
137    debug!("{:?}", {
138        match &res {
139            Ok(stmts) => stmts
140                .iter()
141                .map(|stmt| stmt.ast.to_ast_string_redacted())
142                .join("; "),
143            // Errors can leak sensitive SQL.
144            Err(_) => "parse error".to_string(),
145        }
146    });
147    res
148}
149
150/// Parses a SQL string containing one SQL expression.
151pub fn parse_expr(sql: &str) -> Result<Expr<Raw>, ParserError> {
152    let tokens = lexer::lex(sql)?;
153    let mut parser = Parser::new(sql, tokens);
154    let expr = parser.parse_expr()?;
155    if parser.next_token().is_some() {
156        parser_err!(
157            parser,
158            parser.peek_prev_pos(),
159            "extra token after expression"
160        )
161    } else {
162        Ok(expr)
163    }
164}
165
166/// Parses a SQL string containing a single data type.
167pub fn parse_data_type(sql: &str) -> Result<RawDataType, ParserError> {
168    let tokens = lexer::lex(sql)?;
169    let mut parser = Parser::new(sql, tokens);
170    let data_type = parser.parse_data_type()?;
171    if parser.next_token().is_some() {
172        parser_err!(
173            parser,
174            parser.peek_prev_pos(),
175            "extra token after data type"
176        )
177    } else {
178        Ok(data_type)
179    }
180}
181
182/// Parses a string containing a comma-separated list of identifiers and
183/// returns their underlying string values.
184///
185/// This is analogous to the `SplitIdentifierString` function in PostgreSQL.
186pub fn split_identifier_string(s: &str) -> Result<Vec<String>, ParserError> {
187    // SplitIdentifierString ignores leading and trailing whitespace, and
188    // accepts empty input as a 0-length result.
189    if s.trim().is_empty() {
190        Ok(vec![])
191    } else {
192        let tokens = lexer::lex(s)?;
193        let mut parser = Parser::new(s, tokens);
194        let values = parser.parse_comma_separated(Parser::parse_set_variable_value)?;
195        Ok(values
196            .into_iter()
197            .map(|v| v.into_unquoted_value())
198            .collect())
199    }
200}
201
202macro_rules! maybe {
203    ($e:expr) => {{
204        if let Some(v) = $e {
205            return Ok(v);
206        }
207    }};
208}
209
210#[derive(PartialEq)]
211enum IsOptional {
212    Optional,
213    Mandatory,
214}
215
216enum IsLateral {
217    Lateral,
218    NotLateral,
219}
220
221#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
222pub struct ParserError {
223    /// The error message.
224    pub message: String,
225    /// The byte position with which the error is associated.
226    pub pos: usize,
227}
228
229impl fmt::Display for ParserError {
230    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
231        f.write_str(&self.message)
232    }
233}
234
235impl Error for ParserError {}
236
237impl From<RecursionLimitError> for ParserError {
238    fn from(_: RecursionLimitError) -> ParserError {
239        ParserError {
240            pos: 0,
241            message: format!(
242                "statement exceeds nested expression limit of {}",
243                RECURSION_LIMIT
244            ),
245        }
246    }
247}
248
249impl ParserError {
250    /// Constructs an error with the provided message at the provided position.
251    pub(crate) fn new<S>(pos: usize, message: S) -> ParserError
252    where
253        S: Into<String>,
254    {
255        ParserError {
256            pos,
257            message: message.into(),
258        }
259    }
260}
261
262#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
263pub struct ParserStatementError {
264    /// The underlying error
265    pub error: ParserError,
266    /// The kind of statement erroring
267    pub statement: Option<StatementKind>,
268}
269
270impl Error for ParserStatementError {}
271
272impl fmt::Display for ParserStatementError {
273    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
274        f.write_str(&self.error.to_string())
275    }
276}
277
278impl From<LexerError> for ParserError {
279    fn from(value: LexerError) -> Self {
280        ParserError {
281            message: value.message,
282            pos: value.pos,
283        }
284    }
285}
286
287impl From<Keyword> for Ident {
288    fn from(value: Keyword) -> Ident {
289        // Note: all keywords are known to be less than our max length.
290        Ident::new_unchecked(value.as_str().to_lowercase())
291    }
292}
293
294/// SQL Parser
295struct Parser<'a> {
296    sql: &'a str,
297    tokens: Vec<PosToken>,
298    /// The index of the first unprocessed token in `self.tokens`
299    index: usize,
300    recursion_guard: RecursionGuard,
301}
302
303/// Defines a number of precedence classes operators follow. Since this enum derives Ord, the
304/// precedence classes are ordered from weakest binding at the top to tightest binding at the
305/// bottom.
306#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
307enum Precedence {
308    Zero,
309    Or,
310    And,
311    PrefixNot,
312    Is,
313    Cmp,
314    Like,
315    Other,
316    PlusMinus,
317    MultiplyDivide,
318    PostfixCollateAt,
319    PrefixPlusMinus,
320    PostfixSubscriptCast,
321}
322
323#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
324enum SetPrecedence {
325    Zero,
326    UnionExcept,
327    Intersect,
328}
329
330impl<'a> Parser<'a> {
331    /// Parse the specified tokens
332    fn new(sql: &'a str, tokens: Vec<PosToken>) -> Self {
333        Parser {
334            sql,
335            tokens,
336            index: 0,
337            recursion_guard: RecursionGuard::with_limit(RECURSION_LIMIT),
338        }
339    }
340
341    fn error(&self, pos: usize, message: String) -> ParserError {
342        ParserError { pos, message }
343    }
344
345    fn parse_statements(&mut self) -> Result<Vec<StatementParseResult<'a>>, ParserStatementError> {
346        let mut stmts = Vec::new();
347        let mut expecting_statement_delimiter = false;
348        loop {
349            // ignore empty statements (between successive statement delimiters)
350            while self.consume_token(&Token::Semicolon) {
351                expecting_statement_delimiter = false;
352            }
353
354            if self.peek_token().is_none() {
355                break;
356            } else if expecting_statement_delimiter {
357                return self
358                    .expected(self.peek_pos(), "end of statement", self.peek_token())
359                    .map_no_statement_parser_err();
360            }
361
362            let s = self.parse_statement()?;
363            stmts.push(s);
364            expecting_statement_delimiter = true;
365        }
366        Ok(stmts)
367    }
368    /// Parse a single top-level statement (such as SELECT, INSERT, CREATE, etc.),
369    /// stopping before the statement separator, if any. Returns the parsed statement and the SQL
370    /// fragment corresponding to it.
371    fn parse_statement(&mut self) -> Result<StatementParseResult<'a>, ParserStatementError> {
372        let before = self.peek_pos();
373        let statement = self.parse_statement_inner()?;
374        let after = self.peek_pos();
375        Ok(StatementParseResult::new(
376            statement,
377            self.sql[before..after].trim(),
378        ))
379    }
380
381    /// Parse a single top-level statement (such as SELECT, INSERT, CREATE, etc.),
382    /// stopping before the statement separator, if any.
383    fn parse_statement_inner(&mut self) -> Result<Statement<Raw>, ParserStatementError> {
384        match self.next_token() {
385            Some(t) => match t {
386                Token::Keyword(CREATE) => Ok(self.parse_create()?),
387                Token::Keyword(DISCARD) => Ok(self
388                    .parse_discard()
389                    .map_parser_err(StatementKind::Discard)?),
390                Token::Keyword(DROP) => Ok(self.parse_drop()?),
391                Token::Keyword(DELETE) => {
392                    Ok(self.parse_delete().map_parser_err(StatementKind::Delete)?)
393                }
394                Token::Keyword(INSERT) => {
395                    Ok(self.parse_insert().map_parser_err(StatementKind::Insert)?)
396                }
397                Token::Keyword(UPDATE) => {
398                    Ok(self.parse_update().map_parser_err(StatementKind::Update)?)
399                }
400                Token::Keyword(ALTER) => Ok(self.parse_alter()?),
401                Token::Keyword(COPY) => Ok(self.parse_copy()?),
402                Token::Keyword(SET) => Ok(self.parse_set()?),
403                Token::Keyword(RESET) => Ok(self
404                    .parse_reset()
405                    .map_parser_err(StatementKind::ResetVariable)?),
406                Token::Keyword(SHOW) => Ok(Statement::Show(
407                    self.parse_show().map_parser_err(StatementKind::Show)?,
408                )),
409                Token::Keyword(START) => Ok(self
410                    .parse_start_transaction()
411                    .map_parser_err(StatementKind::StartTransaction)?),
412                // `BEGIN` is a nonstandard but common alias for the
413                // standard `START TRANSACTION` statement. It is supported
414                // by at least PostgreSQL and MySQL.
415                Token::Keyword(BEGIN) => Ok(self
416                    .parse_begin()
417                    .map_parser_err(StatementKind::StartTransaction)?),
418                Token::Keyword(COMMIT) => {
419                    Ok(self.parse_commit().map_parser_err(StatementKind::Commit)?)
420                }
421                Token::Keyword(ROLLBACK) => Ok(self
422                    .parse_rollback()
423                    .map_parser_err(StatementKind::Rollback)?),
424                Token::Keyword(TAIL) => {
425                    Ok(self.parse_tail().map_parser_err(StatementKind::Subscribe)?)
426                }
427                Token::Keyword(SUBSCRIBE) => Ok(self
428                    .parse_subscribe()
429                    .map_parser_err(StatementKind::Subscribe)?),
430                Token::Keyword(EXPLAIN) => Ok(self.parse_explain()?),
431                Token::Keyword(DECLARE) => Ok(self.parse_declare()?),
432                Token::Keyword(FETCH) => {
433                    Ok(self.parse_fetch().map_parser_err(StatementKind::Fetch)?)
434                }
435                Token::Keyword(CLOSE) => {
436                    Ok(self.parse_close().map_parser_err(StatementKind::Close)?)
437                }
438                Token::Keyword(PREPARE) => Ok(self.parse_prepare()?),
439                Token::Keyword(EXECUTE) => Ok(self
440                    .parse_execute()
441                    .map_parser_err(StatementKind::Execute)?),
442                Token::Keyword(DEALLOCATE) => Ok(self
443                    .parse_deallocate()
444                    .map_parser_err(StatementKind::Deallocate)?),
445                Token::Keyword(RAISE) => {
446                    Ok(self.parse_raise().map_parser_err(StatementKind::Raise)?)
447                }
448                Token::Keyword(GRANT) => Ok(self.parse_grant()?),
449                Token::Keyword(REVOKE) => Ok(self.parse_revoke()?),
450                Token::Keyword(REASSIGN) => Ok(self
451                    .parse_reassign_owned()
452                    .map_parser_err(StatementKind::ReassignOwned)?),
453                Token::Keyword(INSPECT) => Ok(Statement::Show(
454                    self.parse_inspect().map_no_statement_parser_err()?,
455                )),
456                Token::Keyword(VALIDATE) => Ok(self
457                    .parse_validate()
458                    .map_parser_err(StatementKind::ValidateConnection)?),
459                Token::Keyword(COMMENT) => Ok(self
460                    .parse_comment()
461                    .map_parser_err(StatementKind::Comment)?),
462                Token::Keyword(k) if QUERY_START_KEYWORDS.contains(&k) => {
463                    self.prev_token();
464                    Ok(Statement::Select(
465                        self.parse_select_statement()
466                            .map_parser_err(StatementKind::Select)?,
467                    ))
468                }
469                Token::Keyword(kw) => parser_err!(
470                    self,
471                    self.peek_prev_pos(),
472                    format!("Unexpected keyword {} at the beginning of a statement", kw)
473                )
474                .map_no_statement_parser_err(),
475                Token::LParen => {
476                    self.prev_token();
477                    Ok(Statement::Select(SelectStatement {
478                        query: self.parse_query().map_parser_err(StatementKind::Select)?,
479                        as_of: None, // Only the outermost SELECT may have an AS OF clause.
480                    }))
481                }
482                unexpected => self
483                    .expected(
484                        self.peek_prev_pos(),
485                        "a keyword at the beginning of a statement",
486                        Some(unexpected),
487                    )
488                    .map_no_statement_parser_err(),
489            },
490            None => self
491                .expected(self.peek_prev_pos(), "SQL statement", None)
492                .map_no_statement_parser_err(),
493        }
494    }
495
496    /// Parse a new expression
497    fn parse_expr(&mut self) -> Result<Expr<Raw>, ParserError> {
498        self.parse_subexpr(Precedence::Zero)
499    }
500
501    /// Parse tokens until the precedence decreases
502    fn parse_subexpr(&mut self, precedence: Precedence) -> Result<Expr<Raw>, ParserError> {
503        let expr = self.checked_recur_mut(|parser| parser.parse_prefix())?;
504        self.parse_subexpr_seeded(precedence, expr)
505    }
506
507    fn parse_subexpr_seeded(
508        &mut self,
509        precedence: Precedence,
510        mut expr: Expr<Raw>,
511    ) -> Result<Expr<Raw>, ParserError> {
512        self.checked_recur_mut(|parser| {
513            loop {
514                let next_precedence = parser.get_next_precedence();
515                if precedence >= next_precedence {
516                    break;
517                }
518
519                expr = parser.parse_infix(expr, next_precedence)?;
520            }
521            Ok(expr)
522        })
523    }
524
525    /// Parse an expression prefix
526    fn parse_prefix(&mut self) -> Result<Expr<Raw>, ParserError> {
527        // PostgreSQL allows any string literal to be preceded by a type name,
528        // indicating that the string literal represents a literal of that type.
529        // Some examples:
530        //
531        //     DATE '2020-05-20'
532        //     TIMESTAMP WITH TIME ZONE '2020-05-20 7:43:54'
533        //     BOOL 'true'
534        //
535        // The first two are standard SQL, while the latter is a PostgreSQL
536        // extension. Complicating matters is the fact that INTERVAL string
537        // literals may optionally be followed by some special keywords, e.g.:
538        //
539        //     INTERVAL '7' DAY
540        //
541        // Note also that naively `SELECT date` looks like a syntax error
542        // because the `date` type name is not followed by a string literal, but
543        // in fact is a valid expression that should parse as the column name
544        // "date".
545        //
546        // Note: the maybe! block here does swallow valid parsing errors
547        // See <https://github.com/MaterializeInc/incidents-and-escalations/issues/90> for more details
548        maybe!(self.maybe_parse(|parser| {
549            let data_type = parser.parse_data_type()?;
550            if data_type.to_string().as_str() == "interval" {
551                Ok(Expr::Value(Value::Interval(parser.parse_interval_value()?)))
552            } else {
553                Ok(Expr::Cast {
554                    expr: Box::new(Expr::Value(Value::String(parser.parse_literal_string()?))),
555                    data_type,
556                })
557            }
558        }));
559
560        let tok = self
561            .next_token()
562            .ok_or_else(|| self.error(self.peek_prev_pos(), "Unexpected EOF".to_string()))?;
563        let expr = match tok {
564            Token::LBracket => {
565                self.prev_token();
566                let function = self.parse_named_function()?;
567                Ok(Expr::Function(function))
568            }
569            Token::Keyword(TRUE) | Token::Keyword(FALSE) | Token::Keyword(NULL) => {
570                self.prev_token();
571                Ok(Expr::Value(self.parse_value()?))
572            }
573            Token::Keyword(ARRAY) => self.parse_array(),
574            Token::Keyword(LIST) => self.parse_list(),
575            Token::Keyword(MAP) => self.parse_map(),
576            Token::Keyword(CASE) => self.parse_case_expr(),
577            Token::Keyword(CAST) => self.parse_cast_expr(),
578            Token::Keyword(COALESCE) => {
579                self.parse_homogenizing_function(HomogenizingFunction::Coalesce)
580            }
581            Token::Keyword(GREATEST) => {
582                self.parse_homogenizing_function(HomogenizingFunction::Greatest)
583            }
584            Token::Keyword(LEAST) => self.parse_homogenizing_function(HomogenizingFunction::Least),
585            Token::Keyword(NULLIF) => self.parse_nullif_expr(),
586            Token::Keyword(EXISTS) => self.parse_exists_expr(),
587            Token::Keyword(EXTRACT) => self.parse_extract_expr(),
588            Token::Keyword(NOT) => Ok(Expr::Not {
589                expr: Box::new(self.parse_subexpr(Precedence::PrefixNot)?),
590            }),
591            Token::Keyword(ROW) if self.peek_token() == Some(Token::LParen) => {
592                self.parse_row_expr()
593            }
594            Token::Keyword(TRIM) => self.parse_trim_expr(),
595            Token::Keyword(POSITION) if self.peek_token() == Some(Token::LParen) => {
596                self.parse_position_expr()
597            }
598            Token::Keyword(SUBSTRING) => self.parse_substring_expr(),
599            Token::Keyword(kw) if kw.is_reserved() => {
600                return Err(self.error(
601                    self.peek_prev_pos(),
602                    format!("expected expression, but found reserved keyword: {kw}"),
603                ));
604            }
605            Token::Keyword(id) => self.parse_qualified_identifier(id.into()),
606            Token::Ident(id) => self.parse_qualified_identifier(self.new_identifier(id)?),
607            Token::Op(op) if op == "-" => {
608                if let Some(Token::Number(n)) = self.peek_token() {
609                    let n = match n.parse::<f64>() {
610                        Ok(n) => n,
611                        Err(_) => {
612                            return Err(
613                                self.error(self.peek_prev_pos(), format!("invalid number {}", n))
614                            );
615                        }
616                    };
617                    if n != 0.0 {
618                        self.prev_token();
619                        return Ok(Expr::Value(self.parse_value()?));
620                    }
621                }
622
623                Ok(Expr::Op {
624                    op: Op::bare(op),
625                    expr1: Box::new(self.parse_subexpr(Precedence::PrefixPlusMinus)?),
626                    expr2: None,
627                })
628            }
629            Token::Op(op) if op == "+" => Ok(Expr::Op {
630                op: Op::bare(op),
631                expr1: Box::new(self.parse_subexpr(Precedence::PrefixPlusMinus)?),
632                expr2: None,
633            }),
634            Token::Op(op) if op == "~" => Ok(Expr::Op {
635                op: Op::bare(op),
636                expr1: Box::new(self.parse_subexpr(Precedence::Other)?),
637                expr2: None,
638            }),
639            Token::Number(_) | Token::String(_) | Token::HexString(_) => {
640                self.prev_token();
641                Ok(Expr::Value(self.parse_value()?))
642            }
643            Token::Parameter(n) => Ok(Expr::Parameter(n)),
644            Token::LParen => {
645                let expr = self.parse_parenthesized_fragment()?.into_expr();
646                self.expect_token(&Token::RParen)?;
647                Ok(expr)
648            }
649            unexpected => self.expected(self.peek_prev_pos(), "an expression", Some(unexpected)),
650        }?;
651
652        Ok(expr)
653    }
654
655    /// Parses an expression list that appears in parentheses, like `(1 + 1)`,
656    /// `(SELECT 1)`, or `(1, 2)`. Assumes that the opening parenthesis has
657    /// already been parsed. Parses up to the closing parenthesis without
658    /// consuming it.
659    fn parse_parenthesized_fragment(&mut self) -> Result<ParenthesizedFragment, ParserError> {
660        // The SQL grammar has an irritating ambiguity that presents here.
661        // Consider these two expression fragments:
662        //
663        //     SELECT (((SELECT 2)) + 3)
664        //     SELECT (((SELECT 2)) UNION SELECT 2)
665        //             ^           ^
666        //            (1)         (2)
667        // When we see the parenthesis marked (1), we have no way to know ahead
668        // of time whether that parenthesis is part of a `SetExpr::Query` inside
669        // of an `Expr::Subquery` or whether it introduces an `Expr::Nested`.
670        // The approach taken here avoids backtracking by deferring the decision
671        // of whether to parse as a subquery or a nested expression until we get
672        // to the point marked (2) above. Once there, we know that the presence
673        // of a set operator implies that the parentheses belonged to the
674        // subquery; otherwise, they belonged to the expression.
675        //
676        // See also PostgreSQL's comments on the matter:
677        // https://github.com/postgres/postgres/blob/42c63ab/src/backend/parser/gram.y#L11125-L11136
678        //
679        // Each call of this function handles one layer of parentheses. Before
680        // every call, the parser must be positioned after an opening
681        // parenthesis; upon non-error return, the parser will be positioned
682        // before the corresponding close parenthesis. Somewhat weirdly, the
683        // returned expression semantically includes the opening/closing
684        // parentheses, even though this function is not responsible for parsing
685        // them.
686
687        if self.peek_one_of_keywords(QUERY_START_KEYWORDS) {
688            // Easy case one: unambiguously a subquery.
689            Ok(ParenthesizedFragment::Query(self.parse_query()?))
690        } else if !self.consume_token(&Token::LParen) {
691            // Easy case two: unambiguously an expression.
692            let exprs = self.parse_comma_separated(Parser::parse_expr)?;
693            Ok(ParenthesizedFragment::Exprs(exprs))
694        } else {
695            // Hard case: we have an open parenthesis, and we need to decide
696            // whether it belongs to the inner expression or the outer
697            // expression.
698
699            // Parse to the closing parenthesis.
700            let fragment = self.checked_recur_mut(Parser::parse_parenthesized_fragment)?;
701            self.expect_token(&Token::RParen)?;
702
703            // Decide if we need to associate any tokens after the closing
704            // parenthesis with what we've parsed so far.
705            match (fragment, self.peek_token()) {
706                // We have a subquery and the next token is a set operator or a
707                // closing parenthesis. That implies we have a partially-parsed
708                // subquery (or a syntax error). Hop into parsing a set
709                // expression where our subquery is the LHS of the set operator.
710                (
711                    ParenthesizedFragment::Query(query),
712                    Some(Token::RParen | Token::Keyword(UNION | INTERSECT | EXCEPT)),
713                ) => {
714                    let query = SetExpr::Query(Box::new(query));
715                    let ctes = CteBlock::empty();
716                    let body = self.parse_query_body_seeded(SetPrecedence::Zero, query)?;
717                    Ok(ParenthesizedFragment::Query(
718                        self.parse_query_tail(ctes, body)?,
719                    ))
720                }
721
722                // Otherwise, we have an expression. It may be only partially
723                // parsed. Hop into parsing an expression where `fragment` is
724                // the expression prefix. Then parse any additional
725                // comma-separated expressions.
726                (fragment, _) => {
727                    let prefix = fragment.into_expr();
728                    let expr = self.parse_subexpr_seeded(Precedence::Zero, prefix)?;
729                    let mut exprs = vec![expr];
730                    while self.consume_token(&Token::Comma) {
731                        exprs.push(self.parse_expr()?);
732                    }
733                    Ok(ParenthesizedFragment::Exprs(exprs))
734                }
735            }
736        }
737    }
738
739    fn parse_function(&mut self, name: RawItemName) -> Result<Function<Raw>, ParserError> {
740        self.expect_token(&Token::LParen)?;
741        let distinct = matches!(
742            self.parse_at_most_one_keyword(&[ALL, DISTINCT], &format!("function: {}", name))?,
743            Some(DISTINCT),
744        );
745        let args = self.parse_optional_args(true)?;
746
747        if distinct && matches!(args, FunctionArgs::Star) {
748            return Err(self.error(
749                self.peek_prev_pos() - 1,
750                "DISTINCT * not supported as function args".to_string(),
751            ));
752        }
753
754        let filter = if self.parse_keyword(FILTER) {
755            self.expect_token(&Token::LParen)?;
756            self.expect_keyword(WHERE)?;
757            let expr = self.parse_expr()?;
758            self.expect_token(&Token::RParen)?;
759            Some(Box::new(expr))
760        } else {
761            None
762        };
763        let over =
764            if self.peek_keyword(OVER) || self.peek_keyword(IGNORE) || self.peek_keyword(RESPECT) {
765                // TBD: support window names (`OVER mywin`) in place of inline specification
766                // https://github.com/MaterializeInc/database-issues/issues/5882
767
768                let ignore_nulls = self.parse_keywords(&[IGNORE, NULLS]);
769                let respect_nulls = self.parse_keywords(&[RESPECT, NULLS]);
770                self.expect_keyword(OVER)?;
771
772                self.expect_token(&Token::LParen)?;
773                let partition_by = if self.parse_keywords(&[PARTITION, BY]) {
774                    // a list of possibly-qualified column names
775                    self.parse_comma_separated(Parser::parse_expr)?
776                } else {
777                    vec![]
778                };
779                let order_by = if self.parse_keywords(&[ORDER, BY]) {
780                    self.parse_comma_separated(Parser::parse_order_by_expr)?
781                } else {
782                    vec![]
783                };
784                let window_frame = if !self.consume_token(&Token::RParen) {
785                    let window_frame = self.parse_window_frame()?;
786                    self.expect_token(&Token::RParen)?;
787                    Some(window_frame)
788                } else {
789                    None
790                };
791
792                Some(WindowSpec {
793                    partition_by,
794                    order_by,
795                    window_frame,
796                    ignore_nulls,
797                    respect_nulls,
798                })
799            } else {
800                None
801            };
802
803        Ok(Function {
804            name,
805            args,
806            filter,
807            over,
808            distinct,
809        })
810    }
811
812    fn parse_window_frame(&mut self) -> Result<WindowFrame, ParserError> {
813        let units = match self.expect_one_of_keywords(&[ROWS, RANGE, GROUPS])? {
814            ROWS => WindowFrameUnits::Rows,
815            RANGE => WindowFrameUnits::Range,
816            GROUPS => WindowFrameUnits::Groups,
817            _ => unreachable!(),
818        };
819        let (start_bound, end_bound) = if self.parse_keyword(BETWEEN) {
820            let start_bound = self.parse_window_frame_bound()?;
821            self.expect_keyword(AND)?;
822            let end_bound = Some(self.parse_window_frame_bound()?);
823            (start_bound, end_bound)
824        } else {
825            (self.parse_window_frame_bound()?, None)
826        };
827        Ok(WindowFrame {
828            units,
829            start_bound,
830            end_bound,
831        })
832    }
833
834    /// Parse `CURRENT ROW` or `{ <positive number> | UNBOUNDED } { PRECEDING | FOLLOWING }`
835    fn parse_window_frame_bound(&mut self) -> Result<WindowFrameBound, ParserError> {
836        if self.parse_keywords(&[CURRENT, ROW]) {
837            Ok(WindowFrameBound::CurrentRow)
838        } else {
839            let rows = if self.parse_keyword(UNBOUNDED) {
840                None
841            } else {
842                Some(self.parse_literal_uint()?)
843            };
844            if self.parse_keyword(PRECEDING) {
845                Ok(WindowFrameBound::Preceding(rows))
846            } else if self.parse_keyword(FOLLOWING) {
847                Ok(WindowFrameBound::Following(rows))
848            } else {
849                self.expected(self.peek_pos(), "PRECEDING or FOLLOWING", self.peek_token())
850            }
851        }
852    }
853
854    fn parse_case_expr(&mut self) -> Result<Expr<Raw>, ParserError> {
855        let mut operand = None;
856        if !self.parse_keyword(WHEN) {
857            operand = Some(Box::new(self.parse_expr()?));
858            self.expect_keyword(WHEN)?;
859        }
860        let mut conditions = vec![];
861        let mut results = vec![];
862        loop {
863            conditions.push(self.parse_expr()?);
864            self.expect_keyword(THEN)?;
865            results.push(self.parse_expr()?);
866            if !self.parse_keyword(WHEN) {
867                break;
868            }
869        }
870        let else_result = if self.parse_keyword(ELSE) {
871            Some(Box::new(self.parse_expr()?))
872        } else {
873            None
874        };
875        self.expect_keyword(END)?;
876        Ok(Expr::Case {
877            operand,
878            conditions,
879            results,
880            else_result,
881        })
882    }
883
884    /// Parse a SQL CAST function e.g. `CAST(expr AS FLOAT)`
885    fn parse_cast_expr(&mut self) -> Result<Expr<Raw>, ParserError> {
886        self.expect_token(&Token::LParen)?;
887        let expr = self.parse_expr()?;
888        self.expect_keyword(AS)?;
889        let data_type = self.parse_data_type()?;
890        self.expect_token(&Token::RParen)?;
891        // We are potentially rewriting an expression like
892        //     CAST(<expr> OP <expr> AS <type>)
893        // to
894        //     <expr> OP <expr>::<type>
895        // (because we print Expr::Cast always as a Postgres-style cast, i.e. `::`)
896        // which could incorrectly change the meaning of the expression
897        // as the `::` binds tightly. To be safe, we wrap the inner
898        // expression in parentheses
899        //    (<expr> OP <expr>)::<type>
900        // unless the inner expression is of a kind that we know is
901        // safe to follow with a `::` without wrapping.
902        if !matches!(
903            expr,
904            Expr::Nested(_)
905                | Expr::Value(_)
906                | Expr::Cast { .. }
907                | Expr::Function { .. }
908                | Expr::Identifier { .. }
909                | Expr::Collate { .. }
910                | Expr::HomogenizingFunction { .. }
911                | Expr::NullIf { .. }
912                | Expr::Subquery { .. }
913                | Expr::Parameter(..)
914        ) {
915            Ok(Expr::Cast {
916                expr: Box::new(Expr::Nested(Box::new(expr))),
917                data_type,
918            })
919        } else {
920            Ok(Expr::Cast {
921                expr: Box::new(expr),
922                data_type,
923            })
924        }
925    }
926
927    /// Parse a SQL EXISTS expression e.g. `WHERE EXISTS(SELECT ...)`.
928    fn parse_exists_expr(&mut self) -> Result<Expr<Raw>, ParserError> {
929        self.expect_token(&Token::LParen)?;
930        let exists_node = Expr::Exists(Box::new(self.parse_query()?));
931        self.expect_token(&Token::RParen)?;
932        Ok(exists_node)
933    }
934
935    fn parse_homogenizing_function(
936        &mut self,
937        function: HomogenizingFunction,
938    ) -> Result<Expr<Raw>, ParserError> {
939        self.expect_token(&Token::LParen)?;
940        let exprs = self.parse_comma_separated(Parser::parse_expr)?;
941        self.expect_token(&Token::RParen)?;
942        Ok(Expr::HomogenizingFunction { function, exprs })
943    }
944
945    fn parse_nullif_expr(&mut self) -> Result<Expr<Raw>, ParserError> {
946        self.expect_token(&Token::LParen)?;
947        let l_expr = Box::new(self.parse_expr()?);
948        self.expect_token(&Token::Comma)?;
949        let r_expr = Box::new(self.parse_expr()?);
950        self.expect_token(&Token::RParen)?;
951        Ok(Expr::NullIf { l_expr, r_expr })
952    }
953
954    // Parse calls to extract(), which can take the form:
955    // - extract(field from 'interval')
956    fn parse_extract_expr(&mut self) -> Result<Expr<Raw>, ParserError> {
957        self.expect_token(&Token::LParen)?;
958        let field = match self.next_token() {
959            Some(Token::Keyword(kw)) => Ident::from(kw).into_string(),
960            Some(Token::Ident(id)) => self.new_identifier(id)?.into_string(),
961            Some(Token::String(s)) => s,
962            t => self.expected(self.peek_prev_pos(), "extract field token", t)?,
963        };
964        self.expect_keyword(FROM)?;
965        let expr = self.parse_expr()?;
966        self.expect_token(&Token::RParen)?;
967        Ok(Expr::Function(Function {
968            name: RawItemName::Name(UnresolvedItemName::unqualified(ident!("extract"))),
969            args: FunctionArgs::args(vec![Expr::Value(Value::String(field)), expr]),
970            filter: None,
971            over: None,
972            distinct: false,
973        }))
974    }
975
976    fn parse_row_expr(&mut self) -> Result<Expr<Raw>, ParserError> {
977        self.expect_token(&Token::LParen)?;
978        if self.consume_token(&Token::RParen) {
979            Ok(Expr::Row { exprs: vec![] })
980        } else {
981            let exprs = self.parse_comma_separated(Parser::parse_expr)?;
982            self.expect_token(&Token::RParen)?;
983            Ok(Expr::Row { exprs })
984        }
985    }
986
987    fn parse_composite_type_definition(&mut self) -> Result<Vec<ColumnDef<Raw>>, ParserError> {
988        self.expect_token(&Token::LParen)?;
989        let fields = self.parse_comma_separated(|parser| {
990            Ok(ColumnDef {
991                name: parser.parse_identifier()?,
992                data_type: parser.parse_data_type()?,
993                collation: None,
994                options: vec![],
995            })
996        })?;
997        self.expect_token(&Token::RParen)?;
998        Ok(fields)
999    }
1000
1001    // Parse calls to trim(), which can take the form:
1002    // - trim(side 'chars' from 'string')
1003    // - trim('chars' from 'string')
1004    // - trim(side from 'string')
1005    // - trim(from 'string')
1006    // - trim('string')
1007    // - trim(side 'string')
1008    fn parse_trim_expr(&mut self) -> Result<Expr<Raw>, ParserError> {
1009        self.expect_token(&Token::LParen)?;
1010        let name = match self.parse_one_of_keywords(&[BOTH, LEADING, TRAILING]) {
1011            None | Some(BOTH) => ident!("btrim"),
1012            Some(LEADING) => ident!("ltrim"),
1013            Some(TRAILING) => ident!("rtrim"),
1014            _ => unreachable!(),
1015        };
1016        let mut exprs = Vec::new();
1017        if self.parse_keyword(FROM) {
1018            // 'string'
1019            exprs.push(self.parse_expr()?);
1020        } else {
1021            // Either 'chars' or 'string'
1022            exprs.push(self.parse_expr()?);
1023            if self.parse_keyword(FROM) {
1024                // 'string'; previous must be 'chars'
1025                // Swap 'chars' and 'string' for compatibility with btrim, ltrim, and rtrim.
1026                exprs.insert(0, self.parse_expr()?);
1027            }
1028        }
1029        self.expect_token(&Token::RParen)?;
1030        Ok(Expr::Function(Function {
1031            name: RawItemName::Name(UnresolvedItemName::unqualified(name)),
1032            args: FunctionArgs::args(exprs),
1033            filter: None,
1034            over: None,
1035            distinct: false,
1036        }))
1037    }
1038
1039    // Parse calls to position(), which has the special form position('string' in 'string').
1040    fn parse_position_expr(&mut self) -> Result<Expr<Raw>, ParserError> {
1041        self.expect_token(&Token::LParen)?;
1042        // we must be greater-equal the precedence of IN, which is Like to avoid
1043        // parsing away the IN as part of the sub expression
1044        let needle = self.parse_subexpr(Precedence::Like)?;
1045        self.expect_token(&Token::Keyword(IN))?;
1046        let haystack = self.parse_expr()?;
1047        self.expect_token(&Token::RParen)?;
1048        Ok(Expr::Function(Function {
1049            name: RawItemName::Name(UnresolvedItemName::unqualified(ident!("position"))),
1050            args: FunctionArgs::args(vec![needle, haystack]),
1051            filter: None,
1052            over: None,
1053            distinct: false,
1054        }))
1055    }
1056
1057    /// Parse an INTERVAL literal.
1058    ///
1059    /// Some syntactically valid intervals:
1060    ///
1061    ///   - `INTERVAL '1' DAY`
1062    ///   - `INTERVAL '1-1' YEAR TO MONTH`
1063    ///   - `INTERVAL '1' SECOND`
1064    ///   - `INTERVAL '1:1' MINUTE TO SECOND
1065    ///   - `INTERVAL '1:1:1.1' HOUR TO SECOND (5)`
1066    ///   - `INTERVAL '1.111' SECOND (2)`
1067    ///
1068    fn parse_interval_value(&mut self) -> Result<IntervalValue, ParserError> {
1069        // The first token in an interval is a string literal which specifies
1070        // the duration of the interval.
1071        let value = self.parse_literal_string()?;
1072
1073        // Determine the range of TimeUnits, whether explicit (`INTERVAL ... DAY TO MINUTE`) or
1074        // implicit (in which all date fields are eligible).
1075        let (precision_high, precision_low, fsec_max_precision) =
1076            match self.expect_one_of_keywords(&[
1077                YEAR, MONTH, DAY, HOUR, MINUTE, SECOND, YEARS, MONTHS, DAYS, HOURS, MINUTES,
1078                SECONDS,
1079            ]) {
1080                Ok(d) => {
1081                    let d_pos = self.peek_prev_pos();
1082                    if self.parse_keyword(TO) {
1083                        let e = self.expect_one_of_keywords(&[
1084                            YEAR, MONTH, DAY, HOUR, MINUTE, SECOND, YEARS, MONTHS, DAYS, HOURS,
1085                            MINUTES, SECONDS,
1086                        ])?;
1087
1088                        let high: DateTimeField = d
1089                            .as_str()
1090                            .parse()
1091                            .map_err(|e| self.error(self.peek_prev_pos(), e))?;
1092                        let low: DateTimeField = e
1093                            .as_str()
1094                            .parse()
1095                            .map_err(|e| self.error(self.peek_prev_pos(), e))?;
1096
1097                        // Check for invalid ranges, i.e. precision_high is the same
1098                        // as or a less significant DateTimeField than
1099                        // precision_low.
1100                        if high >= low {
1101                            return parser_err!(
1102                                self,
1103                                d_pos,
1104                                "Invalid field range in INTERVAL '{}' {} TO {}; the value in the \
1105                                 position of {} should be more significant than {}.",
1106                                value,
1107                                d,
1108                                e,
1109                                d,
1110                                e,
1111                            );
1112                        }
1113
1114                        let fsec_max_precision = if low == DateTimeField::Second {
1115                            self.parse_optional_precision()?
1116                        } else {
1117                            None
1118                        };
1119
1120                        (high, low, fsec_max_precision)
1121                    } else {
1122                        let low: DateTimeField = d
1123                            .as_str()
1124                            .parse()
1125                            .map_err(|e| self.error(self.peek_prev_pos(), e))?;
1126                        let fsec_max_precision = if low == DateTimeField::Second {
1127                            self.parse_optional_precision()?
1128                        } else {
1129                            None
1130                        };
1131
1132                        (DateTimeField::Year, low, fsec_max_precision)
1133                    }
1134                }
1135                Err(_) => (DateTimeField::Year, DateTimeField::Second, None),
1136            };
1137        Ok(IntervalValue {
1138            value,
1139            precision_high,
1140            precision_low,
1141            fsec_max_precision,
1142        })
1143    }
1144
1145    /// Parse an operator following an expression
1146    fn parse_infix(
1147        &mut self,
1148        expr: Expr<Raw>,
1149        precedence: Precedence,
1150    ) -> Result<Expr<Raw>, ParserError> {
1151        let tok = self.next_token().unwrap(); // safe as EOF's precedence is the lowest
1152
1153        let regular_binary_operator = match &tok {
1154            Token::Op(s) => Some(Op::bare(s)),
1155            Token::Eq => Some(Op::bare("=")),
1156            Token::Star => Some(Op::bare("*")),
1157            Token::Keyword(OPERATOR) => {
1158                self.expect_token(&Token::LParen)?;
1159                let op = self.parse_operator()?;
1160                self.expect_token(&Token::RParen)?;
1161                Some(op)
1162            }
1163            _ => None,
1164        };
1165
1166        if let Some(op) = regular_binary_operator {
1167            if let Some(kw) = self.parse_one_of_keywords(ANY_ALL_KEYWORDS) {
1168                self.parse_any_all(expr, op, kw)
1169            } else {
1170                Ok(Expr::Op {
1171                    op,
1172                    expr1: Box::new(expr),
1173                    expr2: Some(Box::new(self.parse_subexpr(precedence)?)),
1174                })
1175            }
1176        } else if let Token::Keyword(kw) = tok {
1177            match kw {
1178                IS => {
1179                    let negated = self.parse_keyword(NOT);
1180                    if let Some(construct) =
1181                        self.parse_one_of_keywords(&[NULL, TRUE, FALSE, UNKNOWN, DISTINCT])
1182                    {
1183                        Ok(Expr::IsExpr {
1184                            expr: Box::new(expr),
1185                            negated,
1186                            construct: match construct {
1187                                NULL => IsExprConstruct::Null,
1188                                TRUE => IsExprConstruct::True,
1189                                FALSE => IsExprConstruct::False,
1190                                UNKNOWN => IsExprConstruct::Unknown,
1191                                DISTINCT => {
1192                                    self.expect_keyword(FROM)?;
1193                                    let expr = self.parse_expr()?;
1194                                    IsExprConstruct::DistinctFrom(Box::new(expr))
1195                                }
1196                                _ => unreachable!(),
1197                            },
1198                        })
1199                    } else {
1200                        self.expected(
1201                            self.peek_pos(),
1202                            "NULL, NOT NULL, TRUE, NOT TRUE, FALSE, NOT FALSE, UNKNOWN, NOT UNKNOWN after IS",
1203                            self.peek_token(),
1204                        )
1205                    }
1206                }
1207                ISNULL => Ok(Expr::IsExpr {
1208                    expr: Box::new(expr),
1209                    negated: false,
1210                    construct: IsExprConstruct::Null,
1211                }),
1212                NOT | IN | LIKE | ILIKE | BETWEEN => {
1213                    self.prev_token();
1214                    let negated = self.parse_keyword(NOT);
1215                    if self.parse_keyword(IN) {
1216                        self.parse_in(expr, negated)
1217                    } else if self.parse_keyword(BETWEEN) {
1218                        self.parse_between(expr, negated)
1219                    } else if self.parse_keyword(LIKE) {
1220                        self.parse_like(expr, false, negated)
1221                    } else if self.parse_keyword(ILIKE) {
1222                        self.parse_like(expr, true, negated)
1223                    } else {
1224                        self.expected(
1225                            self.peek_pos(),
1226                            "IN, BETWEEN, LIKE, or ILIKE after NOT",
1227                            self.peek_token(),
1228                        )
1229                    }
1230                }
1231                AND => Ok(Expr::And {
1232                    left: Box::new(expr),
1233                    right: Box::new(self.parse_subexpr(precedence)?),
1234                }),
1235                OR => Ok(Expr::Or {
1236                    left: Box::new(expr),
1237                    right: Box::new(self.parse_subexpr(precedence)?),
1238                }),
1239                AT => {
1240                    self.expect_keywords(&[TIME, ZONE])?;
1241                    Ok(Expr::Function(Function {
1242                        name: RawItemName::Name(UnresolvedItemName::unqualified(ident!(
1243                            "timezone"
1244                        ))),
1245                        args: FunctionArgs::args(vec![self.parse_subexpr(precedence)?, expr]),
1246                        filter: None,
1247                        over: None,
1248                        distinct: false,
1249                    }))
1250                }
1251                COLLATE => Ok(Expr::Collate {
1252                    expr: Box::new(expr),
1253                    collation: self.parse_item_name()?,
1254                }),
1255                // Can only happen if `get_next_precedence` got out of sync with this function
1256                _ => panic!("No infix parser for token {:?}", tok),
1257            }
1258        } else if Token::DoubleColon == tok {
1259            self.parse_pg_cast(expr)
1260        } else if Token::LBracket == tok {
1261            self.prev_token();
1262            self.parse_subscript(expr)
1263        } else if Token::Dot == tok {
1264            match self.next_token() {
1265                Some(Token::Ident(id)) => Ok(Expr::FieldAccess {
1266                    expr: Box::new(expr),
1267                    field: self.new_identifier(id)?,
1268                }),
1269                // Per PostgreSQL, even reserved keywords are ok after a field
1270                // access operator.
1271                Some(Token::Keyword(kw)) => Ok(Expr::FieldAccess {
1272                    expr: Box::new(expr),
1273                    field: kw.into(),
1274                }),
1275                Some(Token::Star) => Ok(Expr::WildcardAccess(Box::new(expr))),
1276                unexpected => self.expected(
1277                    self.peek_prev_pos(),
1278                    "an identifier or a '*' after '.'",
1279                    unexpected,
1280                ),
1281            }
1282        } else {
1283            // Can only happen if `get_next_precedence` got out of sync with this function
1284            panic!("No infix parser for token {:?}", tok)
1285        }
1286    }
1287
1288    /// Parse subscript expression, i.e. either an index value or slice range.
1289    fn parse_subscript(&mut self, expr: Expr<Raw>) -> Result<Expr<Raw>, ParserError> {
1290        let mut positions = Vec::new();
1291
1292        while self.consume_token(&Token::LBracket) {
1293            let start = if self.peek_token() == Some(Token::Colon) {
1294                None
1295            } else {
1296                Some(self.parse_expr()?)
1297            };
1298
1299            let (end, explicit_slice) = if self.consume_token(&Token::Colon) {
1300                // Presence of a colon means these positions were explicit
1301                (
1302                    // Terminated expr
1303                    if self.peek_token() == Some(Token::RBracket) {
1304                        None
1305                    } else {
1306                        Some(self.parse_expr()?)
1307                    },
1308                    true,
1309                )
1310            } else {
1311                (None, false)
1312            };
1313
1314            assert!(
1315                start.is_some() || explicit_slice,
1316                "user typed something between brackets"
1317            );
1318
1319            assert!(
1320                explicit_slice || end.is_none(),
1321                "if end is some, must have an explicit slice"
1322            );
1323
1324            positions.push(SubscriptPosition {
1325                start,
1326                end,
1327                explicit_slice,
1328            });
1329            self.expect_token(&Token::RBracket)?;
1330        }
1331
1332        // If the expression that is being cast can end with a type name, then let's parenthesize
1333        // it. Otherwise, the `[...]` would melt into the type name (making it an array type).
1334        // Specifically, the only expressions whose printing can end with a type name are casts, so
1335        // check for that.
1336        if matches!(expr, Expr::Cast { .. }) {
1337            Ok(Expr::Subscript {
1338                expr: Box::new(Expr::Nested(Box::new(expr))),
1339                positions,
1340            })
1341        } else {
1342            Ok(Expr::Subscript {
1343                expr: Box::new(expr),
1344                positions,
1345            })
1346        }
1347    }
1348
1349    // Parse calls to substring(), which can take the form:
1350    // - substring('string', 'int')
1351    // - substring('string', 'int', 'int')
1352    // - substring('string' FROM 'int')
1353    // - substring('string' FROM 'int' FOR 'int')
1354    // - substring('string' FOR 'int')
1355    fn parse_substring_expr(&mut self) -> Result<Expr<Raw>, ParserError> {
1356        self.expect_token(&Token::LParen)?;
1357        let mut exprs = vec![self.parse_expr()?];
1358        if self.parse_keyword(FROM) {
1359            // 'string' FROM 'int'
1360            exprs.push(self.parse_expr()?);
1361            if self.parse_keyword(FOR) {
1362                // 'string' FROM 'int' FOR 'int'
1363                exprs.push(self.parse_expr()?);
1364            }
1365        } else if self.parse_keyword(FOR) {
1366            // 'string' FOR 'int'
1367            exprs.push(Expr::Value(Value::Number(String::from("1"))));
1368            exprs.push(self.parse_expr()?);
1369        } else {
1370            // 'string', 'int'
1371            // or
1372            // 'string', 'int', 'int'
1373            self.expect_token(&Token::Comma)?;
1374            exprs.extend(self.parse_comma_separated(Parser::parse_expr)?);
1375        }
1376
1377        self.expect_token(&Token::RParen)?;
1378        Ok(Expr::Function(Function {
1379            name: RawItemName::Name(UnresolvedItemName::unqualified(ident!("substring"))),
1380            args: FunctionArgs::args(exprs),
1381            filter: None,
1382            over: None,
1383            distinct: false,
1384        }))
1385    }
1386
1387    /// Parse an operator reference.
1388    ///
1389    /// Examples:
1390    ///   * `+`
1391    ///   * `OPERATOR(schema.+)`
1392    ///   * `OPERATOR("foo"."bar"."baz".@>)`
1393    fn parse_operator(&mut self) -> Result<Op, ParserError> {
1394        let mut namespace = vec![];
1395        let op = loop {
1396            match self.next_token() {
1397                Some(Token::Keyword(kw)) => namespace.push(kw.into()),
1398                Some(Token::Ident(id)) => namespace.push(self.new_identifier(id)?),
1399                Some(Token::Op(op)) => break op,
1400                Some(Token::Star) => break "*".to_string(),
1401                tok => self.expected(self.peek_prev_pos(), "operator", tok)?,
1402            }
1403            self.expect_token(&Token::Dot)?;
1404        };
1405        Ok(Op {
1406            namespace: Some(namespace),
1407            op,
1408        })
1409    }
1410
1411    /// Parses an `ANY`, `ALL`, or `SOME` operation, starting after the `ANY`,
1412    /// `ALL`, or `SOME` keyword.
1413    fn parse_any_all(
1414        &mut self,
1415        left: Expr<Raw>,
1416        op: Op,
1417        kw: Keyword,
1418    ) -> Result<Expr<Raw>, ParserError> {
1419        self.expect_token(&Token::LParen)?;
1420
1421        let expr = match self.parse_parenthesized_fragment()? {
1422            ParenthesizedFragment::Exprs(exprs) => {
1423                if exprs.len() > 1 {
1424                    return parser_err!(
1425                        self,
1426                        self.peek_pos(),
1427                        "{kw} requires a single expression or subquery, not an expression list",
1428                    );
1429                }
1430                let right = exprs.into_element();
1431                if kw == ALL {
1432                    Expr::AllExpr {
1433                        left: Box::new(left),
1434                        op,
1435                        right: Box::new(right),
1436                    }
1437                } else {
1438                    Expr::AnyExpr {
1439                        left: Box::new(left),
1440                        op,
1441                        right: Box::new(right),
1442                    }
1443                }
1444            }
1445            ParenthesizedFragment::Query(subquery) => {
1446                if kw == ALL {
1447                    Expr::AllSubquery {
1448                        left: Box::new(left),
1449                        op,
1450                        right: Box::new(subquery),
1451                    }
1452                } else {
1453                    Expr::AnySubquery {
1454                        left: Box::new(left),
1455                        op,
1456                        right: Box::new(subquery),
1457                    }
1458                }
1459            }
1460        };
1461
1462        self.expect_token(&Token::RParen)?;
1463
1464        Ok(expr)
1465    }
1466
1467    /// Parses the parens following the `[ NOT ] IN` operator
1468    fn parse_in(&mut self, expr: Expr<Raw>, negated: bool) -> Result<Expr<Raw>, ParserError> {
1469        self.expect_token(&Token::LParen)?;
1470        let in_op = match self.parse_parenthesized_fragment()? {
1471            ParenthesizedFragment::Exprs(list) => Expr::InList {
1472                expr: Box::new(expr),
1473                list,
1474                negated,
1475            },
1476            ParenthesizedFragment::Query(subquery) => Expr::InSubquery {
1477                expr: Box::new(expr),
1478                subquery: Box::new(subquery),
1479                negated,
1480            },
1481        };
1482        self.expect_token(&Token::RParen)?;
1483        Ok(in_op)
1484    }
1485
1486    /// Parses `BETWEEN <low> AND <high>`, assuming the `BETWEEN` keyword was already consumed
1487    fn parse_between(&mut self, expr: Expr<Raw>, negated: bool) -> Result<Expr<Raw>, ParserError> {
1488        // Stop parsing subexpressions for <low> and <high> on tokens with
1489        // precedence lower than that of `BETWEEN`, such as `AND`, `IS`, etc.
1490        let low = self.parse_subexpr(Precedence::Like)?;
1491        self.expect_keyword(AND)?;
1492        let high = self.parse_subexpr(Precedence::Like)?;
1493        Ok(Expr::Between {
1494            expr: Box::new(expr),
1495            negated,
1496            low: Box::new(low),
1497            high: Box::new(high),
1498        })
1499    }
1500
1501    /// Parses `LIKE <pattern> [ ESCAPE <char> ]`, assuming the `LIKE` keyword was already consumed
1502    fn parse_like(
1503        &mut self,
1504        expr: Expr<Raw>,
1505        case_insensitive: bool,
1506        negated: bool,
1507    ) -> Result<Expr<Raw>, ParserError> {
1508        if let Some(kw) = self.parse_one_of_keywords(ANY_ALL_KEYWORDS) {
1509            let op = match (case_insensitive, negated) {
1510                (false, false) => "~~",
1511                (false, true) => "!~~",
1512                (true, false) => "~~*",
1513                (true, true) => "!~~*",
1514            };
1515            return self.parse_any_all(expr, Op::bare(op), kw);
1516        }
1517        let pattern = self.parse_subexpr(Precedence::Like)?;
1518        let escape = if self.parse_keyword(ESCAPE) {
1519            Some(Box::new(self.parse_subexpr(Precedence::Like)?))
1520        } else {
1521            None
1522        };
1523        Ok(Expr::Like {
1524            expr: Box::new(expr),
1525            pattern: Box::new(pattern),
1526            escape,
1527            case_insensitive,
1528            negated,
1529        })
1530    }
1531
1532    /// Parse a postgresql casting style which is in the form of `expr::datatype`
1533    fn parse_pg_cast(&mut self, expr: Expr<Raw>) -> Result<Expr<Raw>, ParserError> {
1534        Ok(Expr::Cast {
1535            expr: Box::new(expr),
1536            data_type: self.parse_data_type()?,
1537        })
1538    }
1539
1540    /// Get the precedence of the next token
1541    fn get_next_precedence(&self) -> Precedence {
1542        if let Some(token) = self.peek_token() {
1543            match &token {
1544                Token::Keyword(OR) => Precedence::Or,
1545                Token::Keyword(AND) => Precedence::And,
1546                Token::Keyword(NOT) => match &self.peek_nth_token(1) {
1547                    // The precedence of NOT varies depending on keyword that
1548                    // follows it. If it is followed by IN, BETWEEN, or LIKE,
1549                    // it takes on the precedence of those tokens. Otherwise it
1550                    // is not an infix operator, and therefore has zero
1551                    // precedence.
1552                    Some(Token::Keyword(IN)) => Precedence::Like,
1553                    Some(Token::Keyword(BETWEEN)) => Precedence::Like,
1554                    Some(Token::Keyword(ILIKE)) => Precedence::Like,
1555                    Some(Token::Keyword(LIKE)) => Precedence::Like,
1556                    _ => Precedence::Zero,
1557                },
1558                Token::Keyword(IS) | Token::Keyword(ISNULL) => Precedence::Is,
1559                Token::Keyword(IN) => Precedence::Like,
1560                Token::Keyword(BETWEEN) => Precedence::Like,
1561                Token::Keyword(ILIKE) => Precedence::Like,
1562                Token::Keyword(LIKE) => Precedence::Like,
1563                Token::Keyword(OPERATOR) => Precedence::Other,
1564                Token::Op(s) => match s.as_str() {
1565                    "<" | "<=" | "<>" | "!=" | ">" | ">=" => Precedence::Cmp,
1566                    "+" | "-" => Precedence::PlusMinus,
1567                    "/" | "%" => Precedence::MultiplyDivide,
1568                    _ => Precedence::Other,
1569                },
1570                Token::Eq => Precedence::Cmp,
1571                Token::Star => Precedence::MultiplyDivide,
1572                Token::Keyword(COLLATE) | Token::Keyword(AT) => Precedence::PostfixCollateAt,
1573                Token::DoubleColon | Token::LBracket | Token::Dot => {
1574                    Precedence::PostfixSubscriptCast
1575                }
1576                _ => Precedence::Zero,
1577            }
1578        } else {
1579            Precedence::Zero
1580        }
1581    }
1582
1583    /// Return the first non-whitespace token that has not yet been processed
1584    /// (or None if reached end-of-file)
1585    fn peek_token(&self) -> Option<Token> {
1586        self.peek_nth_token(0)
1587    }
1588
1589    fn peek_keyword(&self, kw: Keyword) -> bool {
1590        match self.peek_token() {
1591            Some(Token::Keyword(k)) => k == kw,
1592            _ => false,
1593        }
1594    }
1595
1596    fn peek_keywords(&self, keywords: &[Keyword]) -> bool {
1597        self.peek_keywords_from(0, keywords)
1598    }
1599
1600    fn peek_keywords_from(&self, start: usize, keywords: &[Keyword]) -> bool {
1601        for (i, keyword) in keywords.iter().enumerate() {
1602            match self.peek_nth_token(start + i) {
1603                Some(Token::Keyword(k)) => {
1604                    if k != *keyword {
1605                        return false;
1606                    }
1607                }
1608                _ => return false,
1609            }
1610        }
1611        true
1612    }
1613
1614    fn peek_one_of_keywords(&self, kws: &[Keyword]) -> bool {
1615        match self.peek_token() {
1616            Some(Token::Keyword(k)) => kws.contains(&k),
1617            _ => false,
1618        }
1619    }
1620
1621    /// Returns whether the sequence of keywords is found at any point before
1622    /// the end of the unprocessed tokens.
1623    fn peek_keywords_lookahead(&self, keywords: &[Keyword]) -> bool {
1624        let mut index = 0;
1625        while index < self.tokens.len() {
1626            if self.peek_keywords_from(index, keywords) {
1627                return true;
1628            }
1629            index += 1;
1630        }
1631        false
1632    }
1633
1634    /// Return the nth token that has not yet been processed.
1635    fn peek_nth_token(&self, n: usize) -> Option<Token> {
1636        self.tokens
1637            .get(self.index + n)
1638            .map(|token| token.kind.clone())
1639    }
1640
1641    /// Return the next token that has not yet been processed, or None if
1642    /// reached end-of-file, and mark it as processed. OK to call repeatedly
1643    /// after reaching EOF.
1644    fn next_token(&mut self) -> Option<Token> {
1645        let token = self.tokens.get(self.index).map(|token| token.kind.clone());
1646        self.index += 1;
1647        token
1648    }
1649
1650    /// Push back the last one non-whitespace token. Must be called after
1651    /// `next_token()`, otherwise might panic. OK to call after
1652    /// `next_token()` indicates an EOF.
1653    fn prev_token(&mut self) {
1654        assert!(self.index > 0);
1655        self.index -= 1;
1656    }
1657
1658    /// Return the byte position within the query string at which the
1659    /// next token starts.
1660    fn peek_pos(&self) -> usize {
1661        match self.tokens.get(self.index) {
1662            Some(token) => token.offset,
1663            None => self.sql.len(),
1664        }
1665    }
1666
1667    /// Return the byte position within the query string at which the previous
1668    /// token starts.
1669    ///
1670    /// Must be called after `next_token()`, otherwise might panic.
1671    /// OK to call after `next_token()` indicates an EOF.
1672    fn peek_prev_pos(&self) -> usize {
1673        assert!(self.index > 0);
1674        match self.tokens.get(self.index - 1) {
1675            Some(token) => token.offset,
1676            None => self.sql.len(),
1677        }
1678    }
1679
1680    /// Report unexpected token
1681    fn expected<D, T>(
1682        &self,
1683        pos: usize,
1684        expected: D,
1685        found: Option<Token>,
1686    ) -> Result<T, ParserError>
1687    where
1688        D: fmt::Display,
1689    {
1690        parser_err!(
1691            self,
1692            pos,
1693            "Expected {}, found {}",
1694            expected,
1695            found.display_or("EOF"),
1696        )
1697    }
1698
1699    /// Look for an expected keyword and consume it if it exists
1700    #[must_use]
1701    fn parse_keyword(&mut self, kw: Keyword) -> bool {
1702        if self.peek_keyword(kw) {
1703            self.next_token();
1704            true
1705        } else {
1706            false
1707        }
1708    }
1709
1710    /// Look for an expected sequence of keywords and consume them if they exist
1711    #[must_use]
1712    fn parse_keywords(&mut self, keywords: &[Keyword]) -> bool {
1713        if self.peek_keywords(keywords) {
1714            self.index += keywords.len();
1715            true
1716        } else {
1717            false
1718        }
1719    }
1720
1721    fn parse_at_most_one_keyword(
1722        &mut self,
1723        keywords: &[Keyword],
1724        location: &str,
1725    ) -> Result<Option<Keyword>, ParserError> {
1726        match self.parse_one_of_keywords(keywords) {
1727            Some(first) => {
1728                let remaining_keywords = keywords
1729                    .iter()
1730                    .cloned()
1731                    .filter(|k| *k != first)
1732                    .collect::<Vec<_>>();
1733                if let Some(second) = self.parse_one_of_keywords(remaining_keywords.as_slice()) {
1734                    let second_pos = self.peek_prev_pos();
1735                    parser_err!(
1736                        self,
1737                        second_pos,
1738                        "Cannot specify both {} and {} in {}",
1739                        first,
1740                        second,
1741                        location,
1742                    )
1743                } else {
1744                    Ok(Some(first))
1745                }
1746            }
1747            None => Ok(None),
1748        }
1749    }
1750
1751    /// Look for one of the given keywords and return the one that matches.
1752    #[must_use]
1753    fn parse_one_of_keywords(&mut self, kws: &[Keyword]) -> Option<Keyword> {
1754        match self.peek_token() {
1755            Some(Token::Keyword(k)) if kws.contains(&k) => {
1756                self.next_token();
1757                Some(k)
1758            }
1759            _ => None,
1760        }
1761    }
1762
1763    /// Bail out if the current token is not one of the expected keywords, or consume it if it is
1764    fn expect_one_of_keywords(&mut self, keywords: &[Keyword]) -> Result<Keyword, ParserError> {
1765        if let Some(keyword) = self.parse_one_of_keywords(keywords) {
1766            Ok(keyword)
1767        } else {
1768            self.expected(
1769                self.peek_pos(),
1770                format!("one of {}", keywords.iter().join(" or ")),
1771                self.peek_token(),
1772            )
1773        }
1774    }
1775
1776    /// Bail out if the current token is not an expected keyword, or consume it if it is
1777    fn expect_keyword(&mut self, expected: Keyword) -> Result<(), ParserError> {
1778        if self.parse_keyword(expected) {
1779            Ok(())
1780        } else {
1781            self.expected(self.peek_pos(), expected, self.peek_token())
1782        }
1783    }
1784
1785    /// Bail out if the following tokens are not the expected sequence of
1786    /// keywords, or consume them if they are.
1787    fn expect_keywords(&mut self, expected: &[Keyword]) -> Result<(), ParserError> {
1788        for kw in expected {
1789            self.expect_keyword(*kw)?;
1790        }
1791        Ok(())
1792    }
1793
1794    /// Consume the next token if it matches the expected token, otherwise return false
1795    #[must_use]
1796    fn consume_token(&mut self, expected: &Token) -> bool {
1797        match &self.peek_token() {
1798            Some(t) if *t == *expected => {
1799                self.next_token();
1800                true
1801            }
1802            _ => false,
1803        }
1804    }
1805
1806    /// Bail out if the current token is not an expected token, or consume it if it is
1807    fn expect_token(&mut self, expected: &Token) -> Result<(), ParserError> {
1808        if self.consume_token(expected) {
1809            Ok(())
1810        } else {
1811            self.expected(self.peek_pos(), expected, self.peek_token())
1812        }
1813    }
1814
1815    /// Bail out if the current token is not one of the expected tokens, or consume it if it is
1816    fn expect_one_of_tokens(&mut self, tokens: &[Token]) -> Result<Token, ParserError> {
1817        match self.peek_token() {
1818            Some(t) if tokens.iter().find(|token| t == **token).is_some() => {
1819                let _ = self.next_token();
1820                Ok(t)
1821            }
1822            _ => self.expected(
1823                self.peek_pos(),
1824                format!("one of {}", tokens.iter().join(" or ")),
1825                self.peek_token(),
1826            ),
1827        }
1828    }
1829
1830    /// Bail out if the current token is not an expected keyword or token, or consume it if it is
1831    fn expect_keyword_or_token(
1832        &mut self,
1833        expected_keyword: Keyword,
1834        expected_token: &Token,
1835    ) -> Result<(), ParserError> {
1836        if self.parse_keyword(expected_keyword) || self.consume_token(expected_token) {
1837            Ok(())
1838        } else {
1839            self.expected(
1840                self.peek_pos(),
1841                format!("{expected_keyword} or {expected_token}"),
1842                self.peek_token(),
1843            )
1844        }
1845    }
1846
1847    /// Parse a comma-separated list of 1+ items accepted by `F`
1848    fn parse_comma_separated<T, F>(&mut self, mut f: F) -> Result<Vec<T>, ParserError>
1849    where
1850        F: FnMut(&mut Self) -> Result<T, ParserError>,
1851    {
1852        let mut values = vec![];
1853        loop {
1854            values.push(f(self)?);
1855            if !self.consume_token(&Token::Comma) {
1856                break;
1857            }
1858        }
1859        Ok(values)
1860    }
1861
1862    #[must_use]
1863    fn maybe_parse<T, F>(&mut self, mut f: F) -> Option<T>
1864    where
1865        F: FnMut(&mut Self) -> Result<T, ParserError>,
1866    {
1867        let index = self.index;
1868        if let Ok(t) = f(self) {
1869            Some(t)
1870        } else {
1871            self.index = index;
1872            None
1873        }
1874    }
1875
1876    /// Parse a SQL CREATE statement
1877    fn parse_create(&mut self) -> Result<Statement<Raw>, ParserStatementError> {
1878        if self.peek_keyword(DATABASE) {
1879            self.parse_create_database()
1880                .map_parser_err(StatementKind::CreateDatabase)
1881        } else if self.peek_keyword(SCHEMA) {
1882            self.parse_create_schema()
1883                .map_parser_err(StatementKind::CreateSchema)
1884        } else if self.peek_keyword(SINK) {
1885            self.parse_create_sink()
1886                .map_parser_err(StatementKind::CreateSink)
1887        } else if self.peek_keyword(TYPE) {
1888            self.parse_create_type()
1889                .map_parser_err(StatementKind::CreateType)
1890        } else if self.peek_keyword(ROLE) {
1891            self.parse_create_role()
1892                .map_parser_err(StatementKind::CreateRole)
1893        } else if self.peek_keyword(CLUSTER) {
1894            self.next_token();
1895            if self.peek_keyword(REPLICA) {
1896                self.parse_create_cluster_replica()
1897                    .map_parser_err(StatementKind::CreateClusterReplica)
1898            } else {
1899                self.parse_create_cluster()
1900                    .map_parser_err(StatementKind::CreateCluster)
1901            }
1902        } else if self.peek_keyword(INDEX) || self.peek_keywords(&[DEFAULT, INDEX]) {
1903            self.parse_create_index()
1904                .map_parser_err(StatementKind::CreateIndex)
1905        } else if self.peek_keyword(SOURCE) {
1906            self.parse_create_source()
1907                .map_parser_err(StatementKind::CreateSource)
1908        } else if self.peek_keyword(SUBSOURCE) {
1909            self.parse_create_subsource()
1910                .map_parser_err(StatementKind::CreateSubsource)
1911        } else if self.peek_keyword(TABLE)
1912            || self.peek_keywords(&[TEMP, TABLE])
1913            || self.peek_keywords(&[TEMPORARY, TABLE])
1914        {
1915            if self.peek_keywords_lookahead(&[FROM, SOURCE])
1916                || self.peek_keywords_lookahead(&[FROM, WEBHOOK])
1917            {
1918                self.parse_create_table_from_source()
1919                    .map_parser_err(StatementKind::CreateTableFromSource)
1920            } else {
1921                self.parse_create_table()
1922                    .map_parser_err(StatementKind::CreateTable)
1923            }
1924        } else if self.peek_keyword(SECRET) {
1925            self.parse_create_secret()
1926                .map_parser_err(StatementKind::CreateSecret)
1927        } else if self.peek_keyword(CONNECTION) {
1928            self.parse_create_connection()
1929                .map_parser_err(StatementKind::CreateConnection)
1930        } else if self.peek_keywords(&[MATERIALIZED, VIEW])
1931            || self.peek_keywords(&[OR, REPLACE, MATERIALIZED, VIEW])
1932        {
1933            self.parse_create_materialized_view()
1934                .map_parser_err(StatementKind::CreateMaterializedView)
1935        } else if self.peek_keywords(&[CONTINUAL, TASK]) {
1936            if self.peek_keywords_lookahead(&[FROM, TRANSFORM]) {
1937                self.parse_create_continual_task_from_transform()
1938                    .map_parser_err(StatementKind::CreateContinualTask)
1939            } else if self.peek_keywords_lookahead(&[FROM, RETAIN]) {
1940                self.parse_create_continual_task_from_retain()
1941                    .map_parser_err(StatementKind::CreateContinualTask)
1942            } else {
1943                self.parse_create_continual_task()
1944                    .map_parser_err(StatementKind::CreateContinualTask)
1945            }
1946        } else if self.peek_keywords(&[USER]) {
1947            parser_err!(
1948                self,
1949                self.peek_pos(),
1950                "CREATE USER is not supported, for more information consult the documentation at https://materialize.com/docs/sql/create-role/#details"
1951            ).map_parser_err(StatementKind::CreateRole)
1952        } else if self.peek_keywords(&[NETWORK, POLICY]) {
1953            self.parse_create_network_policy()
1954                .map_parser_err(StatementKind::CreateNetworkPolicy)
1955        } else {
1956            let index = self.index;
1957
1958            // go over optional modifiers
1959            let parsed_or_replace = self.parse_keywords(&[OR, REPLACE]);
1960            let parsed_temporary = self.parse_one_of_keywords(&[TEMP, TEMPORARY]).is_some();
1961
1962            if self.parse_keyword(VIEW) {
1963                self.index = index;
1964                self.parse_create_view()
1965                    .map_parser_err(StatementKind::CreateView)
1966            } else {
1967                let expected_msg = match (parsed_or_replace, parsed_temporary) {
1968                    (true, true) => "VIEW after CREATE OR REPLACE TEMPORARY",
1969                    (true, false) => {
1970                        "[TEMPORARY] VIEW, or MATERIALIZED VIEW after CREATE OR REPLACE"
1971                    }
1972                    (false, true) => "TABLE, or VIEW after CREATE TEMPORARY",
1973                    (false, false) => {
1974                        "DATABASE, SCHEMA, ROLE, TYPE, INDEX, SINK, SOURCE, [TEMPORARY] TABLE, \
1975                        SECRET, [OR REPLACE] [TEMPORARY] VIEW, or [OR REPLACE] MATERIALIZED VIEW \
1976                        after CREATE"
1977                    }
1978                };
1979                self.expected(self.peek_pos(), expected_msg, self.peek_token())
1980                    .map_no_statement_parser_err()
1981            }
1982        }
1983    }
1984
1985    fn parse_create_database(&mut self) -> Result<Statement<Raw>, ParserError> {
1986        self.expect_keyword(DATABASE)?;
1987        let if_not_exists = self.parse_if_not_exists()?;
1988        let name = self.parse_database_name()?;
1989        Ok(Statement::CreateDatabase(CreateDatabaseStatement {
1990            name,
1991            if_not_exists,
1992        }))
1993    }
1994
1995    fn parse_create_schema(&mut self) -> Result<Statement<Raw>, ParserError> {
1996        self.expect_keyword(SCHEMA)?;
1997        let if_not_exists = self.parse_if_not_exists()?;
1998        let name = self.parse_schema_name()?;
1999        Ok(Statement::CreateSchema(CreateSchemaStatement {
2000            name,
2001            if_not_exists,
2002        }))
2003    }
2004
2005    fn parse_format(&mut self) -> Result<Format<Raw>, ParserError> {
2006        let format = if self.parse_keyword(AVRO) {
2007            self.expect_keyword(USING)?;
2008            Format::Avro(self.parse_avro_schema()?)
2009        } else if self.parse_keyword(PROTOBUF) {
2010            Format::Protobuf(self.parse_protobuf_schema()?)
2011        } else if self.parse_keyword(REGEX) {
2012            let regex = self.parse_literal_string()?;
2013            Format::Regex(regex)
2014        } else if self.parse_keyword(CSV) {
2015            self.expect_keyword(WITH)?;
2016            let columns = if self.parse_keyword(HEADER) || self.parse_keyword(HEADERS) {
2017                CsvColumns::Header {
2018                    names: self.parse_parenthesized_column_list(Mandatory)?,
2019                }
2020            } else {
2021                let n_cols = self.parse_literal_uint()?;
2022                self.expect_keyword(COLUMNS)?;
2023                CsvColumns::Count(n_cols)
2024            };
2025            let delimiter = if self.parse_keywords(&[DELIMITED, BY]) {
2026                let s = self.parse_literal_string()?;
2027                match s.len() {
2028                    1 => Ok(s.chars().next().unwrap()),
2029                    _ => self.expected(self.peek_pos(), "one-character string", self.peek_token()),
2030                }?
2031            } else {
2032                ','
2033            };
2034            Format::Csv { columns, delimiter }
2035        } else if self.parse_keyword(JSON) {
2036            let array = self.parse_keyword(ARRAY);
2037            Format::Json { array }
2038        } else if self.parse_keyword(TEXT) {
2039            Format::Text
2040        } else if self.parse_keyword(BYTES) {
2041            Format::Bytes
2042        } else {
2043            return self.expected(
2044                self.peek_pos(),
2045                "AVRO, PROTOBUF, REGEX, CSV, JSON, TEXT, or BYTES",
2046                self.peek_token(),
2047            );
2048        };
2049        Ok(format)
2050    }
2051
2052    fn parse_avro_schema(&mut self) -> Result<AvroSchema<Raw>, ParserError> {
2053        let avro_schema = if self.parse_keywords(&[CONFLUENT, SCHEMA, REGISTRY]) {
2054            let csr_connection = self.parse_csr_connection_avro()?;
2055            AvroSchema::Csr { csr_connection }
2056        } else if self.parse_keyword(SCHEMA) {
2057            self.prev_token();
2058            self.expect_keyword(SCHEMA)?;
2059            let schema = Schema {
2060                schema: self.parse_literal_string()?,
2061            };
2062            let with_options = if self.consume_token(&Token::LParen) {
2063                let with_options = self.parse_comma_separated(Parser::parse_avro_schema_option)?;
2064                self.expect_token(&Token::RParen)?;
2065                with_options
2066            } else {
2067                vec![]
2068            };
2069            AvroSchema::InlineSchema {
2070                schema,
2071                with_options,
2072            }
2073        } else {
2074            return self.expected(
2075                self.peek_pos(),
2076                "CONFLUENT SCHEMA REGISTRY or SCHEMA",
2077                self.peek_token(),
2078            );
2079        };
2080        Ok(avro_schema)
2081    }
2082
2083    fn parse_avro_schema_option(&mut self) -> Result<AvroSchemaOption<Raw>, ParserError> {
2084        self.expect_keywords(&[CONFLUENT, WIRE, FORMAT])?;
2085        Ok(AvroSchemaOption {
2086            name: AvroSchemaOptionName::ConfluentWireFormat,
2087            value: self.parse_optional_option_value()?,
2088        })
2089    }
2090
2091    fn parse_protobuf_schema(&mut self) -> Result<ProtobufSchema<Raw>, ParserError> {
2092        if self.parse_keywords(&[USING, CONFLUENT, SCHEMA, REGISTRY]) {
2093            let csr_connection = self.parse_csr_connection_proto()?;
2094            Ok(ProtobufSchema::Csr { csr_connection })
2095        } else if self.parse_keyword(MESSAGE) {
2096            let message_name = self.parse_literal_string()?;
2097            self.expect_keyword(USING)?;
2098            self.expect_keyword(SCHEMA)?;
2099            let schema = Schema {
2100                schema: self.parse_literal_string()?,
2101            };
2102            Ok(ProtobufSchema::InlineSchema {
2103                message_name,
2104                schema,
2105            })
2106        } else {
2107            self.expected(
2108                self.peek_pos(),
2109                "CONFLUENT SCHEMA REGISTRY or MESSAGE",
2110                self.peek_token(),
2111            )
2112        }
2113    }
2114
2115    fn parse_csr_connection_reference(&mut self) -> Result<CsrConnection<Raw>, ParserError> {
2116        self.expect_keyword(CONNECTION)?;
2117        let connection = self.parse_raw_name()?;
2118
2119        let options = if self.consume_token(&Token::LParen) {
2120            let options = self.parse_comma_separated(Parser::parse_csr_config_option)?;
2121            self.expect_token(&Token::RParen)?;
2122            options
2123        } else {
2124            vec![]
2125        };
2126
2127        Ok(CsrConnection {
2128            connection,
2129            options,
2130        })
2131    }
2132
2133    fn parse_csr_config_option(&mut self) -> Result<CsrConfigOption<Raw>, ParserError> {
2134        let name = match self.expect_one_of_keywords(&[AVRO, NULL, KEY, VALUE, DOC])? {
2135            AVRO => {
2136                let name = match self.expect_one_of_keywords(&[KEY, VALUE])? {
2137                    KEY => CsrConfigOptionName::AvroKeyFullname,
2138                    VALUE => CsrConfigOptionName::AvroValueFullname,
2139                    _ => unreachable!(),
2140                };
2141                self.expect_keyword(FULLNAME)?;
2142                name
2143            }
2144            NULL => {
2145                self.expect_keyword(DEFAULTS)?;
2146                CsrConfigOptionName::NullDefaults
2147            }
2148            KEY => match self.expect_one_of_keywords(&[DOC, COMPATIBILITY])? {
2149                DOC => {
2150                    self.expect_keyword(ON)?;
2151                    let doc_on_identifier = self.parse_avro_doc_on_option_name()?;
2152                    CsrConfigOptionName::AvroDocOn(AvroDocOn {
2153                        identifier: doc_on_identifier,
2154                        for_schema: DocOnSchema::KeyOnly,
2155                    })
2156                }
2157                COMPATIBILITY => {
2158                    self.expect_keyword(LEVEL)?;
2159                    CsrConfigOptionName::KeyCompatibilityLevel
2160                }
2161                _ => unreachable!(),
2162            },
2163            VALUE => match self.expect_one_of_keywords(&[DOC, COMPATIBILITY])? {
2164                DOC => {
2165                    self.expect_keyword(ON)?;
2166                    let doc_on_identifier = self.parse_avro_doc_on_option_name()?;
2167                    CsrConfigOptionName::AvroDocOn(AvroDocOn {
2168                        identifier: doc_on_identifier,
2169                        for_schema: DocOnSchema::ValueOnly,
2170                    })
2171                }
2172                COMPATIBILITY => {
2173                    self.expect_keyword(LEVEL)?;
2174                    CsrConfigOptionName::ValueCompatibilityLevel
2175                }
2176                _ => unreachable!(),
2177            },
2178            DOC => {
2179                self.expect_keyword(ON)?;
2180                let doc_on_identifier = self.parse_avro_doc_on_option_name()?;
2181                CsrConfigOptionName::AvroDocOn(AvroDocOn {
2182                    identifier: doc_on_identifier,
2183                    for_schema: DocOnSchema::All,
2184                })
2185            }
2186            _ => unreachable!(),
2187        };
2188        Ok(CsrConfigOption {
2189            name,
2190            value: self.parse_optional_option_value()?,
2191        })
2192    }
2193
2194    fn parse_avro_doc_on_option_name(&mut self) -> Result<DocOnIdentifier<Raw>, ParserError> {
2195        match self.expect_one_of_keywords(&[TYPE, COLUMN])? {
2196            TYPE => Ok(DocOnIdentifier::Type(self.parse_raw_name()?)),
2197            COLUMN => Ok(DocOnIdentifier::Column(self.parse_column_name()?)),
2198            _ => unreachable!(),
2199        }
2200    }
2201
2202    fn parse_csr_connection_avro(&mut self) -> Result<CsrConnectionAvro<Raw>, ParserError> {
2203        let connection = self.parse_csr_connection_reference()?;
2204        let seed = if self.parse_keyword(SEED) {
2205            let key_schema = if self.parse_keyword(KEY) {
2206                self.expect_keyword(SCHEMA)?;
2207                Some(self.parse_literal_string()?)
2208            } else {
2209                None
2210            };
2211            self.expect_keywords(&[VALUE, SCHEMA])?;
2212            let value_schema = self.parse_literal_string()?;
2213            Some(CsrSeedAvro {
2214                key_schema,
2215                value_schema,
2216            })
2217        } else {
2218            None
2219        };
2220
2221        let mut parse_schema_strategy =
2222            |kws| -> Result<Option<ReaderSchemaSelectionStrategy>, ParserError> {
2223                if self.parse_keywords(kws) {
2224                    Ok(Some(
2225                        match self.expect_one_of_keywords(&[ID, LATEST, INLINE])? {
2226                            ID => {
2227                                let pos = self.index;
2228                                ReaderSchemaSelectionStrategy::ById(
2229                                    self.parse_literal_int()?.try_into().map_err(|_| {
2230                                        ParserError::new(pos, "Expected a 32-bit integer")
2231                                    })?,
2232                                )
2233                            }
2234                            LATEST => ReaderSchemaSelectionStrategy::Latest,
2235                            INLINE => {
2236                                ReaderSchemaSelectionStrategy::Inline(self.parse_literal_string()?)
2237                            }
2238                            _ => unreachable!(),
2239                        },
2240                    ))
2241                } else {
2242                    Ok(None)
2243                }
2244            };
2245
2246        let key_strategy = parse_schema_strategy(&[KEY, STRATEGY])?;
2247        let value_strategy = parse_schema_strategy(&[VALUE, STRATEGY])?;
2248
2249        Ok(CsrConnectionAvro {
2250            connection,
2251            seed,
2252            key_strategy,
2253            value_strategy,
2254        })
2255    }
2256
2257    fn parse_csr_connection_proto(&mut self) -> Result<CsrConnectionProtobuf<Raw>, ParserError> {
2258        let connection = self.parse_csr_connection_reference()?;
2259
2260        let seed = if self.parse_keyword(SEED) {
2261            let key = if self.parse_keyword(KEY) {
2262                self.expect_keyword(SCHEMA)?;
2263                let schema = self.parse_literal_string()?;
2264                self.expect_keyword(MESSAGE)?;
2265                let message_name = self.parse_literal_string()?;
2266                Some(CsrSeedProtobufSchema {
2267                    schema,
2268                    message_name,
2269                })
2270            } else {
2271                None
2272            };
2273            self.expect_keywords(&[VALUE, SCHEMA])?;
2274            let value_schema = self.parse_literal_string()?;
2275            self.expect_keyword(MESSAGE)?;
2276            let value_message_name = self.parse_literal_string()?;
2277            Some(CsrSeedProtobuf {
2278                value: CsrSeedProtobufSchema {
2279                    schema: value_schema,
2280                    message_name: value_message_name,
2281                },
2282                key,
2283            })
2284        } else {
2285            None
2286        };
2287
2288        Ok(CsrConnectionProtobuf { connection, seed })
2289    }
2290
2291    fn parse_source_error_policy_option(&mut self) -> Result<SourceErrorPolicy, ParserError> {
2292        match self.expect_one_of_keywords(&[INLINE])? {
2293            INLINE => Ok(SourceErrorPolicy::Inline {
2294                alias: self.parse_alias()?,
2295            }),
2296            _ => unreachable!(),
2297        }
2298    }
2299
2300    fn parse_source_envelope(&mut self) -> Result<SourceEnvelope, ParserError> {
2301        let envelope = if self.parse_keyword(NONE) {
2302            SourceEnvelope::None
2303        } else if self.parse_keyword(DEBEZIUM) {
2304            SourceEnvelope::Debezium
2305        } else if self.parse_keyword(UPSERT) {
2306            let value_decode_err_policy = if self.consume_token(&Token::LParen) {
2307                // We only support the `VALUE DECODING ERRORS` option for now, but if we add another
2308                // we should extract this into a helper function.
2309                self.expect_keywords(&[VALUE, DECODING, ERRORS])?;
2310                let _ = self.consume_token(&Token::Eq);
2311                let open_inner = self.consume_token(&Token::LParen);
2312                let value_decode_err_policy =
2313                    self.parse_comma_separated(Parser::parse_source_error_policy_option)?;
2314                if open_inner {
2315                    self.expect_token(&Token::RParen)?;
2316                }
2317                self.expect_token(&Token::RParen)?;
2318                value_decode_err_policy
2319            } else {
2320                vec![]
2321            };
2322
2323            SourceEnvelope::Upsert {
2324                value_decode_err_policy,
2325            }
2326        } else if self.parse_keyword(MATERIALIZE) {
2327            SourceEnvelope::CdcV2
2328        } else {
2329            return self.expected(
2330                self.peek_pos(),
2331                "NONE, UPSERT, or MATERIALIZE",
2332                self.peek_token(),
2333            );
2334        };
2335        Ok(envelope)
2336    }
2337
2338    fn parse_sink_envelope(&mut self) -> Result<SinkEnvelope, ParserError> {
2339        if self.parse_keyword(UPSERT) {
2340            Ok(SinkEnvelope::Upsert)
2341        } else if self.parse_keyword(DEBEZIUM) {
2342            Ok(SinkEnvelope::Debezium)
2343        } else {
2344            self.expected(self.peek_pos(), "UPSERT, or DEBEZIUM", self.peek_token())
2345        }
2346    }
2347    /// Parse a `VALIDATE` statement
2348    fn parse_validate(&mut self) -> Result<Statement<Raw>, ParserError> {
2349        self.expect_keyword(CONNECTION)?;
2350        let name = self.parse_raw_name()?;
2351        Ok(Statement::ValidateConnection(ValidateConnectionStatement {
2352            name,
2353        }))
2354    }
2355
2356    fn parse_create_connection(&mut self) -> Result<Statement<Raw>, ParserError> {
2357        self.expect_keyword(CONNECTION)?;
2358        let if_not_exists = self.parse_if_not_exists()?;
2359        let name = self.parse_item_name()?;
2360        let expect_paren = match self.expect_one_of_keywords(&[FOR, TO])? {
2361            FOR => false,
2362            TO => true,
2363            _ => unreachable!(),
2364        };
2365        let connection_type = match self.expect_one_of_keywords(&[
2366            AWS, KAFKA, CONFLUENT, POSTGRES, SSH, SQL, MYSQL, YUGABYTE, ICEBERG,
2367        ])? {
2368            AWS => {
2369                if self.parse_keyword(PRIVATELINK) {
2370                    CreateConnectionType::AwsPrivatelink
2371                } else {
2372                    CreateConnectionType::Aws
2373                }
2374            }
2375            KAFKA => CreateConnectionType::Kafka,
2376            CONFLUENT => {
2377                self.expect_keywords(&[SCHEMA, REGISTRY])?;
2378                CreateConnectionType::Csr
2379            }
2380            POSTGRES => CreateConnectionType::Postgres,
2381            SSH => {
2382                self.expect_keyword(TUNNEL)?;
2383                CreateConnectionType::Ssh
2384            }
2385            SQL => {
2386                self.expect_keyword(SERVER)?;
2387                CreateConnectionType::SqlServer
2388            }
2389            MYSQL => CreateConnectionType::MySql,
2390            YUGABYTE => CreateConnectionType::Yugabyte,
2391            ICEBERG => {
2392                self.expect_keyword(CATALOG)?;
2393                CreateConnectionType::IcebergCatalog
2394            }
2395            _ => unreachable!(),
2396        };
2397        if expect_paren {
2398            self.expect_token(&Token::LParen)?;
2399        }
2400        let values = self.parse_comma_separated(Parser::parse_connection_option_unified)?;
2401        if expect_paren {
2402            self.expect_token(&Token::RParen)?;
2403        }
2404
2405        let with_options = if self.parse_keyword(WITH) {
2406            self.expect_token(&Token::LParen)?;
2407            let options = self.parse_comma_separated(Parser::parse_create_connection_option)?;
2408            self.expect_token(&Token::RParen)?;
2409            options
2410        } else {
2411            vec![]
2412        };
2413
2414        Ok(Statement::CreateConnection(CreateConnectionStatement {
2415            name,
2416            connection_type,
2417            values,
2418            if_not_exists,
2419            with_options,
2420        }))
2421    }
2422
2423    fn parse_create_connection_option_name(
2424        &mut self,
2425    ) -> Result<CreateConnectionOptionName, ParserError> {
2426        let name = match self.expect_one_of_keywords(&[VALIDATE])? {
2427            VALIDATE => CreateConnectionOptionName::Validate,
2428            _ => unreachable!(),
2429        };
2430        Ok(name)
2431    }
2432
2433    /// Parses a single valid option in the WITH block of a create source
2434    fn parse_create_connection_option(
2435        &mut self,
2436    ) -> Result<CreateConnectionOption<Raw>, ParserError> {
2437        let name = self.parse_create_connection_option_name()?;
2438        Ok(CreateConnectionOption {
2439            name,
2440            value: self.parse_optional_option_value()?,
2441        })
2442    }
2443
2444    fn parse_default_aws_privatelink(&mut self) -> Result<WithOptionValue<Raw>, ParserError> {
2445        let _ = self.consume_token(&Token::Eq);
2446        let connection = self.parse_raw_name()?;
2447        let port = if self.consume_token(&Token::LParen) {
2448            self.expect_keyword(PORT)?;
2449            let pos = self.peek_pos();
2450            let Ok(port) = u16::try_from(self.parse_literal_int()?) else {
2451                return parser_err!(self, pos, "Could not parse value into port");
2452            };
2453            self.expect_token(&Token::RParen)?;
2454            Some(port)
2455        } else {
2456            None
2457        };
2458        Ok(WithOptionValue::ConnectionAwsPrivatelink(
2459            ConnectionDefaultAwsPrivatelink { connection, port },
2460        ))
2461    }
2462
2463    fn parse_kafka_broker(&mut self) -> Result<WithOptionValue<Raw>, ParserError> {
2464        let _ = self.consume_token(&Token::Eq);
2465        let address = self.parse_literal_string()?;
2466        let tunnel = if self.parse_keyword(USING) {
2467            match self.expect_one_of_keywords(&[AWS, SSH])? {
2468                AWS => {
2469                    self.expect_keywords(&[PRIVATELINK])?;
2470                    let connection = self.parse_raw_name()?;
2471                    let options = if self.consume_token(&Token::LParen) {
2472                        let options = self.parse_comma_separated(
2473                            Parser::parse_kafka_broker_aws_privatelink_option,
2474                        )?;
2475                        self.expect_token(&Token::RParen)?;
2476                        options
2477                    } else {
2478                        vec![]
2479                    };
2480                    KafkaBrokerTunnel::AwsPrivatelink(KafkaBrokerAwsPrivatelink {
2481                        connection,
2482                        options,
2483                    })
2484                }
2485                SSH => {
2486                    self.expect_keywords(&[TUNNEL])?;
2487                    KafkaBrokerTunnel::SshTunnel(self.parse_raw_name()?)
2488                }
2489                _ => unreachable!(),
2490            }
2491        } else {
2492            KafkaBrokerTunnel::Direct
2493        };
2494
2495        Ok(WithOptionValue::ConnectionKafkaBroker(KafkaBroker {
2496            address,
2497            tunnel,
2498        }))
2499    }
2500
2501    fn parse_kafka_broker_aws_privatelink_option(
2502        &mut self,
2503    ) -> Result<KafkaBrokerAwsPrivatelinkOption<Raw>, ParserError> {
2504        let name = match self.expect_one_of_keywords(&[AVAILABILITY, PORT])? {
2505            AVAILABILITY => {
2506                self.expect_keywords(&[ZONE])?;
2507                KafkaBrokerAwsPrivatelinkOptionName::AvailabilityZone
2508            }
2509            PORT => KafkaBrokerAwsPrivatelinkOptionName::Port,
2510            _ => unreachable!(),
2511        };
2512        let value = self.parse_optional_option_value()?;
2513        Ok(KafkaBrokerAwsPrivatelinkOption { name, value })
2514    }
2515
2516    fn parse_kafka_source_config_option(
2517        &mut self,
2518    ) -> Result<KafkaSourceConfigOption<Raw>, ParserError> {
2519        let name = match self.expect_one_of_keywords(&[GROUP, START, TOPIC])? {
2520            GROUP => {
2521                self.expect_keywords(&[ID, PREFIX])?;
2522                KafkaSourceConfigOptionName::GroupIdPrefix
2523            }
2524            START => match self.expect_one_of_keywords(&[OFFSET, TIMESTAMP])? {
2525                OFFSET => KafkaSourceConfigOptionName::StartOffset,
2526                TIMESTAMP => KafkaSourceConfigOptionName::StartTimestamp,
2527                _ => unreachable!(),
2528            },
2529            TOPIC => {
2530                if self.parse_keyword(METADATA) {
2531                    self.expect_keywords(&[REFRESH, INTERVAL])?;
2532                    KafkaSourceConfigOptionName::TopicMetadataRefreshInterval
2533                } else {
2534                    KafkaSourceConfigOptionName::Topic
2535                }
2536            }
2537            _ => unreachable!(),
2538        };
2539        Ok(KafkaSourceConfigOption {
2540            name,
2541            value: self.parse_optional_option_value()?,
2542        })
2543    }
2544
2545    fn parse_kafka_sink_config_option(
2546        &mut self,
2547    ) -> Result<KafkaSinkConfigOption<Raw>, ParserError> {
2548        let name = match self.expect_one_of_keywords(&[
2549            COMPRESSION,
2550            PARTITION,
2551            PROGRESS,
2552            TOPIC,
2553            LEGACY,
2554            TRANSACTIONAL,
2555        ])? {
2556            COMPRESSION => {
2557                self.expect_keyword(TYPE)?;
2558                KafkaSinkConfigOptionName::CompressionType
2559            }
2560            PARTITION => {
2561                self.expect_keyword(BY)?;
2562                let _ = self.consume_token(&Token::Eq);
2563                return Ok(KafkaSinkConfigOption {
2564                    name: KafkaSinkConfigOptionName::PartitionBy,
2565                    value: Some(WithOptionValue::Expr(self.parse_expr()?)),
2566                });
2567            }
2568            PROGRESS => {
2569                self.expect_keywords(&[GROUP, ID, PREFIX])?;
2570                KafkaSinkConfigOptionName::ProgressGroupIdPrefix
2571            }
2572            TOPIC => {
2573                match self.parse_one_of_keywords(&[METADATA, PARTITION, REPLICATION, CONFIG]) {
2574                    None => KafkaSinkConfigOptionName::Topic,
2575                    Some(METADATA) => {
2576                        self.expect_keywords(&[REFRESH, INTERVAL])?;
2577                        KafkaSinkConfigOptionName::TopicMetadataRefreshInterval
2578                    }
2579                    Some(PARTITION) => {
2580                        self.expect_keyword(COUNT)?;
2581                        KafkaSinkConfigOptionName::TopicPartitionCount
2582                    }
2583                    Some(REPLICATION) => {
2584                        self.expect_keyword(FACTOR)?;
2585                        KafkaSinkConfigOptionName::TopicReplicationFactor
2586                    }
2587                    Some(CONFIG) => KafkaSinkConfigOptionName::TopicConfig,
2588                    Some(other) => {
2589                        return parser_err!(
2590                            self,
2591                            self.peek_prev_pos(),
2592                            "unexpected keyword {}",
2593                            other
2594                        );
2595                    }
2596                }
2597            }
2598            TRANSACTIONAL => {
2599                self.expect_keywords(&[ID, PREFIX])?;
2600                KafkaSinkConfigOptionName::TransactionalIdPrefix
2601            }
2602            LEGACY => {
2603                self.expect_keywords(&[IDS])?;
2604                KafkaSinkConfigOptionName::LegacyIds
2605            }
2606            _ => unreachable!(),
2607        };
2608        Ok(KafkaSinkConfigOption {
2609            name,
2610            value: self.parse_optional_option_value()?,
2611        })
2612    }
2613
2614    fn parse_connection_option_name(&mut self) -> Result<ConnectionOptionName, ParserError> {
2615        Ok(
2616            match self.expect_one_of_keywords(&[
2617                ACCESS,
2618                ASSUME,
2619                AVAILABILITY,
2620                AWS,
2621                BROKER,
2622                BROKERS,
2623                CATALOG,
2624                CREDENTIAL,
2625                DATABASE,
2626                ENDPOINT,
2627                HOST,
2628                PASSWORD,
2629                PORT,
2630                PUBLIC,
2631                PROGRESS,
2632                REGION,
2633                ROLE,
2634                SASL,
2635                SCOPE,
2636                SECRET,
2637                SECURITY,
2638                SERVICE,
2639                SESSION,
2640                SSH,
2641                SSL,
2642                URL,
2643                USER,
2644                USERNAME,
2645                WAREHOUSE,
2646            ])? {
2647                ACCESS => {
2648                    self.expect_keywords(&[KEY, ID])?;
2649                    ConnectionOptionName::AccessKeyId
2650                }
2651                ASSUME => {
2652                    self.expect_keyword(ROLE)?;
2653                    match self.expect_one_of_keywords(&[ARN, SESSION])? {
2654                        ARN => ConnectionOptionName::AssumeRoleArn,
2655                        SESSION => {
2656                            self.expect_keyword(NAME)?;
2657                            ConnectionOptionName::AssumeRoleSessionName
2658                        }
2659                        _ => unreachable!(),
2660                    }
2661                }
2662                AVAILABILITY => {
2663                    self.expect_keyword(ZONES)?;
2664                    ConnectionOptionName::AvailabilityZones
2665                }
2666                AWS => match self.expect_one_of_keywords(&[CONNECTION, PRIVATELINK])? {
2667                    CONNECTION => ConnectionOptionName::AwsConnection,
2668                    PRIVATELINK => ConnectionOptionName::AwsPrivatelink,
2669                    _ => unreachable!(),
2670                },
2671                BROKER => ConnectionOptionName::Broker,
2672                BROKERS => ConnectionOptionName::Brokers,
2673                CATALOG => {
2674                    self.expect_keyword(TYPE)?;
2675                    ConnectionOptionName::CatalogType
2676                }
2677                CREDENTIAL => ConnectionOptionName::Credential,
2678                DATABASE => ConnectionOptionName::Database,
2679                ENDPOINT => ConnectionOptionName::Endpoint,
2680                HOST => ConnectionOptionName::Host,
2681                PASSWORD => ConnectionOptionName::Password,
2682                PORT => ConnectionOptionName::Port,
2683                PUBLIC => {
2684                    self.expect_keyword(KEY)?;
2685                    match self.next_token() {
2686                        Some(Token::Number(n)) if n == "1" => ConnectionOptionName::PublicKey1,
2687                        Some(Token::Number(n)) if n == "2" => ConnectionOptionName::PublicKey2,
2688                        t => self.expected(self.peek_prev_pos(), "1 or 2 after PUBLIC KEY", t)?,
2689                    }
2690                }
2691                PROGRESS => {
2692                    self.expect_keyword(TOPIC)?;
2693                    match self.parse_keywords(&[REPLICATION, FACTOR]) {
2694                        true => ConnectionOptionName::ProgressTopicReplicationFactor,
2695                        false => ConnectionOptionName::ProgressTopic,
2696                    }
2697                }
2698                SECURITY => {
2699                    self.expect_keyword(PROTOCOL)?;
2700                    ConnectionOptionName::SecurityProtocol
2701                }
2702                REGION => ConnectionOptionName::Region,
2703                SASL => match self.expect_one_of_keywords(&[MECHANISMS, PASSWORD, USERNAME])? {
2704                    MECHANISMS => ConnectionOptionName::SaslMechanisms,
2705                    PASSWORD => ConnectionOptionName::SaslPassword,
2706                    USERNAME => ConnectionOptionName::SaslUsername,
2707                    _ => unreachable!(),
2708                },
2709                SCOPE => ConnectionOptionName::Scope,
2710                SECRET => {
2711                    self.expect_keywords(&[ACCESS, KEY])?;
2712                    ConnectionOptionName::SecretAccessKey
2713                }
2714                SERVICE => {
2715                    self.expect_keyword(NAME)?;
2716                    ConnectionOptionName::ServiceName
2717                }
2718                SESSION => {
2719                    self.expect_keyword(TOKEN)?;
2720                    ConnectionOptionName::SessionToken
2721                }
2722                SSH => {
2723                    self.expect_keyword(TUNNEL)?;
2724                    ConnectionOptionName::SshTunnel
2725                }
2726                SSL => match self.expect_one_of_keywords(&[CERTIFICATE, MODE, KEY])? {
2727                    CERTIFICATE => {
2728                        if self.parse_keyword(AUTHORITY) {
2729                            ConnectionOptionName::SslCertificateAuthority
2730                        } else {
2731                            ConnectionOptionName::SslCertificate
2732                        }
2733                    }
2734                    KEY => ConnectionOptionName::SslKey,
2735                    MODE => ConnectionOptionName::SslMode,
2736                    _ => unreachable!(),
2737                },
2738                URL => ConnectionOptionName::Url,
2739                // TYPE => ConnectionOptionName::CatalogType,
2740                WAREHOUSE => ConnectionOptionName::Warehouse,
2741                USER | USERNAME => ConnectionOptionName::User,
2742                _ => unreachable!(),
2743            },
2744        )
2745    }
2746
2747    fn parse_connection_option_unified(&mut self) -> Result<ConnectionOption<Raw>, ParserError> {
2748        let name = match self.parse_connection_option_name()? {
2749            ConnectionOptionName::AwsConnection => {
2750                return Ok(ConnectionOption {
2751                    name: ConnectionOptionName::AwsConnection,
2752                    value: Some(self.parse_object_option_value()?),
2753                });
2754            }
2755            ConnectionOptionName::AwsPrivatelink => {
2756                return Ok(ConnectionOption {
2757                    name: ConnectionOptionName::AwsPrivatelink,
2758                    value: Some(self.parse_default_aws_privatelink()?),
2759                });
2760            }
2761            ConnectionOptionName::Broker => {
2762                return Ok(ConnectionOption {
2763                    name: ConnectionOptionName::Broker,
2764                    value: Some(self.parse_kafka_broker()?),
2765                });
2766            }
2767            ConnectionOptionName::Brokers => {
2768                let _ = self.consume_token(&Token::Eq);
2769                let delimiter = self.expect_one_of_tokens(&[Token::LParen, Token::LBracket])?;
2770                let brokers = self.parse_comma_separated(Parser::parse_kafka_broker)?;
2771                self.expect_token(&match delimiter {
2772                    Token::LParen => Token::RParen,
2773                    Token::LBracket => Token::RBracket,
2774                    _ => unreachable!(),
2775                })?;
2776                return Ok(ConnectionOption {
2777                    name: ConnectionOptionName::Brokers,
2778                    value: Some(WithOptionValue::Sequence(brokers)),
2779                });
2780            }
2781            ConnectionOptionName::SshTunnel => {
2782                return Ok(ConnectionOption {
2783                    name: ConnectionOptionName::SshTunnel,
2784                    value: Some(self.parse_object_option_value()?),
2785                });
2786            }
2787            name => name,
2788        };
2789        Ok(ConnectionOption {
2790            name,
2791            value: self.parse_optional_option_value()?,
2792        })
2793    }
2794
2795    fn parse_create_subsource(&mut self) -> Result<Statement<Raw>, ParserError> {
2796        self.expect_keyword(SUBSOURCE)?;
2797        let if_not_exists = self.parse_if_not_exists()?;
2798        let name = self.parse_item_name()?;
2799
2800        let (columns, constraints) = self.parse_columns(Mandatory)?;
2801
2802        let of_source = if self.parse_keyword(OF) {
2803            self.expect_keyword(SOURCE)?;
2804            Some(self.parse_raw_name()?)
2805        } else {
2806            None
2807        };
2808
2809        let with_options = if self.parse_keyword(WITH) {
2810            self.expect_token(&Token::LParen)?;
2811            let options = self.parse_comma_separated(Parser::parse_create_subsource_option)?;
2812            self.expect_token(&Token::RParen)?;
2813            options
2814        } else {
2815            vec![]
2816        };
2817
2818        Ok(Statement::CreateSubsource(CreateSubsourceStatement {
2819            name,
2820            if_not_exists,
2821            columns,
2822            of_source,
2823            constraints,
2824            with_options,
2825        }))
2826    }
2827
2828    fn parse_create_subsource_option(&mut self) -> Result<CreateSubsourceOption<Raw>, ParserError> {
2829        let option = match self
2830            .expect_one_of_keywords(&[EXTERNAL, PROGRESS, TEXT, EXCLUDE, IGNORE, DETAILS, RETAIN])?
2831        {
2832            EXTERNAL => {
2833                self.expect_keyword(REFERENCE)?;
2834                CreateSubsourceOption {
2835                    name: CreateSubsourceOptionName::ExternalReference,
2836                    value: self.parse_optional_option_value()?,
2837                }
2838            }
2839            PROGRESS => CreateSubsourceOption {
2840                name: CreateSubsourceOptionName::Progress,
2841                value: self.parse_optional_option_value()?,
2842            },
2843            ref keyword @ (TEXT | EXCLUDE | IGNORE) => {
2844                self.expect_keyword(COLUMNS)?;
2845
2846                let _ = self.consume_token(&Token::Eq);
2847
2848                let value = self
2849                    .parse_option_sequence(Parser::parse_identifier)?
2850                    .map(|inner| {
2851                        WithOptionValue::Sequence(
2852                            inner.into_iter().map(WithOptionValue::Ident).collect_vec(),
2853                        )
2854                    });
2855
2856                CreateSubsourceOption {
2857                    name: match *keyword {
2858                        TEXT => CreateSubsourceOptionName::TextColumns,
2859                        // IGNORE is historical syntax for this option.
2860                        EXCLUDE | IGNORE => CreateSubsourceOptionName::ExcludeColumns,
2861                        _ => unreachable!(),
2862                    },
2863                    value,
2864                }
2865            }
2866            DETAILS => CreateSubsourceOption {
2867                name: CreateSubsourceOptionName::Details,
2868                value: self.parse_optional_option_value()?,
2869            },
2870            RETAIN => {
2871                self.expect_keyword(HISTORY)?;
2872                CreateSubsourceOption {
2873                    name: CreateSubsourceOptionName::RetainHistory,
2874                    value: self.parse_option_retain_history()?,
2875                }
2876            }
2877            _ => unreachable!(),
2878        };
2879        Ok(option)
2880    }
2881
2882    fn parse_create_source(&mut self) -> Result<Statement<Raw>, ParserError> {
2883        self.expect_keyword(SOURCE)?;
2884        let if_not_exists = self.parse_if_not_exists()?;
2885        let name = self.parse_item_name()?;
2886
2887        let (col_names, key_constraint) = self.parse_source_columns()?;
2888
2889        let in_cluster = self.parse_optional_in_cluster()?;
2890        self.expect_keyword(FROM)?;
2891
2892        // Webhook Source, which works differently than all other sources.
2893        if self.parse_keyword(WEBHOOK) {
2894            return self.parse_create_webhook_source(name, if_not_exists, in_cluster, false);
2895        }
2896
2897        let connection = self.parse_create_source_connection()?;
2898        let format = match self.parse_one_of_keywords(&[KEY, FORMAT]) {
2899            Some(KEY) => {
2900                self.expect_keyword(FORMAT)?;
2901                let key = self.parse_format()?;
2902                self.expect_keywords(&[VALUE, FORMAT])?;
2903                let value = self.parse_format()?;
2904                Some(FormatSpecifier::KeyValue { key, value })
2905            }
2906            Some(FORMAT) => Some(FormatSpecifier::Bare(self.parse_format()?)),
2907            Some(_) => unreachable!("parse_one_of_keywords returns None for this"),
2908            None => None,
2909        };
2910        let include_metadata = self.parse_source_include_metadata()?;
2911
2912        let envelope = if self.parse_keyword(ENVELOPE) {
2913            Some(self.parse_source_envelope()?)
2914        } else {
2915            None
2916        };
2917
2918        let referenced_subsources = if self.parse_keywords(&[FOR, TABLES]) {
2919            self.expect_token(&Token::LParen)?;
2920            let subsources = self.parse_comma_separated(Parser::parse_subsource_references)?;
2921            self.expect_token(&Token::RParen)?;
2922            Some(ExternalReferences::SubsetTables(subsources))
2923        } else if self.parse_keywords(&[FOR, SCHEMAS]) {
2924            self.expect_token(&Token::LParen)?;
2925            let schemas = self.parse_comma_separated(Parser::parse_identifier)?;
2926            self.expect_token(&Token::RParen)?;
2927            Some(ExternalReferences::SubsetSchemas(schemas))
2928        } else if self.parse_keywords(&[FOR, ALL, TABLES]) {
2929            Some(ExternalReferences::All)
2930        } else {
2931            None
2932        };
2933
2934        let progress_subsource = if self.parse_keywords(&[EXPOSE, PROGRESS, AS]) {
2935            Some(self.parse_deferred_item_name()?)
2936        } else {
2937            None
2938        };
2939
2940        // New WITH block
2941        let with_options = if self.parse_keyword(WITH) {
2942            self.expect_token(&Token::LParen)?;
2943            let options = self.parse_comma_separated(Parser::parse_source_option)?;
2944            self.expect_token(&Token::RParen)?;
2945            options
2946        } else {
2947            vec![]
2948        };
2949
2950        Ok(Statement::CreateSource(CreateSourceStatement {
2951            name,
2952            in_cluster,
2953            col_names,
2954            connection,
2955            format,
2956            include_metadata,
2957            envelope,
2958            if_not_exists,
2959            key_constraint,
2960            external_references: referenced_subsources,
2961            progress_subsource,
2962            with_options,
2963        }))
2964    }
2965
2966    fn parse_subsource_references(&mut self) -> Result<ExternalReferenceExport, ParserError> {
2967        let reference = self.parse_item_name()?;
2968        let subsource = if self.parse_one_of_keywords(&[AS, INTO]).is_some() {
2969            Some(self.parse_item_name()?)
2970        } else {
2971            None
2972        };
2973
2974        Ok(ExternalReferenceExport {
2975            reference,
2976            alias: subsource,
2977        })
2978    }
2979
2980    /// Parses the column section of a CREATE SOURCE statement which can be
2981    /// empty or a comma-separated list of column identifiers and a single key
2982    /// constraint, e.g.
2983    ///
2984    /// (col_0, col_i, ..., col_n, key_constraint)
2985    fn parse_source_columns(&mut self) -> Result<(Vec<Ident>, Option<KeyConstraint>), ParserError> {
2986        if self.consume_token(&Token::LParen) {
2987            let mut columns = vec![];
2988            let mut key_constraints = vec![];
2989            loop {
2990                let pos = self.peek_pos();
2991                if let Some(key_constraint) = self.parse_key_constraint()? {
2992                    if !key_constraints.is_empty() {
2993                        return parser_err!(self, pos, "Multiple key constraints not allowed");
2994                    }
2995                    key_constraints.push(key_constraint);
2996                } else {
2997                    columns.push(self.parse_identifier()?);
2998                }
2999                if !self.consume_token(&Token::Comma) {
3000                    break;
3001                }
3002            }
3003            self.expect_token(&Token::RParen)?;
3004            Ok((columns, key_constraints.into_iter().next()))
3005        } else {
3006            Ok((vec![], None))
3007        }
3008    }
3009
3010    /// Parses a key constraint.
3011    fn parse_key_constraint(&mut self) -> Result<Option<KeyConstraint>, ParserError> {
3012        // PRIMARY KEY (col_1, ..., col_n) NOT ENFORCED
3013        if self.parse_keywords(&[PRIMARY, KEY]) {
3014            let columns = self.parse_parenthesized_column_list(Mandatory)?;
3015            self.expect_keywords(&[NOT, ENFORCED])?;
3016            Ok(Some(KeyConstraint::PrimaryKeyNotEnforced { columns }))
3017        } else {
3018            Ok(None)
3019        }
3020    }
3021
3022    fn parse_source_option_name(&mut self) -> Result<CreateSourceOptionName, ParserError> {
3023        let name = match self.expect_one_of_keywords(&[TIMESTAMP, RETAIN])? {
3024            TIMESTAMP => {
3025                self.expect_keyword(INTERVAL)?;
3026                CreateSourceOptionName::TimestampInterval
3027            }
3028            RETAIN => {
3029                self.expect_keyword(HISTORY)?;
3030                CreateSourceOptionName::RetainHistory
3031            }
3032            _ => unreachable!(),
3033        };
3034        Ok(name)
3035    }
3036
3037    /// Parses a single valid option in the WITH block of a create source
3038    fn parse_source_option(&mut self) -> Result<CreateSourceOption<Raw>, ParserError> {
3039        let name = self.parse_source_option_name()?;
3040        if name == CreateSourceOptionName::RetainHistory {
3041            let _ = self.consume_token(&Token::Eq);
3042            return Ok(CreateSourceOption {
3043                name,
3044                value: self.parse_option_retain_history()?,
3045            });
3046        }
3047        Ok(CreateSourceOption {
3048            name,
3049            value: self.parse_optional_option_value()?,
3050        })
3051    }
3052
3053    fn parse_create_webhook_source(
3054        &mut self,
3055        name: UnresolvedItemName,
3056        if_not_exists: bool,
3057        in_cluster: Option<RawClusterName>,
3058        is_table: bool,
3059    ) -> Result<Statement<Raw>, ParserError> {
3060        self.expect_keywords(&[BODY, FORMAT])?;
3061
3062        // Note: we don't use `parse_format()` here because we support fewer formats than other
3063        // sources, and the user gets better errors if we reject the formats here.
3064        let body_format = match self.expect_one_of_keywords(&[JSON, TEXT, BYTES])? {
3065            JSON => {
3066                let array = self.parse_keyword(ARRAY);
3067                Format::Json { array }
3068            }
3069            TEXT => Format::Text,
3070            BYTES => Format::Bytes,
3071            _ => unreachable!(),
3072        };
3073
3074        let mut include_headers = CreateWebhookSourceIncludeHeaders::default();
3075        while self.parse_keyword(INCLUDE) {
3076            match self.expect_one_of_keywords(&[HEADER, HEADERS])? {
3077                HEADER => {
3078                    let header_name = self.parse_literal_string()?;
3079                    self.expect_keyword(AS)?;
3080                    let column_name = self.parse_identifier()?;
3081                    let use_bytes = self.parse_keyword(BYTES);
3082
3083                    include_headers.mappings.push(CreateWebhookSourceMapHeader {
3084                        header_name,
3085                        column_name,
3086                        use_bytes,
3087                    });
3088                }
3089                HEADERS => {
3090                    let header_filters = include_headers.column.get_or_insert_with(Vec::default);
3091                    if self.consume_token(&Token::LParen) {
3092                        let filters = self.parse_comma_separated(|f| {
3093                            let block = f.parse_keyword(NOT);
3094                            let header_name = f.parse_literal_string()?;
3095                            Ok(CreateWebhookSourceFilterHeader { block, header_name })
3096                        })?;
3097                        header_filters.extend(filters);
3098
3099                        self.expect_token(&Token::RParen)?;
3100                    }
3101                }
3102                k => unreachable!("programming error, didn't expect {k}"),
3103            }
3104        }
3105
3106        let validate_using = if self.parse_keyword(CHECK) {
3107            self.expect_token(&Token::LParen)?;
3108
3109            let options = if self.parse_keyword(WITH) {
3110                self.expect_token(&Token::LParen)?;
3111                let options = self.parse_create_webhook_check_options()?;
3112                self.expect_token(&Token::RParen)?;
3113
3114                Some(options)
3115            } else {
3116                None
3117            };
3118
3119            let using = self.parse_expr()?;
3120            self.expect_token(&Token::RParen)?;
3121
3122            Some(CreateWebhookSourceCheck { options, using })
3123        } else {
3124            None
3125        };
3126
3127        Ok(Statement::CreateWebhookSource(
3128            CreateWebhookSourceStatement {
3129                name,
3130                is_table,
3131                if_not_exists,
3132                body_format,
3133                include_headers,
3134                validate_using,
3135                in_cluster,
3136            },
3137        ))
3138    }
3139
3140    fn parse_create_webhook_check_options(
3141        &mut self,
3142    ) -> Result<CreateWebhookSourceCheckOptions<Raw>, ParserError> {
3143        let mut secrets = vec![];
3144        let mut headers = vec![];
3145        let mut bodies = vec![];
3146
3147        fn parse_alias(parser: &mut Parser<'_>) -> Result<Option<Ident>, ParserError> {
3148            parser
3149                .parse_keyword(AS)
3150                .then(|| parser.parse_identifier())
3151                .transpose()
3152        }
3153
3154        self.parse_comma_separated(|f| {
3155            match f.expect_one_of_keywords(&[SECRET, HEADERS, BODY])? {
3156                SECRET => {
3157                    let secret = f.parse_raw_name()?;
3158                    let alias = parse_alias(f)?;
3159                    let use_bytes = f.parse_keyword(Keyword::Bytes);
3160
3161                    secrets.push(CreateWebhookSourceSecret {
3162                        secret,
3163                        alias,
3164                        use_bytes,
3165                    });
3166
3167                    Ok(())
3168                }
3169                HEADERS => {
3170                    // TODO(parkmycar): Support filtering down to specific headers.
3171                    let alias = parse_alias(f)?;
3172                    let use_bytes = f.parse_keyword(Keyword::Bytes);
3173                    headers.push(CreateWebhookSourceHeader { alias, use_bytes });
3174
3175                    Ok(())
3176                }
3177                BODY => {
3178                    let alias = parse_alias(f)?;
3179                    let use_bytes = f.parse_keyword(Keyword::Bytes);
3180                    bodies.push(CreateWebhookSourceBody { alias, use_bytes });
3181
3182                    Ok(())
3183                }
3184                k => unreachable!("Unexpected keyword! {k}"),
3185            }
3186        })?;
3187
3188        Ok(CreateWebhookSourceCheckOptions {
3189            secrets,
3190            headers,
3191            bodies,
3192        })
3193    }
3194
3195    fn parse_create_kafka_sink(
3196        &mut self,
3197        name: Option<UnresolvedItemName>,
3198        in_cluster: Option<RawClusterName>,
3199        from: RawItemName,
3200        if_not_exists: bool,
3201        connection: CreateSinkConnection<Raw>,
3202    ) -> Result<CreateSinkStatement<Raw>, ParserError> {
3203        let format = match &self.parse_one_of_keywords(&[KEY, FORMAT]) {
3204            Some(KEY) => {
3205                self.expect_keyword(FORMAT)?;
3206                let key = self.parse_format()?;
3207                self.expect_keywords(&[VALUE, FORMAT])?;
3208                let value = self.parse_format()?;
3209                Some(FormatSpecifier::KeyValue { key, value })
3210            }
3211            Some(FORMAT) => Some(FormatSpecifier::Bare(self.parse_format()?)),
3212            Some(_) => unreachable!("parse_one_of_keywords returns None for this"),
3213            None => None,
3214        };
3215        let envelope = if self.parse_keyword(ENVELOPE) {
3216            Some(self.parse_sink_envelope()?)
3217        } else {
3218            None
3219        };
3220
3221        let with_options = if self.parse_keyword(WITH) {
3222            self.expect_token(&Token::LParen)?;
3223            let options = self.parse_comma_separated(Parser::parse_create_sink_option)?;
3224            self.expect_token(&Token::RParen)?;
3225            options
3226        } else {
3227            vec![]
3228        };
3229
3230        Ok(CreateSinkStatement {
3231            name,
3232            in_cluster,
3233            from,
3234            connection,
3235            format,
3236            envelope,
3237            if_not_exists,
3238            with_options,
3239        })
3240    }
3241
3242    fn parse_create_sink(&mut self) -> Result<Statement<Raw>, ParserError> {
3243        self.expect_keyword(SINK)?;
3244        let if_not_exists = self.parse_if_not_exists()?;
3245
3246        let mut name = Some(self.parse_item_name()?);
3247
3248        // Sniff out `CREATE SINK IN CLUSTER <c> ...` and `CREATE SINK FROM
3249        // <view>...`  and ensure they are parsed as nameless `CREATE SINK`
3250        // commands.
3251        //
3252        // This is a bit gross, but we didn't have the foresight to make
3253        // `IN` and `FROM` reserved keywords for sink names.
3254        if (name == Some(UnresolvedItemName::unqualified(ident!("in")))
3255            && self.peek_keyword(CLUSTER))
3256            || (name == Some(UnresolvedItemName::unqualified(ident!("from")))
3257                && !self.peek_keyword(FROM))
3258        {
3259            name = None;
3260            self.prev_token();
3261        }
3262
3263        let in_cluster = self.parse_optional_in_cluster()?;
3264        self.expect_keyword(FROM)?;
3265        let from = self.parse_raw_name()?;
3266        self.expect_keyword(INTO)?;
3267        let connection = self.parse_create_sink_connection()?;
3268
3269        let statement = match connection {
3270            conn @ CreateSinkConnection::Kafka { .. } => {
3271                self.parse_create_kafka_sink(name, in_cluster, from, if_not_exists, conn)
3272            }
3273        }?;
3274
3275        Ok(Statement::CreateSink(statement))
3276    }
3277
3278    /// Parse the name of a CREATE SINK optional parameter
3279    fn parse_create_sink_option_name(&mut self) -> Result<CreateSinkOptionName, ParserError> {
3280        let name = match self.expect_one_of_keywords(&[PARTITION, SNAPSHOT, VERSION])? {
3281            SNAPSHOT => CreateSinkOptionName::Snapshot,
3282            VERSION => CreateSinkOptionName::Version,
3283            PARTITION => {
3284                self.expect_keyword(STRATEGY)?;
3285                CreateSinkOptionName::PartitionStrategy
3286            }
3287            _ => unreachable!(),
3288        };
3289        Ok(name)
3290    }
3291
3292    /// Parse a NAME = VALUE parameter for CREATE SINK
3293    fn parse_create_sink_option(&mut self) -> Result<CreateSinkOption<Raw>, ParserError> {
3294        Ok(CreateSinkOption {
3295            name: self.parse_create_sink_option_name()?,
3296            value: self.parse_optional_option_value()?,
3297        })
3298    }
3299
3300    fn parse_create_source_connection(
3301        &mut self,
3302    ) -> Result<CreateSourceConnection<Raw>, ParserError> {
3303        match self.expect_one_of_keywords(&[KAFKA, POSTGRES, SQL, MYSQL, LOAD, YUGABYTE])? {
3304            POSTGRES => {
3305                self.expect_keyword(CONNECTION)?;
3306                let connection = self.parse_raw_name()?;
3307
3308                let options = if self.consume_token(&Token::LParen) {
3309                    let options = self.parse_comma_separated(Parser::parse_pg_connection_option)?;
3310                    self.expect_token(&Token::RParen)?;
3311                    options
3312                } else {
3313                    vec![]
3314                };
3315
3316                Ok(CreateSourceConnection::Postgres {
3317                    connection,
3318                    options,
3319                })
3320            }
3321            YUGABYTE => {
3322                self.expect_keyword(CONNECTION)?;
3323                let connection = self.parse_raw_name()?;
3324
3325                let options = if self.consume_token(&Token::LParen) {
3326                    let options = self.parse_comma_separated(Parser::parse_pg_connection_option)?;
3327                    self.expect_token(&Token::RParen)?;
3328                    options
3329                } else {
3330                    vec![]
3331                };
3332
3333                Ok(CreateSourceConnection::Yugabyte {
3334                    connection,
3335                    options,
3336                })
3337            }
3338            SQL => {
3339                self.expect_keywords(&[SERVER, CONNECTION])?;
3340                let connection = self.parse_raw_name()?;
3341
3342                let options = if self.consume_token(&Token::LParen) {
3343                    let options =
3344                        self.parse_comma_separated(Parser::parse_sql_server_connection_option)?;
3345                    self.expect_token(&Token::RParen)?;
3346                    options
3347                } else {
3348                    vec![]
3349                };
3350
3351                Ok(CreateSourceConnection::SqlServer {
3352                    connection,
3353                    options,
3354                })
3355            }
3356            MYSQL => {
3357                self.expect_keyword(CONNECTION)?;
3358                let connection = self.parse_raw_name()?;
3359
3360                let options = if self.consume_token(&Token::LParen) {
3361                    let options =
3362                        self.parse_comma_separated(Parser::parse_mysql_connection_option)?;
3363                    self.expect_token(&Token::RParen)?;
3364                    options
3365                } else {
3366                    vec![]
3367                };
3368
3369                Ok(CreateSourceConnection::MySql {
3370                    connection,
3371                    options,
3372                })
3373            }
3374            KAFKA => {
3375                self.expect_keyword(CONNECTION)?;
3376                let connection = self.parse_raw_name()?;
3377
3378                let options = if self.consume_token(&Token::LParen) {
3379                    let options =
3380                        self.parse_comma_separated(Parser::parse_kafka_source_config_option)?;
3381                    self.expect_token(&Token::RParen)?;
3382                    options
3383                } else {
3384                    vec![]
3385                };
3386
3387                Ok(CreateSourceConnection::Kafka {
3388                    connection,
3389                    options,
3390                })
3391            }
3392            LOAD => {
3393                self.expect_keyword(GENERATOR)?;
3394                let generator = match self.expect_one_of_keywords(&[
3395                    CLOCK, COUNTER, MARKETING, AUCTION, TPCH, DATUMS, KEY,
3396                ])? {
3397                    CLOCK => LoadGenerator::Clock,
3398                    COUNTER => LoadGenerator::Counter,
3399                    AUCTION => LoadGenerator::Auction,
3400                    TPCH => LoadGenerator::Tpch,
3401                    DATUMS => LoadGenerator::Datums,
3402                    MARKETING => LoadGenerator::Marketing,
3403                    KEY => {
3404                        self.expect_keyword(VALUE)?;
3405                        LoadGenerator::KeyValue
3406                    }
3407                    _ => unreachable!(),
3408                };
3409                let options = if self.consume_token(&Token::LParen) {
3410                    let options =
3411                        self.parse_comma_separated(Parser::parse_load_generator_option)?;
3412                    self.expect_token(&Token::RParen)?;
3413                    options
3414                } else {
3415                    vec![]
3416                };
3417                Ok(CreateSourceConnection::LoadGenerator { generator, options })
3418            }
3419            _ => unreachable!(),
3420        }
3421    }
3422
3423    fn parse_pg_connection_option(&mut self) -> Result<PgConfigOption<Raw>, ParserError> {
3424        let name = match self.expect_one_of_keywords(&[DETAILS, PUBLICATION, TEXT])? {
3425            DETAILS => PgConfigOptionName::Details,
3426            PUBLICATION => PgConfigOptionName::Publication,
3427            TEXT => {
3428                self.expect_keyword(COLUMNS)?;
3429
3430                let _ = self.consume_token(&Token::Eq);
3431
3432                let value = self
3433                    .parse_option_sequence(Parser::parse_item_name)?
3434                    .map(|inner| {
3435                        WithOptionValue::Sequence(
3436                            inner
3437                                .into_iter()
3438                                .map(WithOptionValue::UnresolvedItemName)
3439                                .collect_vec(),
3440                        )
3441                    });
3442
3443                return Ok(PgConfigOption {
3444                    name: PgConfigOptionName::TextColumns,
3445                    value,
3446                });
3447            }
3448            _ => unreachable!(),
3449        };
3450        Ok(PgConfigOption {
3451            name,
3452            value: self.parse_optional_option_value()?,
3453        })
3454    }
3455
3456    fn parse_mysql_connection_option(&mut self) -> Result<MySqlConfigOption<Raw>, ParserError> {
3457        match self.expect_one_of_keywords(&[DETAILS, TEXT, EXCLUDE, IGNORE])? {
3458            DETAILS => Ok(MySqlConfigOption {
3459                name: MySqlConfigOptionName::Details,
3460                value: self.parse_optional_option_value()?,
3461            }),
3462            TEXT => {
3463                self.expect_keyword(COLUMNS)?;
3464
3465                let _ = self.consume_token(&Token::Eq);
3466
3467                let value = self
3468                    .parse_option_sequence(Parser::parse_item_name)?
3469                    .map(|inner| {
3470                        WithOptionValue::Sequence(
3471                            inner
3472                                .into_iter()
3473                                .map(WithOptionValue::UnresolvedItemName)
3474                                .collect_vec(),
3475                        )
3476                    });
3477
3478                Ok(MySqlConfigOption {
3479                    name: MySqlConfigOptionName::TextColumns,
3480                    value,
3481                })
3482            }
3483            // IGNORE is historical syntax for the option.
3484            EXCLUDE | IGNORE => {
3485                self.expect_keyword(COLUMNS)?;
3486
3487                let _ = self.consume_token(&Token::Eq);
3488
3489                let value = self
3490                    .parse_option_sequence(Parser::parse_item_name)?
3491                    .map(|inner| {
3492                        WithOptionValue::Sequence(
3493                            inner
3494                                .into_iter()
3495                                .map(WithOptionValue::UnresolvedItemName)
3496                                .collect_vec(),
3497                        )
3498                    });
3499
3500                Ok(MySqlConfigOption {
3501                    name: MySqlConfigOptionName::ExcludeColumns,
3502                    value,
3503                })
3504            }
3505            _ => unreachable!(),
3506        }
3507    }
3508
3509    fn parse_sql_server_connection_option(
3510        &mut self,
3511    ) -> Result<SqlServerConfigOption<Raw>, ParserError> {
3512        match self.expect_one_of_keywords(&[DETAILS, TEXT, EXCLUDE])? {
3513            DETAILS => Ok(SqlServerConfigOption {
3514                name: SqlServerConfigOptionName::Details,
3515                value: self.parse_optional_option_value()?,
3516            }),
3517            TEXT => {
3518                self.expect_keyword(COLUMNS)?;
3519
3520                let _ = self.consume_token(&Token::Eq);
3521
3522                let value = self
3523                    .parse_option_sequence(Parser::parse_item_name)?
3524                    .map(|inner| {
3525                        WithOptionValue::Sequence(
3526                            inner
3527                                .into_iter()
3528                                .map(WithOptionValue::UnresolvedItemName)
3529                                .collect_vec(),
3530                        )
3531                    });
3532
3533                Ok(SqlServerConfigOption {
3534                    name: SqlServerConfigOptionName::TextColumns,
3535                    value,
3536                })
3537            }
3538            EXCLUDE => {
3539                self.expect_keyword(COLUMNS)?;
3540
3541                let _ = self.consume_token(&Token::Eq);
3542
3543                let value = self
3544                    .parse_option_sequence(Parser::parse_item_name)?
3545                    .map(|inner| {
3546                        WithOptionValue::Sequence(
3547                            inner
3548                                .into_iter()
3549                                .map(WithOptionValue::UnresolvedItemName)
3550                                .collect_vec(),
3551                        )
3552                    });
3553
3554                Ok(SqlServerConfigOption {
3555                    name: SqlServerConfigOptionName::ExcludeColumns,
3556                    value,
3557                })
3558            }
3559            _ => unreachable!(),
3560        }
3561    }
3562
3563    fn parse_load_generator_option(&mut self) -> Result<LoadGeneratorOption<Raw>, ParserError> {
3564        let name = match self.expect_one_of_keywords(&[
3565            AS,
3566            UP,
3567            SCALE,
3568            TICK,
3569            MAX,
3570            KEYS,
3571            SNAPSHOT,
3572            TRANSACTIONAL,
3573            VALUE,
3574            SEED,
3575            PARTITIONS,
3576            BATCH,
3577        ])? {
3578            AS => {
3579                self.expect_keyword(OF)?;
3580                LoadGeneratorOptionName::AsOf
3581            }
3582            UP => {
3583                self.expect_keyword(TO)?;
3584                LoadGeneratorOptionName::UpTo
3585            }
3586            SCALE => {
3587                self.expect_keyword(FACTOR)?;
3588                LoadGeneratorOptionName::ScaleFactor
3589            }
3590            TICK => {
3591                self.expect_keyword(INTERVAL)?;
3592                LoadGeneratorOptionName::TickInterval
3593            }
3594            MAX => {
3595                self.expect_keyword(CARDINALITY)?;
3596                LoadGeneratorOptionName::MaxCardinality
3597            }
3598            KEYS => LoadGeneratorOptionName::Keys,
3599            SNAPSHOT => {
3600                self.expect_keyword(ROUNDS)?;
3601                LoadGeneratorOptionName::SnapshotRounds
3602            }
3603            TRANSACTIONAL => {
3604                self.expect_keyword(SNAPSHOT)?;
3605                LoadGeneratorOptionName::TransactionalSnapshot
3606            }
3607            VALUE => {
3608                self.expect_keyword(SIZE)?;
3609                LoadGeneratorOptionName::ValueSize
3610            }
3611            SEED => LoadGeneratorOptionName::Seed,
3612            PARTITIONS => LoadGeneratorOptionName::Partitions,
3613            BATCH => {
3614                self.expect_keyword(SIZE)?;
3615                LoadGeneratorOptionName::BatchSize
3616            }
3617            _ => unreachable!(),
3618        };
3619
3620        let _ = self.consume_token(&Token::Eq);
3621        Ok(LoadGeneratorOption {
3622            name,
3623            value: self.parse_optional_option_value()?,
3624        })
3625    }
3626
3627    fn parse_create_kafka_sink_connection(
3628        &mut self,
3629    ) -> Result<CreateSinkConnection<Raw>, ParserError> {
3630        self.expect_keyword(CONNECTION)?;
3631
3632        let connection = self.parse_raw_name()?;
3633
3634        let options = if self.consume_token(&Token::LParen) {
3635            let options = self.parse_comma_separated(Parser::parse_kafka_sink_config_option)?;
3636            self.expect_token(&Token::RParen)?;
3637            options
3638        } else {
3639            vec![]
3640        };
3641
3642        // one token of lookahead:
3643        // * `KEY (` means we're parsing a list of columns for the key
3644        // * `KEY FORMAT` means there is no key, we'll parse a KeyValueFormat later
3645        let key =
3646            if self.peek_keyword(KEY) && self.peek_nth_token(1) != Some(Token::Keyword(FORMAT)) {
3647                let _ = self.expect_keyword(KEY);
3648                let key_columns = self.parse_parenthesized_column_list(Mandatory)?;
3649
3650                let not_enforced = if self.peek_keywords(&[NOT, ENFORCED]) {
3651                    let _ = self.expect_keywords(&[NOT, ENFORCED])?;
3652                    true
3653                } else {
3654                    false
3655                };
3656                Some(KafkaSinkKey {
3657                    key_columns,
3658                    not_enforced,
3659                })
3660            } else {
3661                None
3662            };
3663
3664        let headers = if self.parse_keyword(HEADERS) {
3665            Some(self.parse_identifier()?)
3666        } else {
3667            None
3668        };
3669
3670        Ok(CreateSinkConnection::Kafka {
3671            connection,
3672            options,
3673            key,
3674            headers,
3675        })
3676    }
3677
3678    fn parse_create_sink_connection(&mut self) -> Result<CreateSinkConnection<Raw>, ParserError> {
3679        match self.expect_one_of_keywords(&[KAFKA, ICEBERG])? {
3680            KAFKA => self.parse_create_kafka_sink_connection(),
3681            ICEBERG => {
3682                let pos = self.index;
3683                Err(ParserError::new(pos, "ICEBERG sinks are not supported yet"))
3684            }
3685            _ => unreachable!(),
3686        }
3687    }
3688
3689    fn parse_create_view(&mut self) -> Result<Statement<Raw>, ParserError> {
3690        let mut if_exists = if self.parse_keyword(OR) {
3691            self.expect_keyword(REPLACE)?;
3692            IfExistsBehavior::Replace
3693        } else {
3694            IfExistsBehavior::Error
3695        };
3696        let temporary = self.parse_keyword(TEMPORARY) | self.parse_keyword(TEMP);
3697        self.expect_keyword(VIEW)?;
3698        if if_exists == IfExistsBehavior::Error && self.parse_if_not_exists()? {
3699            if_exists = IfExistsBehavior::Skip;
3700        }
3701
3702        let definition = self.parse_view_definition()?;
3703        Ok(Statement::CreateView(CreateViewStatement {
3704            temporary,
3705            if_exists,
3706            definition,
3707        }))
3708    }
3709
3710    fn parse_view_definition(&mut self) -> Result<ViewDefinition<Raw>, ParserError> {
3711        // ANSI SQL and Postgres support RECURSIVE here, but we don't.
3712        let name = self.parse_item_name()?;
3713        let columns = self.parse_parenthesized_column_list(Optional)?;
3714        // Postgres supports WITH options here, but we don't.
3715        self.expect_keyword(AS)?;
3716        let query = self.parse_query()?;
3717        // Optional `WITH [ CASCADED | LOCAL ] CHECK OPTION` is widely supported here.
3718        Ok(ViewDefinition {
3719            name,
3720            columns,
3721            query,
3722        })
3723    }
3724
3725    fn parse_create_materialized_view(&mut self) -> Result<Statement<Raw>, ParserError> {
3726        let mut if_exists = if self.parse_keyword(OR) {
3727            self.expect_keyword(REPLACE)?;
3728            IfExistsBehavior::Replace
3729        } else {
3730            IfExistsBehavior::Error
3731        };
3732        self.expect_keywords(&[MATERIALIZED, VIEW])?;
3733        if if_exists == IfExistsBehavior::Error && self.parse_if_not_exists()? {
3734            if_exists = IfExistsBehavior::Skip;
3735        }
3736
3737        let name = self.parse_item_name()?;
3738        let columns = self.parse_parenthesized_column_list(Optional)?;
3739        let in_cluster = self.parse_optional_in_cluster()?;
3740
3741        let with_options = if self.parse_keyword(WITH) {
3742            self.expect_token(&Token::LParen)?;
3743            let options = self.parse_comma_separated(Parser::parse_materialized_view_option)?;
3744            self.expect_token(&Token::RParen)?;
3745            options
3746        } else {
3747            vec![]
3748        };
3749
3750        self.expect_keyword(AS)?;
3751        let query = self.parse_query()?;
3752        let as_of = self.parse_optional_internal_as_of()?;
3753
3754        Ok(Statement::CreateMaterializedView(
3755            CreateMaterializedViewStatement {
3756                if_exists,
3757                name,
3758                columns,
3759                in_cluster,
3760                query,
3761                as_of,
3762                with_options,
3763            },
3764        ))
3765    }
3766
3767    fn parse_create_continual_task(&mut self) -> Result<Statement<Raw>, ParserError> {
3768        // TODO(ct3): OR REPLACE/IF NOT EXISTS.
3769        self.expect_keywords(&[CONTINUAL, TASK])?;
3770
3771        // TODO(ct3): Multiple outputs.
3772        let name = RawItemName::Name(self.parse_item_name()?);
3773        let columns = match self.consume_token(&Token::LParen) {
3774            true => {
3775                let columns = self.parse_comma_separated(|parser| {
3776                    Ok(CteMutRecColumnDef {
3777                        name: parser.parse_identifier()?,
3778                        data_type: parser.parse_data_type()?,
3779                    })
3780                })?;
3781                self.expect_token(&Token::RParen)?;
3782                Some(columns)
3783            }
3784            false => None,
3785        };
3786        let in_cluster = self.parse_optional_in_cluster()?;
3787        let with_options = self.parse_create_continual_task_with_options()?;
3788
3789        // TODO(ct3): Multiple inputs.
3790        self.expect_keywords(&[ON, INPUT])?;
3791        let input = self.parse_raw_name()?;
3792        // TODO(ct3): Allow renaming the inserts/deletes so that we can use
3793        // something as both an "input" and a "reference".
3794
3795        // Also try to parse WITH options in the old location. We never exposed
3796        // this to users, so this can be removed once the CI upgrade tests have
3797        // moved past these old versions.
3798        let legacy_with_options = self.parse_create_continual_task_with_options()?;
3799        let with_options = match (!with_options.is_empty(), !legacy_with_options.is_empty()) {
3800            (_, false) => with_options,
3801            (false, true) => legacy_with_options,
3802            (true, true) => {
3803                return parser_err!(
3804                    self,
3805                    self.peek_prev_pos(),
3806                    "CREATE CONTINUAL TASK with options in both new and legacy locations"
3807                );
3808            }
3809        };
3810
3811        self.expect_keyword(AS)?;
3812
3813        let mut stmts = Vec::new();
3814        let mut expecting_statement_delimiter = false;
3815        self.expect_token(&Token::LParen)?;
3816        // TODO(ct2): Dedup this with parse_statements?
3817        loop {
3818            // ignore empty statements (between successive statement delimiters)
3819            while self.consume_token(&Token::Semicolon) {
3820                expecting_statement_delimiter = false;
3821            }
3822
3823            if self.consume_token(&Token::RParen) {
3824                break;
3825            } else if expecting_statement_delimiter {
3826                self.expected(self.peek_pos(), "end of statement", self.peek_token())?
3827            }
3828
3829            let stmt = self.parse_statement().map_err(|err| err.error)?.ast;
3830            match stmt {
3831                Statement::Delete(stmt) => stmts.push(ContinualTaskStmt::Delete(stmt)),
3832                Statement::Insert(stmt) => stmts.push(ContinualTaskStmt::Insert(stmt)),
3833                _ => {
3834                    return parser_err!(
3835                        self,
3836                        self.peek_prev_pos(),
3837                        "unsupported query in CREATE CONTINUAL TASK"
3838                    );
3839                }
3840            }
3841            expecting_statement_delimiter = true;
3842        }
3843
3844        let as_of = self.parse_optional_internal_as_of()?;
3845
3846        Ok(Statement::CreateContinualTask(
3847            CreateContinualTaskStatement {
3848                name,
3849                columns,
3850                in_cluster,
3851                with_options,
3852                input,
3853                stmts,
3854                as_of,
3855                sugar: None,
3856            },
3857        ))
3858    }
3859
3860    fn parse_create_continual_task_from_transform(
3861        &mut self,
3862    ) -> Result<Statement<Raw>, ParserError> {
3863        self.expect_keywords(&[CONTINUAL, TASK])?;
3864        let name = RawItemName::Name(self.parse_item_name()?);
3865        let in_cluster = self.parse_optional_in_cluster()?;
3866        let with_options = self.parse_create_continual_task_with_options()?;
3867
3868        self.expect_keywords(&[FROM, TRANSFORM])?;
3869        let input = self.parse_raw_name()?;
3870
3871        self.expect_keyword(USING)?;
3872        self.expect_token(&Token::LParen)?;
3873        let transform = self.parse_query()?;
3874        self.expect_token(&Token::RParen)?;
3875
3876        let as_of = self.parse_optional_internal_as_of()?;
3877
3878        // `INSERT INTO name SELECT * FROM <transform>`
3879        let insert = InsertStatement {
3880            table_name: name.clone(),
3881            columns: Vec::new(),
3882            source: InsertSource::Query(transform.clone()),
3883            returning: Vec::new(),
3884        };
3885
3886        // Desugar into a normal CT body.
3887        let stmts = vec![ContinualTaskStmt::Insert(insert)];
3888
3889        Ok(Statement::CreateContinualTask(
3890            CreateContinualTaskStatement {
3891                name,
3892                columns: None,
3893                in_cluster,
3894                with_options,
3895                input,
3896                stmts,
3897                as_of,
3898                sugar: Some(CreateContinualTaskSugar::Transform { transform }),
3899            },
3900        ))
3901    }
3902
3903    fn parse_create_continual_task_from_retain(&mut self) -> Result<Statement<Raw>, ParserError> {
3904        self.expect_keywords(&[CONTINUAL, TASK])?;
3905        let name = RawItemName::Name(self.parse_item_name()?);
3906        let in_cluster = self.parse_optional_in_cluster()?;
3907        let with_options = self.parse_create_continual_task_with_options()?;
3908
3909        self.expect_keywords(&[FROM, RETAIN])?;
3910        let input = self.parse_raw_name()?;
3911
3912        self.expect_keyword(WHILE)?;
3913        self.expect_token(&Token::LParen)?;
3914        let retain = self.parse_expr()?;
3915        self.expect_token(&Token::RParen)?;
3916
3917        let as_of = self.parse_optional_internal_as_of()?;
3918
3919        // `INSERT INTO name SELECT * FROM input WHERE <retain>`
3920        let insert = InsertStatement {
3921            table_name: name.clone(),
3922            columns: Vec::new(),
3923            source: InsertSource::Query(Query {
3924                ctes: CteBlock::Simple(Vec::new()),
3925                body: SetExpr::Select(Box::new(Select {
3926                    from: vec![TableWithJoins {
3927                        relation: TableFactor::Table {
3928                            name: input.clone(),
3929                            alias: None,
3930                        },
3931                        joins: Vec::new(),
3932                    }],
3933                    selection: Some(retain.clone()),
3934                    distinct: None,
3935                    projection: vec![SelectItem::Wildcard],
3936                    group_by: Vec::new(),
3937                    having: None,
3938                    qualify: None,
3939                    options: Vec::new(),
3940                })),
3941                order_by: Vec::new(),
3942                limit: None,
3943                offset: None,
3944            }),
3945            returning: Vec::new(),
3946        };
3947
3948        // `DELETE FROM name WHERE NOT <retain>`
3949        let delete = DeleteStatement {
3950            table_name: name.clone(),
3951            alias: None,
3952            using: Vec::new(),
3953            selection: Some(retain.clone().negate()),
3954        };
3955
3956        // Desugar into a normal CT body.
3957        let stmts = vec![
3958            ContinualTaskStmt::Insert(insert),
3959            ContinualTaskStmt::Delete(delete),
3960        ];
3961
3962        Ok(Statement::CreateContinualTask(
3963            CreateContinualTaskStatement {
3964                name,
3965                columns: None,
3966                in_cluster,
3967                with_options,
3968                input,
3969                stmts,
3970                as_of,
3971                sugar: Some(CreateContinualTaskSugar::Retain { retain }),
3972            },
3973        ))
3974    }
3975
3976    fn parse_materialized_view_option_name(
3977        &mut self,
3978    ) -> Result<MaterializedViewOptionName, ParserError> {
3979        let option = self.expect_one_of_keywords(&[ASSERT, PARTITION, RETAIN, REFRESH])?;
3980        let name = match option {
3981            ASSERT => {
3982                self.expect_keywords(&[NOT, NULL])?;
3983                MaterializedViewOptionName::AssertNotNull
3984            }
3985            PARTITION => {
3986                self.expect_keyword(BY)?;
3987                MaterializedViewOptionName::PartitionBy
3988            }
3989            RETAIN => {
3990                self.expect_keyword(HISTORY)?;
3991                MaterializedViewOptionName::RetainHistory
3992            }
3993            REFRESH => MaterializedViewOptionName::Refresh,
3994            _ => unreachable!(),
3995        };
3996        Ok(name)
3997    }
3998
3999    fn parse_materialized_view_option(
4000        &mut self,
4001    ) -> Result<MaterializedViewOption<Raw>, ParserError> {
4002        let name = self.parse_materialized_view_option_name()?;
4003        let value = match name {
4004            MaterializedViewOptionName::RetainHistory => self.parse_option_retain_history()?,
4005            MaterializedViewOptionName::Refresh => {
4006                Some(self.parse_materialized_view_refresh_option_value()?)
4007            }
4008            _ => self.parse_optional_option_value()?,
4009        };
4010        Ok(MaterializedViewOption { name, value })
4011    }
4012
4013    fn parse_option_retain_history(&mut self) -> Result<Option<WithOptionValue<Raw>>, ParserError> {
4014        Ok(Some(self.parse_retain_history()?))
4015    }
4016
4017    fn parse_retain_history(&mut self) -> Result<WithOptionValue<Raw>, ParserError> {
4018        let _ = self.consume_token(&Token::Eq);
4019        self.expect_keyword(FOR)?;
4020        let value = self.parse_value()?;
4021        Ok(WithOptionValue::RetainHistoryFor(value))
4022    }
4023
4024    fn parse_materialized_view_refresh_option_value(
4025        &mut self,
4026    ) -> Result<WithOptionValue<Raw>, ParserError> {
4027        let _ = self.consume_token(&Token::Eq);
4028
4029        match self.expect_one_of_keywords(&[ON, AT, EVERY])? {
4030            ON => {
4031                self.expect_keyword(COMMIT)?;
4032                Ok(WithOptionValue::Refresh(RefreshOptionValue::OnCommit))
4033            }
4034            AT => {
4035                if self.parse_keyword(CREATION) {
4036                    Ok(WithOptionValue::Refresh(RefreshOptionValue::AtCreation))
4037                } else {
4038                    Ok(WithOptionValue::Refresh(RefreshOptionValue::At(
4039                        RefreshAtOptionValue {
4040                            time: self.parse_expr()?,
4041                        },
4042                    )))
4043                }
4044            }
4045            EVERY => {
4046                let interval = self.parse_interval_value()?;
4047                let aligned_to = if self.parse_keywords(&[ALIGNED, TO]) {
4048                    Some(self.parse_expr()?)
4049                } else {
4050                    None
4051                };
4052                Ok(WithOptionValue::Refresh(RefreshOptionValue::Every(
4053                    RefreshEveryOptionValue {
4054                        interval,
4055                        aligned_to,
4056                    },
4057                )))
4058            }
4059            _ => unreachable!(),
4060        }
4061    }
4062
4063    fn parse_create_continual_task_with_options(
4064        &mut self,
4065    ) -> Result<Vec<ContinualTaskOption<Raw>>, ParserError> {
4066        if self.parse_keyword(WITH) {
4067            self.expect_token(&Token::LParen)?;
4068            let options = self.parse_comma_separated(Parser::parse_continual_task_option)?;
4069            self.expect_token(&Token::RParen)?;
4070            Ok(options)
4071        } else {
4072            Ok(vec![])
4073        }
4074    }
4075
4076    fn parse_continual_task_option_name(&mut self) -> Result<ContinualTaskOptionName, ParserError> {
4077        let option = self.expect_one_of_keywords(&[SNAPSHOT])?;
4078        let name = match option {
4079            SNAPSHOT => ContinualTaskOptionName::Snapshot,
4080            _ => unreachable!(),
4081        };
4082        Ok(name)
4083    }
4084
4085    fn parse_continual_task_option(&mut self) -> Result<ContinualTaskOption<Raw>, ParserError> {
4086        let name = self.parse_continual_task_option_name()?;
4087        let value = self.parse_optional_option_value()?;
4088        Ok(ContinualTaskOption { name, value })
4089    }
4090
4091    fn parse_create_index(&mut self) -> Result<Statement<Raw>, ParserError> {
4092        let default_index = self.parse_keyword(DEFAULT);
4093        self.expect_keyword(INDEX)?;
4094
4095        let if_not_exists = self.parse_if_not_exists()?;
4096        let name = if self.peek_keyword(IN) || self.peek_keyword(ON) {
4097            if if_not_exists && !default_index {
4098                return self.expected(self.peek_pos(), "index name", self.peek_token());
4099            }
4100            None
4101        } else {
4102            Some(self.parse_identifier()?)
4103        };
4104        let in_cluster = self.parse_optional_in_cluster()?;
4105        self.expect_keyword(ON)?;
4106        let on_name = self.parse_raw_name()?;
4107
4108        // Arrangements are the only index type we support, so we can just ignore this
4109        if self.parse_keyword(USING) {
4110            self.expect_keyword(ARRANGEMENT)?;
4111        }
4112
4113        let key_parts = if default_index {
4114            None
4115        } else {
4116            self.expect_token(&Token::LParen)?;
4117            if self.consume_token(&Token::RParen) {
4118                Some(vec![])
4119            } else {
4120                let key_parts = self
4121                    .parse_comma_separated(Parser::parse_order_by_expr)?
4122                    .into_iter()
4123                    .map(|x| x.expr)
4124                    .collect::<Vec<_>>();
4125                self.expect_token(&Token::RParen)?;
4126                Some(key_parts)
4127            }
4128        };
4129
4130        let with_options = if self.parse_keyword(WITH) {
4131            self.expect_token(&Token::LParen)?;
4132            let o = if matches!(self.peek_token(), Some(Token::RParen)) {
4133                vec![]
4134            } else {
4135                self.parse_comma_separated(Parser::parse_index_option)?
4136            };
4137            self.expect_token(&Token::RParen)?;
4138            o
4139        } else {
4140            vec![]
4141        };
4142
4143        Ok(Statement::CreateIndex(CreateIndexStatement {
4144            name,
4145            in_cluster,
4146            on_name,
4147            key_parts,
4148            with_options,
4149            if_not_exists,
4150        }))
4151    }
4152
4153    fn parse_table_option_name(&mut self) -> Result<TableOptionName, ParserError> {
4154        // this is only so we can test redacted values, of which no other
4155        // examples exist as of its introduction.
4156        if self.parse_keyword(REDACTED) {
4157            return Ok(TableOptionName::RedactedTest);
4158        }
4159        let name = match self.expect_one_of_keywords(&[PARTITION, RETAIN])? {
4160            PARTITION => {
4161                self.expect_keyword(BY)?;
4162                TableOptionName::PartitionBy
4163            }
4164            RETAIN => {
4165                self.expect_keyword(HISTORY)?;
4166                TableOptionName::RetainHistory
4167            }
4168            _ => unreachable!(),
4169        };
4170        Ok(name)
4171    }
4172
4173    fn parse_table_option(&mut self) -> Result<TableOption<Raw>, ParserError> {
4174        let name = self.parse_table_option_name()?;
4175        let value = match name {
4176            TableOptionName::PartitionBy => self.parse_optional_option_value(),
4177            TableOptionName::RetainHistory => self.parse_option_retain_history(),
4178            TableOptionName::RedactedTest => self.parse_optional_option_value(),
4179        }?;
4180        Ok(TableOption { name, value })
4181    }
4182
4183    fn parse_index_option_name(&mut self) -> Result<IndexOptionName, ParserError> {
4184        self.expect_keywords(&[RETAIN, HISTORY])?;
4185        Ok(IndexOptionName::RetainHistory)
4186    }
4187
4188    fn parse_index_option(&mut self) -> Result<IndexOption<Raw>, ParserError> {
4189        let name = self.parse_index_option_name()?;
4190        let value = match name {
4191            IndexOptionName::RetainHistory => self.parse_option_retain_history(),
4192        }?;
4193        Ok(IndexOption { name, value })
4194    }
4195
4196    fn parse_raw_ident(&mut self) -> Result<RawClusterName, ParserError> {
4197        if self.consume_token(&Token::LBracket) {
4198            let id = self.parse_raw_ident_str()?;
4199            self.expect_token(&Token::RBracket)?;
4200            Ok(RawClusterName::Resolved(id))
4201        } else {
4202            Ok(RawClusterName::Unresolved(self.parse_identifier()?))
4203        }
4204    }
4205
4206    fn parse_raw_network_policy_name(&mut self) -> Result<RawNetworkPolicyName, ParserError> {
4207        if self.consume_token(&Token::LBracket) {
4208            let id = self.parse_raw_ident_str()?;
4209            self.expect_token(&Token::RBracket)?;
4210            Ok(RawNetworkPolicyName::Resolved(id))
4211        } else {
4212            Ok(RawNetworkPolicyName::Unresolved(self.parse_identifier()?))
4213        }
4214    }
4215
4216    fn parse_raw_ident_str(&mut self) -> Result<String, ParserError> {
4217        match self.next_token() {
4218            Some(Token::Ident(id)) => Ok(id.into_inner()),
4219            Some(Token::Number(n)) => Ok(n),
4220            _ => parser_err!(self, self.peek_prev_pos(), "expected id"),
4221        }
4222    }
4223
4224    fn parse_optional_in_cluster(&mut self) -> Result<Option<RawClusterName>, ParserError> {
4225        if self.parse_keywords(&[IN, CLUSTER]) {
4226            Ok(Some(self.parse_raw_ident()?))
4227        } else {
4228            Ok(None)
4229        }
4230    }
4231
4232    fn parse_create_role(&mut self) -> Result<Statement<Raw>, ParserError> {
4233        self.expect_keyword(ROLE)?;
4234        let name = self.parse_identifier()?;
4235        let _ = self.parse_keyword(WITH);
4236        let options = self.parse_role_attributes()?;
4237        Ok(Statement::CreateRole(CreateRoleStatement { name, options }))
4238    }
4239
4240    fn parse_role_attributes(&mut self) -> Result<Vec<RoleAttribute>, ParserError> {
4241        let mut options = vec![];
4242        loop {
4243            match self.parse_one_of_keywords(&[
4244                SUPERUSER,
4245                NOSUPERUSER,
4246                LOGIN,
4247                NOLOGIN,
4248                INHERIT,
4249                NOINHERIT,
4250                CREATECLUSTER,
4251                NOCREATECLUSTER,
4252                CREATEDB,
4253                NOCREATEDB,
4254                CREATEROLE,
4255                NOCREATEROLE,
4256                PASSWORD,
4257            ]) {
4258                None => break,
4259                Some(SUPERUSER) => options.push(RoleAttribute::SuperUser),
4260                Some(NOSUPERUSER) => options.push(RoleAttribute::NoSuperUser),
4261                Some(LOGIN) => options.push(RoleAttribute::Login),
4262                Some(NOLOGIN) => options.push(RoleAttribute::NoLogin),
4263                Some(INHERIT) => options.push(RoleAttribute::Inherit),
4264                Some(NOINHERIT) => options.push(RoleAttribute::NoInherit),
4265                Some(CREATECLUSTER) => options.push(RoleAttribute::CreateCluster),
4266                Some(NOCREATECLUSTER) => options.push(RoleAttribute::NoCreateCluster),
4267                Some(CREATEDB) => options.push(RoleAttribute::CreateDB),
4268                Some(NOCREATEDB) => options.push(RoleAttribute::NoCreateDB),
4269                Some(CREATEROLE) => options.push(RoleAttribute::CreateRole),
4270                Some(NOCREATEROLE) => options.push(RoleAttribute::NoCreateRole),
4271                Some(PASSWORD) => {
4272                    if self.parse_keyword(NULL) {
4273                        options.push(RoleAttribute::Password(None));
4274                        continue;
4275                    }
4276                    let password = self.parse_literal_string()?;
4277                    options.push(RoleAttribute::Password(Some(password)));
4278                }
4279                Some(_) => unreachable!(),
4280            }
4281        }
4282        Ok(options)
4283    }
4284
4285    fn parse_create_secret(&mut self) -> Result<Statement<Raw>, ParserError> {
4286        self.expect_keyword(SECRET)?;
4287        let if_not_exists = self.parse_if_not_exists()?;
4288        let name = self.parse_item_name()?;
4289        self.expect_keyword(AS)?;
4290        let value = self.parse_expr()?;
4291        Ok(Statement::CreateSecret(CreateSecretStatement {
4292            name,
4293            if_not_exists,
4294            value,
4295        }))
4296    }
4297
4298    fn parse_create_type(&mut self) -> Result<Statement<Raw>, ParserError> {
4299        self.expect_keyword(TYPE)?;
4300        let name = self.parse_item_name()?;
4301        self.expect_keyword(AS)?;
4302
4303        match self.parse_one_of_keywords(&[LIST, MAP]) {
4304            Some(LIST) => {
4305                self.expect_token(&Token::LParen)?;
4306                let options = self.parse_comma_separated(Parser::parse_create_type_list_option)?;
4307                self.expect_token(&Token::RParen)?;
4308                Ok(Statement::CreateType(CreateTypeStatement {
4309                    name,
4310                    as_type: CreateTypeAs::List { options },
4311                }))
4312            }
4313            Some(MAP) => {
4314                self.expect_token(&Token::LParen)?;
4315                let options = self.parse_comma_separated(Parser::parse_create_type_map_option)?;
4316                self.expect_token(&Token::RParen)?;
4317                Ok(Statement::CreateType(CreateTypeStatement {
4318                    name,
4319                    as_type: CreateTypeAs::Map { options },
4320                }))
4321            }
4322            None => {
4323                let column_defs = self.parse_composite_type_definition()?;
4324
4325                Ok(Statement::CreateType(CreateTypeStatement {
4326                    name,
4327                    as_type: CreateTypeAs::Record { column_defs },
4328                }))
4329            }
4330            _ => unreachable!(),
4331        }
4332    }
4333
4334    fn parse_create_type_list_option(&mut self) -> Result<CreateTypeListOption<Raw>, ParserError> {
4335        self.expect_keywords(&[ELEMENT, TYPE])?;
4336        let name = CreateTypeListOptionName::ElementType;
4337        Ok(CreateTypeListOption {
4338            name,
4339            value: Some(self.parse_data_type_option_value()?),
4340        })
4341    }
4342
4343    fn parse_create_type_map_option(&mut self) -> Result<CreateTypeMapOption<Raw>, ParserError> {
4344        let name = match self.expect_one_of_keywords(&[KEY, VALUE])? {
4345            KEY => {
4346                self.expect_keyword(TYPE)?;
4347                CreateTypeMapOptionName::KeyType
4348            }
4349            VALUE => {
4350                self.expect_keyword(TYPE)?;
4351                CreateTypeMapOptionName::ValueType
4352            }
4353            _ => unreachable!(),
4354        };
4355        Ok(CreateTypeMapOption {
4356            name,
4357            value: Some(self.parse_data_type_option_value()?),
4358        })
4359    }
4360
4361    fn parse_create_cluster(&mut self) -> Result<Statement<Raw>, ParserError> {
4362        let name = self.parse_identifier()?;
4363        // For historical reasons, the parentheses around the options can be
4364        // omitted.
4365        let paren = self.consume_token(&Token::LParen);
4366        let options = self.parse_comma_separated(Parser::parse_cluster_option)?;
4367        if paren {
4368            self.expect_token(&Token::RParen)?;
4369        }
4370
4371        let features = if self.parse_keywords(&[FEATURES]) {
4372            self.expect_token(&Token::LParen)?;
4373            let features = self.parse_comma_separated(Parser::parse_cluster_feature)?;
4374            self.expect_token(&Token::RParen)?;
4375            features
4376        } else {
4377            Vec::new()
4378        };
4379
4380        Ok(Statement::CreateCluster(CreateClusterStatement {
4381            name,
4382            options,
4383            features,
4384        }))
4385    }
4386
4387    fn parse_cluster_option_name(&mut self) -> Result<ClusterOptionName, ParserError> {
4388        let option = self.expect_one_of_keywords(&[
4389            AVAILABILITY,
4390            DISK,
4391            INTROSPECTION,
4392            MANAGED,
4393            REPLICAS,
4394            REPLICATION,
4395            SIZE,
4396            SCHEDULE,
4397            WORKLOAD,
4398        ])?;
4399        let name = match option {
4400            AVAILABILITY => {
4401                self.expect_keyword(ZONES)?;
4402                ClusterOptionName::AvailabilityZones
4403            }
4404            DISK => ClusterOptionName::Disk,
4405            INTROSPECTION => match self.expect_one_of_keywords(&[DEBUGGING, INTERVAL])? {
4406                DEBUGGING => ClusterOptionName::IntrospectionDebugging,
4407                INTERVAL => ClusterOptionName::IntrospectionInterval,
4408                _ => unreachable!(),
4409            },
4410            MANAGED => ClusterOptionName::Managed,
4411            REPLICAS => ClusterOptionName::Replicas,
4412            REPLICATION => {
4413                self.expect_keyword(FACTOR)?;
4414                ClusterOptionName::ReplicationFactor
4415            }
4416            SIZE => ClusterOptionName::Size,
4417            SCHEDULE => ClusterOptionName::Schedule,
4418            WORKLOAD => {
4419                self.expect_keyword(CLASS)?;
4420                ClusterOptionName::WorkloadClass
4421            }
4422            _ => unreachable!(),
4423        };
4424        Ok(name)
4425    }
4426
4427    fn parse_cluster_option(&mut self) -> Result<ClusterOption<Raw>, ParserError> {
4428        let name = self.parse_cluster_option_name()?;
4429
4430        match name {
4431            ClusterOptionName::Replicas => self.parse_cluster_option_replicas(),
4432            ClusterOptionName::Schedule => self.parse_cluster_option_schedule(),
4433            _ => {
4434                let value = self.parse_optional_option_value()?;
4435                Ok(ClusterOption { name, value })
4436            }
4437        }
4438    }
4439
4440    fn parse_alter_cluster_option(&mut self) -> Result<ClusterAlterOption<Raw>, ParserError> {
4441        let (name, value) = match self.expect_one_of_keywords(&[WAIT])? {
4442            WAIT => {
4443                let _ = self.consume_token(&Token::Eq);
4444                let v = match self.expect_one_of_keywords(&[FOR, UNTIL])? {
4445                    FOR => Some(WithOptionValue::ClusterAlterStrategy(
4446                        ClusterAlterOptionValue::For(self.parse_value()?),
4447                    )),
4448                    UNTIL => {
4449                        self.expect_keyword(READY)?;
4450                        let _ = self.consume_token(&Token::Eq);
4451                        let _ = self.expect_token(&Token::LParen)?;
4452                        let opts = Some(WithOptionValue::ClusterAlterStrategy(
4453                            ClusterAlterOptionValue::UntilReady(self.parse_comma_separated(
4454                                Parser::parse_cluster_alter_until_ready_option,
4455                            )?),
4456                        ));
4457                        let _ = self.expect_token(&Token::RParen)?;
4458                        opts
4459                    }
4460                    _ => unreachable!(),
4461                };
4462                (ClusterAlterOptionName::Wait, v)
4463            }
4464            _ => unreachable!(),
4465        };
4466        Ok(ClusterAlterOption { name, value })
4467    }
4468
4469    fn parse_cluster_alter_until_ready_option(
4470        &mut self,
4471    ) -> Result<ClusterAlterUntilReadyOption<Raw>, ParserError> {
4472        let name = match self.expect_one_of_keywords(&[TIMEOUT, ON])? {
4473            ON => {
4474                self.expect_keywords(&[TIMEOUT])?;
4475                ClusterAlterUntilReadyOptionName::OnTimeout
4476            }
4477            TIMEOUT => ClusterAlterUntilReadyOptionName::Timeout,
4478            _ => unreachable!(),
4479        };
4480        let value = self.parse_optional_option_value()?;
4481        Ok(ClusterAlterUntilReadyOption { name, value })
4482    }
4483
4484    fn parse_cluster_option_replicas(&mut self) -> Result<ClusterOption<Raw>, ParserError> {
4485        let _ = self.consume_token(&Token::Eq);
4486        self.expect_token(&Token::LParen)?;
4487        let replicas = if self.consume_token(&Token::RParen) {
4488            vec![]
4489        } else {
4490            let replicas = self.parse_comma_separated(|parser| {
4491                let name = parser.parse_identifier()?;
4492                parser.expect_token(&Token::LParen)?;
4493                let options = parser.parse_comma_separated(Parser::parse_replica_option)?;
4494                parser.expect_token(&Token::RParen)?;
4495                Ok(ReplicaDefinition { name, options })
4496            })?;
4497            self.expect_token(&Token::RParen)?;
4498            replicas
4499        };
4500        Ok(ClusterOption {
4501            name: ClusterOptionName::Replicas,
4502            value: Some(WithOptionValue::ClusterReplicas(replicas)),
4503        })
4504    }
4505
4506    fn parse_cluster_option_schedule(&mut self) -> Result<ClusterOption<Raw>, ParserError> {
4507        let _ = self.consume_token(&Token::Eq);
4508        let kw = self.expect_one_of_keywords(&[MANUAL, ON])?;
4509        let value = match kw {
4510            MANUAL => ClusterScheduleOptionValue::Manual,
4511            ON => {
4512                self.expect_keyword(REFRESH)?;
4513                // Parse optional `(HYDRATION TIME ESTIMATE ...)`
4514                let hydration_time_estimate = if self.consume_token(&Token::LParen) {
4515                    self.expect_keywords(&[HYDRATION, TIME, ESTIMATE])?;
4516                    let _ = self.consume_token(&Token::Eq);
4517                    let interval = self.parse_interval_value()?;
4518                    self.expect_token(&Token::RParen)?;
4519                    Some(interval)
4520                } else {
4521                    None
4522                };
4523                ClusterScheduleOptionValue::Refresh {
4524                    hydration_time_estimate,
4525                }
4526            }
4527            _ => unreachable!(),
4528        };
4529        Ok(ClusterOption {
4530            name: ClusterOptionName::Schedule,
4531            value: Some(WithOptionValue::ClusterScheduleOptionValue(value)),
4532        })
4533    }
4534
4535    fn parse_replica_option(&mut self) -> Result<ReplicaOption<Raw>, ParserError> {
4536        let name = match self.expect_one_of_keywords(&[
4537            AVAILABILITY,
4538            BILLED,
4539            COMPUTE,
4540            COMPUTECTL,
4541            DISK,
4542            INTERNAL,
4543            INTROSPECTION,
4544            SIZE,
4545            STORAGE,
4546            STORAGECTL,
4547            WORKERS,
4548        ])? {
4549            AVAILABILITY => {
4550                self.expect_keyword(ZONE)?;
4551                ReplicaOptionName::AvailabilityZone
4552            }
4553            BILLED => {
4554                self.expect_keyword(AS)?;
4555                ReplicaOptionName::BilledAs
4556            }
4557            COMPUTE => {
4558                self.expect_keyword(ADDRESSES)?;
4559                ReplicaOptionName::ComputeAddresses
4560            }
4561            COMPUTECTL => {
4562                self.expect_keyword(ADDRESSES)?;
4563                ReplicaOptionName::ComputectlAddresses
4564            }
4565            DISK => ReplicaOptionName::Disk,
4566            INTERNAL => ReplicaOptionName::Internal,
4567            INTROSPECTION => match self.expect_one_of_keywords(&[DEBUGGING, INTERVAL])? {
4568                DEBUGGING => ReplicaOptionName::IntrospectionDebugging,
4569                INTERVAL => ReplicaOptionName::IntrospectionInterval,
4570                _ => unreachable!(),
4571            },
4572            SIZE => ReplicaOptionName::Size,
4573            STORAGE => {
4574                self.expect_keyword(ADDRESSES)?;
4575                ReplicaOptionName::StorageAddresses
4576            }
4577            STORAGECTL => {
4578                self.expect_keyword(ADDRESSES)?;
4579                ReplicaOptionName::StoragectlAddresses
4580            }
4581            WORKERS => ReplicaOptionName::Workers,
4582            _ => unreachable!(),
4583        };
4584        let value = self.parse_optional_option_value()?;
4585        Ok(ReplicaOption { name, value })
4586    }
4587
4588    fn parse_cluster_feature(&mut self) -> Result<ClusterFeature<Raw>, ParserError> {
4589        Ok(ClusterFeature {
4590            name: self.parse_cluster_feature_name()?,
4591            value: self.parse_optional_option_value()?,
4592        })
4593    }
4594
4595    fn parse_create_cluster_replica(&mut self) -> Result<Statement<Raw>, ParserError> {
4596        self.next_token();
4597        let of_cluster = self.parse_identifier()?;
4598        self.expect_token(&Token::Dot)?;
4599        let name = self.parse_identifier()?;
4600        // For historical reasons, the parentheses around the options can be
4601        // omitted.
4602        let paren = self.consume_token(&Token::LParen);
4603        let options = self.parse_comma_separated(Parser::parse_replica_option)?;
4604        if paren {
4605            let _ = self.consume_token(&Token::RParen);
4606        }
4607        Ok(Statement::CreateClusterReplica(
4608            CreateClusterReplicaStatement {
4609                of_cluster,
4610                definition: ReplicaDefinition { name, options },
4611            },
4612        ))
4613    }
4614
4615    fn parse_if_exists(&mut self) -> Result<bool, ParserError> {
4616        if self.parse_keyword(IF) {
4617            self.expect_keyword(EXISTS)?;
4618            Ok(true)
4619        } else {
4620            Ok(false)
4621        }
4622    }
4623
4624    fn parse_if_not_exists(&mut self) -> Result<bool, ParserError> {
4625        if self.parse_keyword(IF) {
4626            self.expect_keywords(&[NOT, EXISTS])?;
4627            Ok(true)
4628        } else {
4629            Ok(false)
4630        }
4631    }
4632
4633    fn parse_alias(&mut self) -> Result<Option<Ident>, ParserError> {
4634        self.parse_keyword(AS)
4635            .then(|| self.parse_identifier())
4636            .transpose()
4637    }
4638
4639    fn parse_source_include_metadata(&mut self) -> Result<Vec<SourceIncludeMetadata>, ParserError> {
4640        if self.parse_keyword(INCLUDE) {
4641            self.parse_comma_separated(|parser| {
4642                let metadata = match parser
4643                    .expect_one_of_keywords(&[KEY, TIMESTAMP, PARTITION, OFFSET, HEADERS, HEADER])?
4644                {
4645                    KEY => SourceIncludeMetadata::Key {
4646                        alias: parser.parse_alias()?,
4647                    },
4648                    TIMESTAMP => SourceIncludeMetadata::Timestamp {
4649                        alias: parser.parse_alias()?,
4650                    },
4651                    PARTITION => SourceIncludeMetadata::Partition {
4652                        alias: parser.parse_alias()?,
4653                    },
4654                    OFFSET => SourceIncludeMetadata::Offset {
4655                        alias: parser.parse_alias()?,
4656                    },
4657                    HEADERS => SourceIncludeMetadata::Headers {
4658                        alias: parser.parse_alias()?,
4659                    },
4660                    HEADER => {
4661                        let key: String = parser.parse_literal_string()?;
4662                        parser.expect_keyword(AS)?;
4663                        let alias = parser.parse_identifier()?;
4664                        let use_bytes = parser.parse_keyword(BYTES);
4665                        SourceIncludeMetadata::Header {
4666                            alias,
4667                            key,
4668                            use_bytes,
4669                        }
4670                    }
4671                    _ => unreachable!("only explicitly allowed items can be parsed"),
4672                };
4673                Ok(metadata)
4674            })
4675        } else {
4676            Ok(vec![])
4677        }
4678    }
4679
4680    fn parse_discard(&mut self) -> Result<Statement<Raw>, ParserError> {
4681        let target = match self.expect_one_of_keywords(&[ALL, PLANS, SEQUENCES, TEMP, TEMPORARY])? {
4682            ALL => DiscardTarget::All,
4683            PLANS => DiscardTarget::Plans,
4684            SEQUENCES => DiscardTarget::Sequences,
4685            TEMP | TEMPORARY => DiscardTarget::Temp,
4686            _ => unreachable!(),
4687        };
4688        Ok(Statement::Discard(DiscardStatement { target }))
4689    }
4690
4691    fn parse_drop(&mut self) -> Result<Statement<Raw>, ParserStatementError> {
4692        if self.parse_keyword(OWNED) {
4693            self.parse_drop_owned()
4694                .map_parser_err(StatementKind::DropOwned)
4695        } else {
4696            self.parse_drop_objects()
4697                .map_parser_err(StatementKind::DropObjects)
4698        }
4699    }
4700
4701    fn parse_drop_objects(&mut self) -> Result<Statement<Raw>, ParserError> {
4702        let object_type = self.expect_object_type()?;
4703        let if_exists = self.parse_if_exists()?;
4704        match object_type {
4705            ObjectType::Database => {
4706                let name = UnresolvedObjectName::Database(self.parse_database_name()?);
4707                let restrict = matches!(
4708                    self.parse_at_most_one_keyword(&[CASCADE, RESTRICT], "DROP")?,
4709                    Some(RESTRICT),
4710                );
4711                Ok(Statement::DropObjects(DropObjectsStatement {
4712                    object_type: ObjectType::Database,
4713                    if_exists,
4714                    names: vec![name],
4715                    cascade: !restrict,
4716                }))
4717            }
4718            ObjectType::Schema => {
4719                let names = self.parse_comma_separated(|parser| {
4720                    Ok(UnresolvedObjectName::Schema(parser.parse_schema_name()?))
4721                })?;
4722
4723                let cascade = matches!(
4724                    self.parse_at_most_one_keyword(&[CASCADE, RESTRICT], "DROP")?,
4725                    Some(CASCADE),
4726                );
4727                Ok(Statement::DropObjects(DropObjectsStatement {
4728                    object_type: ObjectType::Schema,
4729                    if_exists,
4730                    names,
4731                    cascade,
4732                }))
4733            }
4734            ObjectType::Role => {
4735                let names = self.parse_comma_separated(|parser| {
4736                    Ok(UnresolvedObjectName::Role(parser.parse_identifier()?))
4737                })?;
4738                Ok(Statement::DropObjects(DropObjectsStatement {
4739                    object_type: ObjectType::Role,
4740                    if_exists,
4741                    names,
4742                    cascade: false,
4743                }))
4744            }
4745            ObjectType::NetworkPolicy => {
4746                let names = self.parse_comma_separated(|parser| {
4747                    Ok(UnresolvedObjectName::NetworkPolicy(
4748                        parser.parse_identifier()?,
4749                    ))
4750                })?;
4751                Ok(Statement::DropObjects(DropObjectsStatement {
4752                    object_type: ObjectType::NetworkPolicy,
4753                    if_exists,
4754                    names,
4755                    cascade: false,
4756                }))
4757            }
4758            ObjectType::Cluster => self.parse_drop_clusters(if_exists),
4759            ObjectType::ClusterReplica => self.parse_drop_cluster_replicas(if_exists),
4760            ObjectType::Table
4761            | ObjectType::View
4762            | ObjectType::MaterializedView
4763            | ObjectType::Source
4764            | ObjectType::Sink
4765            | ObjectType::Index
4766            | ObjectType::Type
4767            | ObjectType::Secret
4768            | ObjectType::Connection
4769            | ObjectType::ContinualTask => {
4770                let names = self.parse_comma_separated(|parser| {
4771                    Ok(UnresolvedObjectName::Item(parser.parse_item_name()?))
4772                })?;
4773                let cascade = matches!(
4774                    self.parse_at_most_one_keyword(&[CASCADE, RESTRICT], "DROP")?,
4775                    Some(CASCADE),
4776                );
4777                Ok(Statement::DropObjects(DropObjectsStatement {
4778                    object_type,
4779                    if_exists,
4780                    names,
4781                    cascade,
4782                }))
4783            }
4784            ObjectType::Func | ObjectType::Subsource => parser_err!(
4785                self,
4786                self.peek_prev_pos(),
4787                format!("Unsupported DROP on {object_type}")
4788            ),
4789        }
4790    }
4791
4792    fn parse_drop_clusters(&mut self, if_exists: bool) -> Result<Statement<Raw>, ParserError> {
4793        let names = self.parse_comma_separated(|parser| {
4794            Ok(UnresolvedObjectName::Cluster(parser.parse_identifier()?))
4795        })?;
4796        let cascade = matches!(
4797            self.parse_at_most_one_keyword(&[CASCADE, RESTRICT], "DROP")?,
4798            Some(CASCADE),
4799        );
4800        Ok(Statement::DropObjects(DropObjectsStatement {
4801            object_type: ObjectType::Cluster,
4802            if_exists,
4803            names,
4804            cascade,
4805        }))
4806    }
4807
4808    fn parse_drop_cluster_replicas(
4809        &mut self,
4810        if_exists: bool,
4811    ) -> Result<Statement<Raw>, ParserError> {
4812        let names = self.parse_comma_separated(|p| {
4813            Ok(UnresolvedObjectName::ClusterReplica(
4814                p.parse_cluster_replica_name()?,
4815            ))
4816        })?;
4817        Ok(Statement::DropObjects(DropObjectsStatement {
4818            object_type: ObjectType::ClusterReplica,
4819            if_exists,
4820            names,
4821            cascade: false,
4822        }))
4823    }
4824
4825    fn parse_drop_owned(&mut self) -> Result<Statement<Raw>, ParserError> {
4826        self.expect_keyword(BY)?;
4827        let role_names = self.parse_comma_separated(Parser::parse_identifier)?;
4828        let cascade = if self.parse_keyword(CASCADE) {
4829            Some(true)
4830        } else if self.parse_keyword(RESTRICT) {
4831            Some(false)
4832        } else {
4833            None
4834        };
4835        Ok(Statement::DropOwned(DropOwnedStatement {
4836            role_names,
4837            cascade,
4838        }))
4839    }
4840
4841    fn parse_cluster_replica_name(&mut self) -> Result<QualifiedReplica, ParserError> {
4842        let cluster = self.parse_identifier()?;
4843        self.expect_token(&Token::Dot)?;
4844        let replica = self.parse_identifier()?;
4845        Ok(QualifiedReplica { cluster, replica })
4846    }
4847
4848    fn parse_alter_network_policy(&mut self) -> Result<Statement<Raw>, ParserError> {
4849        let name = self.parse_identifier()?;
4850        self.expect_keyword(SET)?;
4851        self.expect_token(&Token::LParen)?;
4852        let options = self.parse_comma_separated(Parser::parse_network_policy_option)?;
4853        self.expect_token(&Token::RParen)?;
4854        Ok(Statement::AlterNetworkPolicy(AlterNetworkPolicyStatement {
4855            name,
4856            options,
4857        }))
4858    }
4859
4860    fn parse_create_network_policy(&mut self) -> Result<Statement<Raw>, ParserError> {
4861        self.expect_keywords(&[NETWORK, POLICY])?;
4862        let name = self.parse_identifier()?;
4863        self.expect_token(&Token::LParen)?;
4864        let options = self.parse_comma_separated(Parser::parse_network_policy_option)?;
4865        self.expect_token(&Token::RParen)?;
4866        Ok(Statement::CreateNetworkPolicy(
4867            CreateNetworkPolicyStatement { name, options },
4868        ))
4869    }
4870
4871    fn parse_network_policy_option(&mut self) -> Result<NetworkPolicyOption<Raw>, ParserError> {
4872        let name = match self.expect_one_of_keywords(&[RULES])? {
4873            RULES => NetworkPolicyOptionName::Rules,
4874            v => panic!("found unreachable keyword {}", v),
4875        };
4876        match name {
4877            NetworkPolicyOptionName::Rules => self.parse_network_policy_option_rules(),
4878        }
4879    }
4880
4881    fn parse_network_policy_option_rules(
4882        &mut self,
4883    ) -> Result<NetworkPolicyOption<Raw>, ParserError> {
4884        let _ = self.consume_token(&Token::Eq);
4885        self.expect_token(&Token::LParen)?;
4886        let rules = if self.consume_token(&Token::RParen) {
4887            vec![]
4888        } else {
4889            let rules = self.parse_comma_separated(|parser| {
4890                let name = parser.parse_identifier()?;
4891                parser.expect_token(&Token::LParen)?;
4892                let options =
4893                    parser.parse_comma_separated(Parser::parse_network_policy_rule_option)?;
4894                parser.expect_token(&Token::RParen)?;
4895                Ok(NetworkPolicyRuleDefinition { name, options })
4896            })?;
4897            self.expect_token(&Token::RParen)?;
4898            rules
4899        };
4900        Ok(NetworkPolicyOption {
4901            name: NetworkPolicyOptionName::Rules,
4902            value: Some(WithOptionValue::NetworkPolicyRules(rules)),
4903        })
4904    }
4905
4906    fn parse_network_policy_rule_option(
4907        &mut self,
4908    ) -> Result<NetworkPolicyRuleOption<Raw>, ParserError> {
4909        let name = match self.expect_one_of_keywords(&[ACTION, ADDRESS, DIRECTION])? {
4910            ACTION => NetworkPolicyRuleOptionName::Action,
4911            ADDRESS => NetworkPolicyRuleOptionName::Address,
4912            DIRECTION => NetworkPolicyRuleOptionName::Direction,
4913            v => panic!("found unreachable keyword {}", v),
4914        };
4915        let value = self.parse_optional_option_value()?;
4916        Ok(NetworkPolicyRuleOption { name, value })
4917    }
4918
4919    fn parse_create_table(&mut self) -> Result<Statement<Raw>, ParserError> {
4920        let temporary = self.parse_keyword(TEMPORARY) | self.parse_keyword(TEMP);
4921        self.expect_keyword(TABLE)?;
4922        let if_not_exists = self.parse_if_not_exists()?;
4923        let table_name = self.parse_item_name()?;
4924        // parse optional column list (schema)
4925        let (columns, constraints) = self.parse_columns(Mandatory)?;
4926
4927        let with_options = if self.parse_keyword(WITH) {
4928            self.expect_token(&Token::LParen)?;
4929            let o = if matches!(self.peek_token(), Some(Token::RParen)) {
4930                vec![]
4931            } else {
4932                self.parse_comma_separated(Parser::parse_table_option)?
4933            };
4934            self.expect_token(&Token::RParen)?;
4935            o
4936        } else {
4937            vec![]
4938        };
4939
4940        Ok(Statement::CreateTable(CreateTableStatement {
4941            name: table_name,
4942            columns,
4943            constraints,
4944            if_not_exists,
4945            temporary,
4946            with_options,
4947        }))
4948    }
4949
4950    fn parse_create_table_from_source(&mut self) -> Result<Statement<Raw>, ParserError> {
4951        self.expect_keyword(TABLE)?;
4952        let if_not_exists = self.parse_if_not_exists()?;
4953        let table_name = self.parse_item_name()?;
4954
4955        if self.parse_keywords(&[FROM, WEBHOOK]) {
4956            // Webhook Source, which works differently than all other sources.
4957            return self.parse_create_webhook_source(table_name, if_not_exists, None, true);
4958        }
4959
4960        let (columns, constraints) = self.parse_table_from_source_columns()?;
4961
4962        self.expect_keywords(&[FROM, SOURCE])?;
4963
4964        let source = self.parse_raw_name()?;
4965
4966        let external_reference = if self.consume_token(&Token::LParen) {
4967            self.expect_keyword(REFERENCE)?;
4968            let _ = self.consume_token(&Token::Eq);
4969            let external_reference = self.parse_item_name()?;
4970            self.expect_token(&Token::RParen)?;
4971            Some(external_reference)
4972        } else {
4973            None
4974        };
4975
4976        let format = match self.parse_one_of_keywords(&[KEY, FORMAT]) {
4977            Some(KEY) => {
4978                self.expect_keyword(FORMAT)?;
4979                let key = self.parse_format()?;
4980                self.expect_keywords(&[VALUE, FORMAT])?;
4981                let value = self.parse_format()?;
4982                Some(FormatSpecifier::KeyValue { key, value })
4983            }
4984            Some(FORMAT) => Some(FormatSpecifier::Bare(self.parse_format()?)),
4985            Some(_) => unreachable!("parse_one_of_keywords returns None for this"),
4986            None => None,
4987        };
4988        let include_metadata = self.parse_source_include_metadata()?;
4989
4990        let envelope = if self.parse_keyword(ENVELOPE) {
4991            Some(self.parse_source_envelope()?)
4992        } else {
4993            None
4994        };
4995
4996        let with_options = if self.parse_keyword(WITH) {
4997            self.expect_token(&Token::LParen)?;
4998            let options = self.parse_comma_separated(Parser::parse_table_from_source_option)?;
4999            self.expect_token(&Token::RParen)?;
5000            options
5001        } else {
5002            vec![]
5003        };
5004
5005        Ok(Statement::CreateTableFromSource(
5006            CreateTableFromSourceStatement {
5007                name: table_name,
5008                columns,
5009                constraints,
5010                if_not_exists,
5011                source,
5012                external_reference,
5013                format,
5014                include_metadata,
5015                envelope,
5016                with_options,
5017            },
5018        ))
5019    }
5020
5021    fn parse_table_from_source_option(
5022        &mut self,
5023    ) -> Result<TableFromSourceOption<Raw>, ParserError> {
5024        let option = match self
5025            .expect_one_of_keywords(&[TEXT, EXCLUDE, IGNORE, DETAILS, PARTITION, RETAIN])?
5026        {
5027            ref keyword @ (TEXT | EXCLUDE) => {
5028                self.expect_keyword(COLUMNS)?;
5029
5030                let _ = self.consume_token(&Token::Eq);
5031
5032                let value = self
5033                    .parse_option_sequence(Parser::parse_identifier)?
5034                    .map(|inner| {
5035                        WithOptionValue::Sequence(
5036                            inner.into_iter().map(WithOptionValue::Ident).collect_vec(),
5037                        )
5038                    });
5039
5040                TableFromSourceOption {
5041                    name: match *keyword {
5042                        TEXT => TableFromSourceOptionName::TextColumns,
5043                        EXCLUDE => TableFromSourceOptionName::ExcludeColumns,
5044                        _ => unreachable!(),
5045                    },
5046                    value,
5047                }
5048            }
5049            DETAILS => TableFromSourceOption {
5050                name: TableFromSourceOptionName::Details,
5051                value: self.parse_optional_option_value()?,
5052            },
5053            IGNORE => {
5054                self.expect_keyword(COLUMNS)?;
5055                let _ = self.consume_token(&Token::Eq);
5056
5057                let value = self
5058                    .parse_option_sequence(Parser::parse_identifier)?
5059                    .map(|inner| {
5060                        WithOptionValue::Sequence(
5061                            inner.into_iter().map(WithOptionValue::Ident).collect_vec(),
5062                        )
5063                    });
5064                TableFromSourceOption {
5065                    // IGNORE is historical syntax for this option.
5066                    name: TableFromSourceOptionName::ExcludeColumns,
5067                    value,
5068                }
5069            }
5070            PARTITION => {
5071                self.expect_keyword(BY)?;
5072                TableFromSourceOption {
5073                    name: TableFromSourceOptionName::PartitionBy,
5074                    value: self.parse_optional_option_value()?,
5075                }
5076            }
5077            RETAIN => {
5078                self.expect_keyword(HISTORY)?;
5079                TableFromSourceOption {
5080                    name: TableFromSourceOptionName::RetainHistory,
5081                    value: self.parse_option_retain_history()?,
5082                }
5083            }
5084            _ => unreachable!(),
5085        };
5086        Ok(option)
5087    }
5088
5089    fn parse_table_from_source_columns(
5090        &mut self,
5091    ) -> Result<(TableFromSourceColumns<Raw>, Vec<TableConstraint<Raw>>), ParserError> {
5092        let mut constraints = vec![];
5093
5094        if !self.consume_token(&Token::LParen) {
5095            return Ok((TableFromSourceColumns::NotSpecified, constraints));
5096        }
5097        if self.consume_token(&Token::RParen) {
5098            // Tables with zero columns are a PostgreSQL extension.
5099            return Ok((TableFromSourceColumns::NotSpecified, constraints));
5100        }
5101
5102        let mut column_names = vec![];
5103        let mut column_defs = vec![];
5104        loop {
5105            if let Some(constraint) = self.parse_optional_table_constraint()? {
5106                constraints.push(constraint);
5107            } else if let Some(column_name) = self.consume_identifier()? {
5108                let next_token = self.peek_token();
5109                match next_token {
5110                    Some(Token::Comma) | Some(Token::RParen) => {
5111                        column_names.push(column_name);
5112                    }
5113                    _ => {
5114                        let data_type = self.parse_data_type()?;
5115                        let collation = if self.parse_keyword(COLLATE) {
5116                            Some(self.parse_item_name()?)
5117                        } else {
5118                            None
5119                        };
5120                        let mut options = vec![];
5121                        loop {
5122                            match self.peek_token() {
5123                                None | Some(Token::Comma) | Some(Token::RParen) => break,
5124                                _ => options.push(self.parse_column_option_def()?),
5125                            }
5126                        }
5127
5128                        column_defs.push(ColumnDef {
5129                            name: column_name,
5130                            data_type,
5131                            collation,
5132                            options,
5133                        });
5134                    }
5135                }
5136            } else {
5137                return self.expected(
5138                    self.peek_pos(),
5139                    "column name or constraint definition",
5140                    self.peek_token(),
5141                );
5142            }
5143            if self.consume_token(&Token::Comma) {
5144                // Continue.
5145            } else if self.consume_token(&Token::RParen) {
5146                break;
5147            } else {
5148                return self.expected(
5149                    self.peek_pos(),
5150                    "',' or ')' after column definition",
5151                    self.peek_token(),
5152                );
5153            }
5154        }
5155        if !column_defs.is_empty() && !column_names.is_empty() {
5156            return parser_err!(
5157                self,
5158                self.peek_prev_pos(),
5159                "cannot mix column definitions and column names"
5160            );
5161        }
5162
5163        let columns = match column_defs.is_empty() {
5164            true => match column_names.is_empty() {
5165                true => TableFromSourceColumns::NotSpecified,
5166                false => TableFromSourceColumns::Named(column_names),
5167            },
5168            false => TableFromSourceColumns::Defined(column_defs),
5169        };
5170
5171        Ok((columns, constraints))
5172    }
5173
5174    fn parse_columns(
5175        &mut self,
5176        optional: IsOptional,
5177    ) -> Result<(Vec<ColumnDef<Raw>>, Vec<TableConstraint<Raw>>), ParserError> {
5178        let mut columns = vec![];
5179        let mut constraints = vec![];
5180
5181        if !self.consume_token(&Token::LParen) {
5182            if optional == Optional {
5183                return Ok((columns, constraints));
5184            } else {
5185                return self.expected(
5186                    self.peek_pos(),
5187                    "a list of columns in parentheses",
5188                    self.peek_token(),
5189                );
5190            }
5191        }
5192        if self.consume_token(&Token::RParen) {
5193            // Tables with zero columns are a PostgreSQL extension.
5194            return Ok((columns, constraints));
5195        }
5196
5197        loop {
5198            if let Some(constraint) = self.parse_optional_table_constraint()? {
5199                constraints.push(constraint);
5200            } else if let Some(column_name) = self.consume_identifier()? {
5201                let data_type = self.parse_data_type()?;
5202                let collation = if self.parse_keyword(COLLATE) {
5203                    Some(self.parse_item_name()?)
5204                } else {
5205                    None
5206                };
5207                let mut options = vec![];
5208                loop {
5209                    match self.peek_token() {
5210                        None | Some(Token::Comma) | Some(Token::RParen) => break,
5211                        _ => options.push(self.parse_column_option_def()?),
5212                    }
5213                }
5214
5215                columns.push(ColumnDef {
5216                    name: column_name,
5217                    data_type,
5218                    collation,
5219                    options,
5220                });
5221            } else {
5222                return self.expected(
5223                    self.peek_pos(),
5224                    "column name or constraint definition",
5225                    self.peek_token(),
5226                );
5227            }
5228            if self.consume_token(&Token::Comma) {
5229                // Continue.
5230            } else if self.consume_token(&Token::RParen) {
5231                break;
5232            } else {
5233                return self.expected(
5234                    self.peek_pos(),
5235                    "',' or ')' after column definition",
5236                    self.peek_token(),
5237                );
5238            }
5239        }
5240
5241        Ok((columns, constraints))
5242    }
5243
5244    fn parse_column_option_def(&mut self) -> Result<ColumnOptionDef<Raw>, ParserError> {
5245        let name = if self.parse_keyword(CONSTRAINT) {
5246            Some(self.parse_identifier()?)
5247        } else {
5248            None
5249        };
5250
5251        let option = if self.parse_keywords(&[NOT, NULL]) {
5252            ColumnOption::NotNull
5253        } else if self.parse_keyword(NULL) {
5254            ColumnOption::Null
5255        } else if self.parse_keyword(DEFAULT) {
5256            ColumnOption::Default(self.parse_expr()?)
5257        } else if self.parse_keywords(&[PRIMARY, KEY]) {
5258            ColumnOption::Unique { is_primary: true }
5259        } else if self.parse_keyword(UNIQUE) {
5260            ColumnOption::Unique { is_primary: false }
5261        } else if self.parse_keyword(REFERENCES) {
5262            let foreign_table = self.parse_item_name()?;
5263            let referred_columns = self.parse_parenthesized_column_list(Mandatory)?;
5264            ColumnOption::ForeignKey {
5265                foreign_table,
5266                referred_columns,
5267            }
5268        } else if self.parse_keyword(CHECK) {
5269            self.expect_token(&Token::LParen)?;
5270            let expr = self.parse_expr()?;
5271            self.expect_token(&Token::RParen)?;
5272            ColumnOption::Check(expr)
5273        } else if self.parse_keyword(VERSION) {
5274            self.expect_keyword(ADDED)?;
5275            let action = ColumnVersioned::Added;
5276            let version = self.parse_version()?;
5277
5278            ColumnOption::Versioned { action, version }
5279        } else {
5280            return self.expected(self.peek_pos(), "column option", self.peek_token());
5281        };
5282
5283        Ok(ColumnOptionDef { name, option })
5284    }
5285
5286    fn parse_optional_table_constraint(
5287        &mut self,
5288    ) -> Result<Option<TableConstraint<Raw>>, ParserError> {
5289        let name = if self.parse_keyword(CONSTRAINT) {
5290            Some(self.parse_identifier()?)
5291        } else {
5292            None
5293        };
5294        match self.next_token() {
5295            Some(Token::Keyword(PRIMARY)) => {
5296                self.expect_keyword(KEY)?;
5297                let columns = self.parse_parenthesized_column_list(Mandatory)?;
5298                Ok(Some(TableConstraint::Unique {
5299                    name,
5300                    columns,
5301                    is_primary: true,
5302                    nulls_not_distinct: false,
5303                }))
5304            }
5305            Some(Token::Keyword(UNIQUE)) => {
5306                let nulls_not_distinct = if self.parse_keyword(NULLS) {
5307                    self.expect_keywords(&[NOT, DISTINCT])?;
5308                    true
5309                } else {
5310                    false
5311                };
5312
5313                let columns = self.parse_parenthesized_column_list(Mandatory)?;
5314                Ok(Some(TableConstraint::Unique {
5315                    name,
5316                    columns,
5317                    is_primary: false,
5318                    nulls_not_distinct,
5319                }))
5320            }
5321            Some(Token::Keyword(FOREIGN)) => {
5322                self.expect_keyword(KEY)?;
5323                let columns = self.parse_parenthesized_column_list(Mandatory)?;
5324                self.expect_keyword(REFERENCES)?;
5325                let foreign_table = self.parse_raw_name()?;
5326                let referred_columns = self.parse_parenthesized_column_list(Mandatory)?;
5327                Ok(Some(TableConstraint::ForeignKey {
5328                    name,
5329                    columns,
5330                    foreign_table,
5331                    referred_columns,
5332                }))
5333            }
5334            Some(Token::Keyword(CHECK)) => {
5335                self.expect_token(&Token::LParen)?;
5336                let expr = Box::new(self.parse_expr()?);
5337                self.expect_token(&Token::RParen)?;
5338                Ok(Some(TableConstraint::Check { name, expr }))
5339            }
5340            unexpected => {
5341                if name.is_some() {
5342                    self.expected(
5343                        self.peek_prev_pos(),
5344                        "PRIMARY, UNIQUE, FOREIGN, or CHECK",
5345                        unexpected,
5346                    )
5347                } else {
5348                    self.prev_token();
5349                    Ok(None)
5350                }
5351            }
5352        }
5353    }
5354
5355    fn parse_object_option_value(&mut self) -> Result<WithOptionValue<Raw>, ParserError> {
5356        let _ = self.consume_token(&Token::Eq);
5357        Ok(WithOptionValue::Item(self.parse_raw_name()?))
5358    }
5359
5360    fn parse_optional_option_value(&mut self) -> Result<Option<WithOptionValue<Raw>>, ParserError> {
5361        // The next token might be a value and might not. The only valid things
5362        // that indicate no value would be `)` for end-of-options , `,` for
5363        // another-option, or ';'/nothing for end-of-statement. Either of those
5364        // means there's no value, anything else means we expect a valid value.
5365        match self.peek_token() {
5366            Some(Token::RParen) | Some(Token::Comma) | Some(Token::Semicolon) | None => Ok(None),
5367            _ => {
5368                let _ = self.consume_token(&Token::Eq);
5369                Ok(Some(self.parse_option_value()?))
5370            }
5371        }
5372    }
5373
5374    fn parse_option_sequence<T, F>(&mut self, f: F) -> Result<Option<Vec<T>>, ParserError>
5375    where
5376        F: FnMut(&mut Self) -> Result<T, ParserError>,
5377    {
5378        Ok(if self.consume_token(&Token::LParen) {
5379            let options = if self.consume_token(&Token::RParen) {
5380                vec![]
5381            } else {
5382                let options = self.parse_comma_separated(f)?;
5383                self.expect_token(&Token::RParen)?;
5384                options
5385            };
5386
5387            Some(options)
5388        } else if self.consume_token(&Token::LBracket) {
5389            let options = if self.consume_token(&Token::RBracket) {
5390                vec![]
5391            } else {
5392                let options = self.parse_comma_separated(f)?;
5393
5394                self.expect_token(&Token::RBracket)?;
5395                options
5396            };
5397
5398            Some(options)
5399        } else {
5400            None
5401        })
5402    }
5403
5404    fn parse_option_map(
5405        &mut self,
5406    ) -> Result<Option<BTreeMap<String, WithOptionValue<Raw>>>, ParserError> {
5407        Ok(if self.parse_keyword(MAP) {
5408            self.expect_token(&Token::LBracket)?;
5409            let mut map = BTreeMap::new();
5410            loop {
5411                if let Some(Token::RBracket) = self.peek_token() {
5412                    break;
5413                }
5414                let key = match self.next_token() {
5415                    Some(Token::String(s)) => s,
5416                    token => return self.expected(self.peek_pos(), "string", token),
5417                };
5418                self.expect_token(&Token::Arrow)?;
5419                let value = Parser::parse_option_value(self)?;
5420                map.insert(key, value);
5421                if !self.consume_token(&Token::Comma) {
5422                    break;
5423                }
5424            }
5425            self.expect_token(&Token::RBracket)?;
5426            Some(map)
5427        } else {
5428            None
5429        })
5430    }
5431
5432    fn parse_option_value(&mut self) -> Result<WithOptionValue<Raw>, ParserError> {
5433        if let Some(seq) = self.parse_option_sequence(Parser::parse_option_value)? {
5434            Ok(WithOptionValue::Sequence(seq))
5435        } else if let Some(map) = self.parse_option_map()? {
5436            Ok(WithOptionValue::Map(map))
5437        } else if self.parse_keyword(SECRET) {
5438            if let Some(secret) = self.maybe_parse(Parser::parse_raw_name) {
5439                Ok(WithOptionValue::Secret(secret))
5440            } else {
5441                Ok(WithOptionValue::UnresolvedItemName(UnresolvedItemName(
5442                    vec![ident!("secret")],
5443                )))
5444            }
5445        } else if let Some(value) = self.maybe_parse(Parser::parse_value) {
5446            Ok(WithOptionValue::Value(value))
5447        } else if let Some(item_name) = self.maybe_parse(Parser::parse_item_name) {
5448            Ok(WithOptionValue::UnresolvedItemName(item_name))
5449        } else {
5450            self.expected(self.peek_pos(), "option value", self.peek_token())
5451        }
5452    }
5453
5454    fn parse_data_type_option_value(&mut self) -> Result<WithOptionValue<Raw>, ParserError> {
5455        let _ = self.consume_token(&Token::Eq);
5456        Ok(WithOptionValue::DataType(self.parse_data_type()?))
5457    }
5458
5459    fn parse_alter(&mut self) -> Result<Statement<Raw>, ParserStatementError> {
5460        if self.parse_keyword(SYSTEM) {
5461            self.parse_alter_system()
5462        } else if self.parse_keywords(&[DEFAULT, PRIVILEGES]) {
5463            self.parse_alter_default_privileges()
5464                .map_parser_err(StatementKind::AlterDefaultPrivileges)
5465        } else {
5466            self.parse_alter_object()
5467        }
5468    }
5469
5470    fn parse_alter_object(&mut self) -> Result<Statement<Raw>, ParserStatementError> {
5471        let object_type = self.expect_object_type().map_no_statement_parser_err()?;
5472
5473        match object_type {
5474            ObjectType::Role => self
5475                .parse_alter_role()
5476                .map_parser_err(StatementKind::AlterRole),
5477            ObjectType::Sink => self.parse_alter_sink(),
5478            ObjectType::Source => self.parse_alter_source(),
5479            ObjectType::Index => self.parse_alter_index(),
5480            ObjectType::Secret => self.parse_alter_secret(),
5481            ObjectType::Connection => self.parse_alter_connection(),
5482            ObjectType::View
5483            | ObjectType::MaterializedView
5484            | ObjectType::Table
5485            | ObjectType::ContinualTask => self.parse_alter_views(object_type),
5486            ObjectType::Type => {
5487                let if_exists = self
5488                    .parse_if_exists()
5489                    .map_parser_err(StatementKind::AlterOwner)?;
5490                let name = UnresolvedObjectName::Item(
5491                    self.parse_item_name()
5492                        .map_parser_err(StatementKind::AlterOwner)?,
5493                );
5494                self.expect_keywords(&[OWNER, TO])
5495                    .map_parser_err(StatementKind::AlterOwner)?;
5496                let new_owner = self
5497                    .parse_identifier()
5498                    .map_parser_err(StatementKind::AlterOwner)?;
5499                Ok(Statement::AlterOwner(AlterOwnerStatement {
5500                    object_type,
5501                    if_exists,
5502                    name,
5503                    new_owner,
5504                }))
5505            }
5506            ObjectType::Cluster => self.parse_alter_cluster(object_type),
5507            ObjectType::ClusterReplica => {
5508                let if_exists = self.parse_if_exists().map_no_statement_parser_err()?;
5509                let name = UnresolvedObjectName::ClusterReplica(
5510                    self.parse_cluster_replica_name()
5511                        .map_no_statement_parser_err()?,
5512                );
5513                let action = self
5514                    .expect_one_of_keywords(&[OWNER, RENAME])
5515                    .map_no_statement_parser_err()?;
5516                self.expect_keyword(TO).map_no_statement_parser_err()?;
5517                match action {
5518                    OWNER => {
5519                        let new_owner = self
5520                            .parse_identifier()
5521                            .map_parser_err(StatementKind::AlterOwner)?;
5522                        Ok(Statement::AlterOwner(AlterOwnerStatement {
5523                            object_type,
5524                            if_exists,
5525                            name,
5526                            new_owner,
5527                        }))
5528                    }
5529                    RENAME => {
5530                        let to_item_name = self
5531                            .parse_identifier()
5532                            .map_parser_err(StatementKind::AlterObjectRename)?;
5533                        Ok(Statement::AlterObjectRename(AlterObjectRenameStatement {
5534                            object_type,
5535                            if_exists,
5536                            name,
5537                            to_item_name,
5538                        }))
5539                    }
5540                    _ => unreachable!(),
5541                }
5542            }
5543            ObjectType::Database => {
5544                let if_exists = self
5545                    .parse_if_exists()
5546                    .map_parser_err(StatementKind::AlterOwner)?;
5547                let name = UnresolvedObjectName::Database(
5548                    self.parse_database_name()
5549                        .map_parser_err(StatementKind::AlterOwner)?,
5550                );
5551                self.expect_keywords(&[OWNER, TO])
5552                    .map_parser_err(StatementKind::AlterOwner)?;
5553                let new_owner = self
5554                    .parse_identifier()
5555                    .map_parser_err(StatementKind::AlterOwner)?;
5556                Ok(Statement::AlterOwner(AlterOwnerStatement {
5557                    object_type,
5558                    if_exists,
5559                    name,
5560                    new_owner,
5561                }))
5562            }
5563            ObjectType::Schema => self.parse_alter_schema(object_type),
5564            ObjectType::NetworkPolicy => self
5565                .parse_alter_network_policy()
5566                .map_parser_err(StatementKind::AlterNetworkPolicy),
5567            ObjectType::Func | ObjectType::Subsource => parser_err!(
5568                self,
5569                self.peek_prev_pos(),
5570                format!("Unsupported ALTER on {object_type}")
5571            )
5572            .map_no_statement_parser_err(),
5573        }
5574    }
5575
5576    fn parse_alter_cluster(
5577        &mut self,
5578        object_type: ObjectType,
5579    ) -> Result<Statement<Raw>, ParserStatementError> {
5580        let if_exists = self.parse_if_exists().map_no_statement_parser_err()?;
5581        let name = self.parse_identifier().map_no_statement_parser_err()?;
5582        let action = self
5583            .expect_one_of_keywords(&[OWNER, RENAME, RESET, SET, SWAP])
5584            .map_no_statement_parser_err()?;
5585        match action {
5586            OWNER => {
5587                self.expect_keyword(TO)
5588                    .map_parser_err(StatementKind::AlterOwner)?;
5589                let new_owner = self
5590                    .parse_identifier()
5591                    .map_parser_err(StatementKind::AlterOwner)?;
5592                let name = UnresolvedObjectName::Cluster(name);
5593                Ok(Statement::AlterOwner(AlterOwnerStatement {
5594                    object_type,
5595                    if_exists,
5596                    name,
5597                    new_owner,
5598                }))
5599            }
5600            RENAME => {
5601                self.expect_keyword(TO)
5602                    .map_parser_err(StatementKind::AlterObjectRename)?;
5603                let to_item_name = self
5604                    .parse_identifier()
5605                    .map_parser_err(StatementKind::AlterObjectRename)?;
5606                let name = UnresolvedObjectName::Cluster(name);
5607                Ok(Statement::AlterObjectRename(AlterObjectRenameStatement {
5608                    object_type,
5609                    if_exists,
5610                    name,
5611                    to_item_name,
5612                }))
5613            }
5614            RESET => {
5615                self.expect_token(&Token::LParen)
5616                    .map_parser_err(StatementKind::AlterCluster)?;
5617                let names = self
5618                    .parse_comma_separated(Parser::parse_cluster_option_name)
5619                    .map_parser_err(StatementKind::AlterCluster)?;
5620                self.expect_token(&Token::RParen)
5621                    .map_parser_err(StatementKind::AlterCluster)?;
5622                Ok(Statement::AlterCluster(AlterClusterStatement {
5623                    if_exists,
5624                    name,
5625                    action: AlterClusterAction::ResetOptions(names),
5626                }))
5627            }
5628            SET => {
5629                self.expect_token(&Token::LParen)
5630                    .map_parser_err(StatementKind::AlterCluster)?;
5631                let options = self
5632                    .parse_comma_separated(Parser::parse_cluster_option)
5633                    .map_parser_err(StatementKind::AlterCluster)?;
5634                self.expect_token(&Token::RParen)
5635                    .map_parser_err(StatementKind::AlterCluster)?;
5636                let with_options = if self.parse_keyword(WITH) {
5637                    self.expect_token(&Token::LParen)
5638                        .map_parser_err(StatementKind::AlterCluster)?;
5639                    let options = self
5640                        .parse_comma_separated(Parser::parse_alter_cluster_option)
5641                        .map_parser_err(StatementKind::AlterCluster)?;
5642                    self.expect_token(&Token::RParen)
5643                        .map_parser_err(StatementKind::AlterCluster)?;
5644                    options
5645                } else {
5646                    vec![]
5647                };
5648                Ok(Statement::AlterCluster(AlterClusterStatement {
5649                    if_exists,
5650                    name,
5651                    action: AlterClusterAction::SetOptions {
5652                        options,
5653                        with_options,
5654                    },
5655                }))
5656            }
5657            SWAP => {
5658                self.expect_keyword(WITH)
5659                    .map_parser_err(StatementKind::AlterObjectSwap)?;
5660                let name_b = self
5661                    .parse_identifier()
5662                    .map_parser_err(StatementKind::AlterObjectSwap)?;
5663
5664                Ok(Statement::AlterObjectSwap(AlterObjectSwapStatement {
5665                    object_type,
5666                    name_a: UnresolvedObjectName::Cluster(name),
5667                    name_b,
5668                }))
5669            }
5670            _ => unreachable!(),
5671        }
5672    }
5673
5674    fn parse_alter_source(&mut self) -> Result<Statement<Raw>, ParserStatementError> {
5675        let if_exists = self.parse_if_exists().map_no_statement_parser_err()?;
5676        let source_name = self.parse_item_name().map_no_statement_parser_err()?;
5677
5678        Ok(
5679            match self
5680                .expect_one_of_keywords(&[ADD, DROP, RESET, SET, RENAME, OWNER, REFRESH])
5681                .map_no_statement_parser_err()?
5682            {
5683                ADD => {
5684                    self.expect_one_of_keywords(&[SUBSOURCE, TABLE])
5685                        .map_parser_err(StatementKind::AlterSource)?;
5686
5687                    // TODO: Add IF NOT EXISTS?
5688                    let subsources = self
5689                        .parse_comma_separated(Parser::parse_subsource_references)
5690                        .map_parser_err(StatementKind::AlterSource)?;
5691
5692                    let options = if self.parse_keyword(WITH) {
5693                        self.expect_token(&Token::LParen)
5694                            .map_parser_err(StatementKind::AlterSource)?;
5695                        let options = self
5696                            .parse_comma_separated(Parser::parse_alter_source_add_subsource_option)
5697                            .map_parser_err(StatementKind::AlterSource)?;
5698                        self.expect_token(&Token::RParen)
5699                            .map_parser_err(StatementKind::AlterSource)?;
5700                        options
5701                    } else {
5702                        vec![]
5703                    };
5704
5705                    Statement::AlterSource(AlterSourceStatement {
5706                        source_name,
5707                        if_exists,
5708                        action: AlterSourceAction::AddSubsources {
5709                            external_references: subsources,
5710                            options,
5711                        },
5712                    })
5713                }
5714                DROP => {
5715                    self.expect_one_of_keywords(&[SUBSOURCE, TABLE])
5716                        .map_parser_err(StatementKind::AlterSource)?;
5717
5718                    let if_exists_inner = self
5719                        .parse_if_exists()
5720                        .map_parser_err(StatementKind::AlterSource)?;
5721
5722                    let names = self
5723                        .parse_comma_separated(Parser::parse_item_name)
5724                        .map_parser_err(StatementKind::AlterSource)?;
5725
5726                    let cascade = matches!(
5727                        self.parse_at_most_one_keyword(&[CASCADE, RESTRICT], "ALTER SOURCE...DROP")
5728                            .map_parser_err(StatementKind::AlterSource)?,
5729                        Some(CASCADE),
5730                    );
5731
5732                    Statement::AlterSource(AlterSourceStatement {
5733                        source_name,
5734                        if_exists,
5735                        action: AlterSourceAction::DropSubsources {
5736                            if_exists: if_exists_inner,
5737                            cascade,
5738                            names,
5739                        },
5740                    })
5741                }
5742                RESET => {
5743                    self.expect_token(&Token::LParen)
5744                        .map_parser_err(StatementKind::AlterSource)?;
5745                    let reset_options = self
5746                        .parse_comma_separated(Parser::parse_source_option_name)
5747                        .map_parser_err(StatementKind::AlterSource)?;
5748                    self.expect_token(&Token::RParen)
5749                        .map_parser_err(StatementKind::AlterSource)?;
5750
5751                    Statement::AlterSource(AlterSourceStatement {
5752                        source_name,
5753                        if_exists,
5754                        action: AlterSourceAction::ResetOptions(reset_options),
5755                    })
5756                }
5757                SET => {
5758                    if let Some(stmt) = self.maybe_parse_alter_set_cluster(
5759                        if_exists,
5760                        &source_name,
5761                        ObjectType::Source,
5762                    ) {
5763                        return stmt;
5764                    }
5765                    self.expect_token(&Token::LParen)
5766                        .map_parser_err(StatementKind::AlterSource)?;
5767                    let set_options = self
5768                        .parse_comma_separated(Parser::parse_source_option)
5769                        .map_parser_err(StatementKind::AlterSource)?;
5770                    self.expect_token(&Token::RParen)
5771                        .map_parser_err(StatementKind::AlterSource)?;
5772                    Statement::AlterSource(AlterSourceStatement {
5773                        source_name,
5774                        if_exists,
5775                        action: AlterSourceAction::SetOptions(set_options),
5776                    })
5777                }
5778                RENAME => {
5779                    self.expect_keyword(TO)
5780                        .map_parser_err(StatementKind::AlterObjectRename)?;
5781                    let to_item_name = self
5782                        .parse_identifier()
5783                        .map_parser_err(StatementKind::AlterObjectRename)?;
5784
5785                    Statement::AlterObjectRename(AlterObjectRenameStatement {
5786                        object_type: ObjectType::Source,
5787                        if_exists,
5788                        name: UnresolvedObjectName::Item(source_name),
5789                        to_item_name,
5790                    })
5791                }
5792                OWNER => {
5793                    self.expect_keyword(TO)
5794                        .map_parser_err(StatementKind::AlterOwner)?;
5795                    let new_owner = self
5796                        .parse_identifier()
5797                        .map_parser_err(StatementKind::AlterOwner)?;
5798
5799                    Statement::AlterOwner(AlterOwnerStatement {
5800                        object_type: ObjectType::Source,
5801                        if_exists,
5802                        name: UnresolvedObjectName::Item(source_name),
5803                        new_owner,
5804                    })
5805                }
5806                REFRESH => {
5807                    self.expect_keyword(REFERENCES)
5808                        .map_parser_err(StatementKind::AlterSource)?;
5809                    Statement::AlterSource(AlterSourceStatement {
5810                        source_name,
5811                        if_exists,
5812                        action: AlterSourceAction::RefreshReferences,
5813                    })
5814                }
5815                _ => unreachable!(),
5816            },
5817        )
5818    }
5819
5820    fn parse_alter_source_add_subsource_option(
5821        &mut self,
5822    ) -> Result<AlterSourceAddSubsourceOption<Raw>, ParserError> {
5823        match self.expect_one_of_keywords(&[TEXT, EXCLUDE, IGNORE])? {
5824            ref keyword @ (TEXT | EXCLUDE | IGNORE) => {
5825                self.expect_keyword(COLUMNS)?;
5826
5827                let _ = self.consume_token(&Token::Eq);
5828
5829                let value = self
5830                    .parse_option_sequence(Parser::parse_item_name)?
5831                    .map(|inner| {
5832                        WithOptionValue::Sequence(
5833                            inner
5834                                .into_iter()
5835                                .map(WithOptionValue::UnresolvedItemName)
5836                                .collect_vec(),
5837                        )
5838                    });
5839
5840                Ok(AlterSourceAddSubsourceOption {
5841                    name: match *keyword {
5842                        TEXT => AlterSourceAddSubsourceOptionName::TextColumns,
5843                        // IGNORE is historical syntax for this option.
5844                        EXCLUDE | IGNORE => AlterSourceAddSubsourceOptionName::ExcludeColumns,
5845                        _ => unreachable!(),
5846                    },
5847                    value,
5848                })
5849            }
5850            _ => unreachable!(),
5851        }
5852    }
5853
5854    fn parse_alter_index(&mut self) -> Result<Statement<Raw>, ParserStatementError> {
5855        let if_exists = self.parse_if_exists().map_no_statement_parser_err()?;
5856        let name = self.parse_item_name().map_no_statement_parser_err()?;
5857
5858        Ok(
5859            match self
5860                .expect_one_of_keywords(&[RESET, SET, RENAME, OWNER])
5861                .map_no_statement_parser_err()?
5862            {
5863                RESET => {
5864                    self.expect_token(&Token::LParen)
5865                        .map_parser_err(StatementKind::AlterIndex)?;
5866                    let reset_options = self
5867                        .parse_comma_separated(Parser::parse_index_option_name)
5868                        .map_parser_err(StatementKind::AlterIndex)?;
5869                    self.expect_token(&Token::RParen)
5870                        .map_parser_err(StatementKind::AlterIndex)?;
5871
5872                    Statement::AlterIndex(AlterIndexStatement {
5873                        index_name: name,
5874                        if_exists,
5875                        action: AlterIndexAction::ResetOptions(reset_options),
5876                    })
5877                }
5878                SET => {
5879                    self.expect_token(&Token::LParen)
5880                        .map_parser_err(StatementKind::AlterIndex)?;
5881                    let set_options = self
5882                        .parse_comma_separated(Parser::parse_index_option)
5883                        .map_parser_err(StatementKind::AlterIndex)?;
5884                    self.expect_token(&Token::RParen)
5885                        .map_parser_err(StatementKind::AlterIndex)?;
5886                    Statement::AlterIndex(AlterIndexStatement {
5887                        index_name: name,
5888                        if_exists,
5889                        action: AlterIndexAction::SetOptions(set_options),
5890                    })
5891                }
5892                RENAME => {
5893                    self.expect_keyword(TO)
5894                        .map_parser_err(StatementKind::AlterObjectRename)?;
5895                    let to_item_name = self
5896                        .parse_identifier()
5897                        .map_parser_err(StatementKind::AlterObjectRename)?;
5898
5899                    Statement::AlterObjectRename(AlterObjectRenameStatement {
5900                        object_type: ObjectType::Index,
5901                        if_exists,
5902                        name: UnresolvedObjectName::Item(name),
5903                        to_item_name,
5904                    })
5905                }
5906                OWNER => {
5907                    self.expect_keyword(TO)
5908                        .map_parser_err(StatementKind::AlterOwner)?;
5909                    let new_owner = self
5910                        .parse_identifier()
5911                        .map_parser_err(StatementKind::AlterOwner)?;
5912
5913                    Statement::AlterOwner(AlterOwnerStatement {
5914                        object_type: ObjectType::Index,
5915                        if_exists,
5916                        name: UnresolvedObjectName::Item(name),
5917                        new_owner,
5918                    })
5919                }
5920                _ => unreachable!(),
5921            },
5922        )
5923    }
5924
5925    fn parse_alter_secret(&mut self) -> Result<Statement<Raw>, ParserStatementError> {
5926        let if_exists = self.parse_if_exists().map_no_statement_parser_err()?;
5927        let name = self.parse_item_name().map_no_statement_parser_err()?;
5928
5929        Ok(
5930            match self
5931                .expect_one_of_keywords(&[AS, RENAME, OWNER])
5932                .map_no_statement_parser_err()?
5933            {
5934                AS => {
5935                    let value = self
5936                        .parse_expr()
5937                        .map_parser_err(StatementKind::AlterSecret)?;
5938                    Statement::AlterSecret(AlterSecretStatement {
5939                        name,
5940                        if_exists,
5941                        value,
5942                    })
5943                }
5944                RENAME => {
5945                    self.expect_keyword(TO)
5946                        .map_parser_err(StatementKind::AlterObjectRename)?;
5947                    let to_item_name = self
5948                        .parse_identifier()
5949                        .map_parser_err(StatementKind::AlterObjectRename)?;
5950
5951                    Statement::AlterObjectRename(AlterObjectRenameStatement {
5952                        object_type: ObjectType::Secret,
5953                        if_exists,
5954                        name: UnresolvedObjectName::Item(name),
5955                        to_item_name,
5956                    })
5957                }
5958                OWNER => {
5959                    self.expect_keyword(TO)
5960                        .map_parser_err(StatementKind::AlterOwner)?;
5961                    let new_owner = self
5962                        .parse_identifier()
5963                        .map_parser_err(StatementKind::AlterOwner)?;
5964
5965                    Statement::AlterOwner(AlterOwnerStatement {
5966                        object_type: ObjectType::Secret,
5967                        if_exists,
5968                        name: UnresolvedObjectName::Item(name),
5969                        new_owner,
5970                    })
5971                }
5972                _ => unreachable!(),
5973            },
5974        )
5975    }
5976
5977    /// Parse an ALTER SINK statement.
5978    fn parse_alter_sink(&mut self) -> Result<Statement<Raw>, ParserStatementError> {
5979        let if_exists = self.parse_if_exists().map_no_statement_parser_err()?;
5980        let name = self.parse_item_name().map_no_statement_parser_err()?;
5981
5982        Ok(
5983            match self
5984                .expect_one_of_keywords(&[RESET, SET, RENAME, OWNER])
5985                .map_no_statement_parser_err()?
5986            {
5987                RESET => {
5988                    self.expect_token(&Token::LParen)
5989                        .map_parser_err(StatementKind::AlterSink)?;
5990                    let reset_options = self
5991                        .parse_comma_separated(Parser::parse_create_sink_option_name)
5992                        .map_parser_err(StatementKind::AlterSink)?;
5993                    self.expect_token(&Token::RParen)
5994                        .map_parser_err(StatementKind::AlterSink)?;
5995
5996                    Statement::AlterSink(AlterSinkStatement {
5997                        sink_name: name,
5998                        if_exists,
5999                        action: AlterSinkAction::ResetOptions(reset_options),
6000                    })
6001                }
6002                SET => {
6003                    if let Some(result) =
6004                        self.maybe_parse_alter_set_cluster(if_exists, &name, ObjectType::Sink)
6005                    {
6006                        return result;
6007                    }
6008
6009                    if self.parse_keyword(FROM) {
6010                        let from = self
6011                            .parse_raw_name()
6012                            .map_parser_err(StatementKind::AlterSink)?;
6013
6014                        Statement::AlterSink(AlterSinkStatement {
6015                            sink_name: name,
6016                            if_exists,
6017                            action: AlterSinkAction::ChangeRelation(from),
6018                        })
6019                    } else {
6020                        self.expect_token(&Token::LParen)
6021                            .map_parser_err(StatementKind::AlterSink)?;
6022                        let set_options = self
6023                            .parse_comma_separated(Parser::parse_create_sink_option)
6024                            .map_parser_err(StatementKind::AlterSink)?;
6025                        self.expect_token(&Token::RParen)
6026                            .map_parser_err(StatementKind::AlterSink)?;
6027                        Statement::AlterSink(AlterSinkStatement {
6028                            sink_name: name,
6029                            if_exists,
6030                            action: AlterSinkAction::SetOptions(set_options),
6031                        })
6032                    }
6033                }
6034                RENAME => {
6035                    self.expect_keyword(TO)
6036                        .map_parser_err(StatementKind::AlterObjectRename)?;
6037                    let to_item_name = self
6038                        .parse_identifier()
6039                        .map_parser_err(StatementKind::AlterObjectRename)?;
6040
6041                    Statement::AlterObjectRename(AlterObjectRenameStatement {
6042                        object_type: ObjectType::Sink,
6043                        if_exists,
6044                        name: UnresolvedObjectName::Item(name),
6045                        to_item_name,
6046                    })
6047                }
6048                OWNER => {
6049                    self.expect_keyword(TO)
6050                        .map_parser_err(StatementKind::AlterOwner)?;
6051                    let new_owner = self
6052                        .parse_identifier()
6053                        .map_parser_err(StatementKind::AlterOwner)?;
6054
6055                    Statement::AlterOwner(AlterOwnerStatement {
6056                        object_type: ObjectType::Sink,
6057                        if_exists,
6058                        name: UnresolvedObjectName::Item(name),
6059                        new_owner,
6060                    })
6061                }
6062                _ => unreachable!(),
6063            },
6064        )
6065    }
6066
6067    /// Parse an ALTER SYSTEM statement.
6068    fn parse_alter_system(&mut self) -> Result<Statement<Raw>, ParserStatementError> {
6069        match self
6070            .expect_one_of_keywords(&[SET, RESET])
6071            .map_no_statement_parser_err()?
6072        {
6073            SET => {
6074                let name = self
6075                    .parse_identifier()
6076                    .map_parser_err(StatementKind::AlterSystemSet)?;
6077                self.expect_keyword_or_token(TO, &Token::Eq)
6078                    .map_parser_err(StatementKind::AlterSystemSet)?;
6079                let to = self
6080                    .parse_set_variable_to()
6081                    .map_parser_err(StatementKind::AlterSystemSet)?;
6082                Ok(Statement::AlterSystemSet(AlterSystemSetStatement {
6083                    name,
6084                    to,
6085                }))
6086            }
6087            RESET => {
6088                if self.parse_keyword(ALL) {
6089                    Ok(Statement::AlterSystemResetAll(
6090                        AlterSystemResetAllStatement {},
6091                    ))
6092                } else {
6093                    let name = self
6094                        .parse_identifier()
6095                        .map_parser_err(StatementKind::AlterSystemReset)?;
6096                    Ok(Statement::AlterSystemReset(AlterSystemResetStatement {
6097                        name,
6098                    }))
6099                }
6100            }
6101            _ => unreachable!(),
6102        }
6103    }
6104
6105    fn parse_alter_connection(&mut self) -> Result<Statement<Raw>, ParserStatementError> {
6106        let if_exists = self.parse_if_exists().map_no_statement_parser_err()?;
6107        let name = self.parse_item_name().map_no_statement_parser_err()?;
6108
6109        Ok(
6110            match self
6111                .expect_one_of_keywords(&[RENAME, OWNER, ROTATE, SET, RESET, DROP])
6112                .map_no_statement_parser_err()?
6113            {
6114                RENAME => {
6115                    self.expect_keyword(TO)
6116                        .map_parser_err(StatementKind::AlterObjectRename)?;
6117                    let to_item_name = self
6118                        .parse_identifier()
6119                        .map_parser_err(StatementKind::AlterObjectRename)?;
6120
6121                    Statement::AlterObjectRename(AlterObjectRenameStatement {
6122                        object_type: ObjectType::Connection,
6123                        if_exists,
6124                        name: UnresolvedObjectName::Item(name),
6125                        to_item_name,
6126                    })
6127                }
6128                OWNER => {
6129                    self.expect_keyword(TO)
6130                        .map_parser_err(StatementKind::AlterOwner)?;
6131                    let new_owner = self
6132                        .parse_identifier()
6133                        .map_parser_err(StatementKind::AlterOwner)?;
6134
6135                    Statement::AlterOwner(AlterOwnerStatement {
6136                        object_type: ObjectType::Connection,
6137                        if_exists,
6138                        name: UnresolvedObjectName::Item(name),
6139                        new_owner,
6140                    })
6141                }
6142                _ => {
6143                    self.prev_token();
6144                    let actions = self
6145                        .parse_comma_separated(Parser::parse_alter_connection_action)
6146                        .map_parser_err(StatementKind::AlterConnection)?;
6147
6148                    let with_options = if self.parse_keyword(WITH) {
6149                        self.expect_token(&Token::LParen)
6150                            .map_parser_err(StatementKind::AlterConnection)?;
6151                        let options = self
6152                            .parse_comma_separated(Parser::parse_alter_connection_option)
6153                            .map_parser_err(StatementKind::AlterConnection)?;
6154                        self.expect_token(&Token::RParen)
6155                            .map_parser_err(StatementKind::AlterConnection)?;
6156                        options
6157                    } else {
6158                        vec![]
6159                    };
6160
6161                    Statement::AlterConnection(AlterConnectionStatement {
6162                        name,
6163                        if_exists,
6164                        actions,
6165                        with_options,
6166                    })
6167                }
6168            },
6169        )
6170    }
6171
6172    fn parse_alter_connection_action(&mut self) -> Result<AlterConnectionAction<Raw>, ParserError> {
6173        let r = match self.expect_one_of_keywords(&[ROTATE, SET, RESET, DROP])? {
6174            ROTATE => {
6175                self.expect_keyword(KEYS)?;
6176                AlterConnectionAction::RotateKeys
6177            }
6178            SET => {
6179                self.expect_token(&Token::LParen)?;
6180                let option = self.parse_connection_option_unified()?;
6181                self.expect_token(&Token::RParen)?;
6182                AlterConnectionAction::SetOption(option)
6183            }
6184            DROP | RESET => {
6185                self.expect_token(&Token::LParen)?;
6186                let option = self.parse_connection_option_name()?;
6187                self.expect_token(&Token::RParen)?;
6188                AlterConnectionAction::DropOption(option)
6189            }
6190            _ => unreachable!(),
6191        };
6192
6193        Ok(r)
6194    }
6195
6196    /// Parses a single valid option in the WITH block of a create source
6197    fn parse_alter_connection_option(&mut self) -> Result<AlterConnectionOption<Raw>, ParserError> {
6198        let name = match self.expect_one_of_keywords(&[VALIDATE])? {
6199            VALIDATE => AlterConnectionOptionName::Validate,
6200            _ => unreachable!(),
6201        };
6202
6203        Ok(AlterConnectionOption {
6204            name,
6205            value: self.parse_optional_option_value()?,
6206        })
6207    }
6208
6209    fn parse_alter_role(&mut self) -> Result<Statement<Raw>, ParserError> {
6210        let name = self.parse_identifier()?;
6211
6212        let option = match self.parse_one_of_keywords(&[SET, RESET, WITH]) {
6213            Some(SET) => {
6214                let name = self.parse_identifier()?;
6215                self.expect_keyword_or_token(TO, &Token::Eq)?;
6216                let value = self.parse_set_variable_to()?;
6217                let var = SetRoleVar::Set { name, value };
6218                AlterRoleOption::Variable(var)
6219            }
6220            Some(RESET) => {
6221                let name = self.parse_identifier()?;
6222                let var = SetRoleVar::Reset { name };
6223                AlterRoleOption::Variable(var)
6224            }
6225            Some(WITH) | None => {
6226                let _ = self.parse_keyword(WITH);
6227                let attrs = self.parse_role_attributes()?;
6228                AlterRoleOption::Attributes(attrs)
6229            }
6230            Some(k) => unreachable!("unmatched keyword: {k}"),
6231        };
6232
6233        Ok(Statement::AlterRole(AlterRoleStatement { name, option }))
6234    }
6235
6236    fn parse_alter_default_privileges(&mut self) -> Result<Statement<Raw>, ParserError> {
6237        self.expect_keyword(FOR)?;
6238        let target_roles = match self.expect_one_of_keywords(&[ROLE, USER, ALL])? {
6239            ROLE | USER => TargetRoleSpecification::Roles(
6240                self.parse_comma_separated(Parser::parse_identifier)?,
6241            ),
6242            ALL => {
6243                self.expect_keyword(ROLES)?;
6244                TargetRoleSpecification::AllRoles
6245            }
6246            _ => unreachable!(),
6247        };
6248        let target_objects = if self.parse_keyword(IN) {
6249            match self.expect_one_of_keywords(&[SCHEMA, DATABASE])? {
6250                SCHEMA => GrantTargetAllSpecification::AllSchemas {
6251                    schemas: self.parse_comma_separated(Parser::parse_schema_name)?,
6252                },
6253                DATABASE => GrantTargetAllSpecification::AllDatabases {
6254                    databases: self.parse_comma_separated(Parser::parse_database_name)?,
6255                },
6256                _ => unreachable!(),
6257            }
6258        } else {
6259            GrantTargetAllSpecification::All
6260        };
6261        let is_grant = self.expect_one_of_keywords(&[GRANT, REVOKE])? == GRANT;
6262        let privileges = self.parse_privilege_specification().ok_or_else(|| {
6263            self.expected::<_, PrivilegeSpecification>(
6264                self.peek_pos(),
6265                "ALL or INSERT or SELECT or UPDATE or DELETE or USAGE or CREATE",
6266                self.peek_token(),
6267            )
6268            .expect_err("only returns errors")
6269        })?;
6270        self.expect_keyword(ON)?;
6271        let object_type =
6272            self.expect_grant_revoke_plural_object_type(if is_grant { "GRANT" } else { "REVOKE" })?;
6273        if is_grant {
6274            self.expect_keyword(TO)?;
6275        } else {
6276            self.expect_keyword(FROM)?;
6277        }
6278        let grantees = self.parse_comma_separated(Parser::expect_role_specification)?;
6279
6280        let grant_or_revoke = if is_grant {
6281            AbbreviatedGrantOrRevokeStatement::Grant(AbbreviatedGrantStatement {
6282                privileges,
6283                object_type,
6284                grantees,
6285            })
6286        } else {
6287            AbbreviatedGrantOrRevokeStatement::Revoke(AbbreviatedRevokeStatement {
6288                privileges,
6289                object_type,
6290                revokees: grantees,
6291            })
6292        };
6293
6294        Ok(Statement::AlterDefaultPrivileges(
6295            AlterDefaultPrivilegesStatement {
6296                target_roles,
6297                target_objects,
6298                grant_or_revoke,
6299            },
6300        ))
6301    }
6302
6303    fn parse_alter_views(
6304        &mut self,
6305        object_type: ObjectType,
6306    ) -> Result<Statement<Raw>, ParserStatementError> {
6307        let if_exists = self.parse_if_exists().map_no_statement_parser_err()?;
6308        let name = self.parse_item_name().map_no_statement_parser_err()?;
6309        let keywords = if object_type == ObjectType::Table {
6310            [SET, RENAME, OWNER, RESET, ADD].as_slice()
6311        } else {
6312            [SET, RENAME, OWNER, RESET].as_slice()
6313        };
6314
6315        let action = self
6316            .expect_one_of_keywords(keywords)
6317            .map_no_statement_parser_err()?;
6318        match action {
6319            RENAME => {
6320                self.expect_keyword(TO).map_no_statement_parser_err()?;
6321                let to_item_name = self
6322                    .parse_identifier()
6323                    .map_parser_err(StatementKind::AlterObjectRename)?;
6324                Ok(Statement::AlterObjectRename(AlterObjectRenameStatement {
6325                    object_type,
6326                    if_exists,
6327                    name: UnresolvedObjectName::Item(name),
6328                    to_item_name,
6329                }))
6330            }
6331            SET => {
6332                if self.parse_keyword(CLUSTER) {
6333                    self.parse_alter_set_cluster(if_exists, name, object_type)
6334                } else {
6335                    self.expect_token(&Token::LParen)
6336                        .map_no_statement_parser_err()?;
6337                    self.expect_keywords(&[RETAIN, HISTORY])
6338                        .map_parser_err(StatementKind::AlterRetainHistory)?;
6339                    let history = self
6340                        .parse_retain_history()
6341                        .map_parser_err(StatementKind::AlterRetainHistory)?;
6342                    self.expect_token(&Token::RParen)
6343                        .map_parser_err(StatementKind::AlterCluster)?;
6344                    Ok(Statement::AlterRetainHistory(AlterRetainHistoryStatement {
6345                        object_type,
6346                        if_exists,
6347                        name: UnresolvedObjectName::Item(name),
6348                        history: Some(history),
6349                    }))
6350                }
6351            }
6352            RESET => {
6353                self.expect_token(&Token::LParen)
6354                    .map_no_statement_parser_err()?;
6355                self.expect_keywords(&[RETAIN, HISTORY])
6356                    .map_parser_err(StatementKind::AlterRetainHistory)?;
6357                self.expect_token(&Token::RParen)
6358                    .map_no_statement_parser_err()?;
6359                Ok(Statement::AlterRetainHistory(AlterRetainHistoryStatement {
6360                    object_type,
6361                    if_exists,
6362                    name: UnresolvedObjectName::Item(name),
6363                    history: None,
6364                }))
6365            }
6366            OWNER => {
6367                self.expect_keyword(TO).map_no_statement_parser_err()?;
6368                let new_owner = self
6369                    .parse_identifier()
6370                    .map_parser_err(StatementKind::AlterOwner)?;
6371                Ok(Statement::AlterOwner(AlterOwnerStatement {
6372                    object_type,
6373                    if_exists,
6374                    name: UnresolvedObjectName::Item(name),
6375                    new_owner,
6376                }))
6377            }
6378            ADD => {
6379                assert_eq!(object_type, ObjectType::Table, "checked object_type above");
6380
6381                self.expect_keyword(COLUMN)
6382                    .map_parser_err(StatementKind::AlterTableAddColumn)?;
6383                let if_col_not_exist = self
6384                    .parse_if_not_exists()
6385                    .map_parser_err(StatementKind::AlterTableAddColumn)?;
6386                let column_name = self
6387                    .parse_identifier()
6388                    .map_parser_err(StatementKind::AlterTableAddColumn)?;
6389                let data_type = self
6390                    .parse_data_type()
6391                    .map_parser_err(StatementKind::AlterTableAddColumn)?;
6392
6393                Ok(Statement::AlterTableAddColumn(
6394                    AlterTableAddColumnStatement {
6395                        if_exists,
6396                        name,
6397                        if_col_not_exist,
6398                        column_name,
6399                        data_type,
6400                    },
6401                ))
6402            }
6403            _ => unreachable!(),
6404        }
6405    }
6406
6407    fn parse_alter_schema(
6408        &mut self,
6409        object_type: ObjectType,
6410    ) -> Result<Statement<Raw>, ParserStatementError> {
6411        let if_exists = self.parse_if_exists().map_no_statement_parser_err()?;
6412        let name = self.parse_schema_name().map_no_statement_parser_err()?;
6413        let name = UnresolvedObjectName::Schema(name);
6414        let action = self
6415            .expect_one_of_keywords(&[OWNER, RENAME, SWAP])
6416            .map_no_statement_parser_err()?;
6417
6418        match action {
6419            OWNER => {
6420                self.expect_keyword(TO)
6421                    .map_parser_err(StatementKind::AlterOwner)?;
6422                let new_owner = self
6423                    .parse_identifier()
6424                    .map_parser_err(StatementKind::AlterOwner)?;
6425
6426                Ok(Statement::AlterOwner(AlterOwnerStatement {
6427                    object_type,
6428                    if_exists,
6429                    name,
6430                    new_owner,
6431                }))
6432            }
6433            RENAME => {
6434                self.expect_keyword(TO)
6435                    .map_parser_err(StatementKind::AlterObjectRename)?;
6436                let to_item_name = self
6437                    .parse_identifier()
6438                    .map_parser_err(StatementKind::AlterObjectRename)?;
6439
6440                Ok(Statement::AlterObjectRename(AlterObjectRenameStatement {
6441                    object_type,
6442                    if_exists,
6443                    name,
6444                    to_item_name,
6445                }))
6446            }
6447            SWAP => {
6448                self.expect_keyword(WITH)
6449                    .map_parser_err(StatementKind::AlterObjectSwap)?;
6450                let name_b = self
6451                    .parse_identifier()
6452                    .map_parser_err(StatementKind::AlterObjectSwap)?;
6453
6454                Ok(Statement::AlterObjectSwap(AlterObjectSwapStatement {
6455                    object_type,
6456                    name_a: name,
6457                    name_b,
6458                }))
6459            }
6460            k => unreachable!("programming error, unmatched {k}"),
6461        }
6462    }
6463
6464    /// Parses `CLUSTER name` fragments into a [`AlterSetClusterStatement`] if `CLUSTER` is found.
6465    fn maybe_parse_alter_set_cluster(
6466        &mut self,
6467        if_exists: bool,
6468        name: &UnresolvedItemName,
6469        object_type: ObjectType,
6470    ) -> Option<Result<Statement<Raw>, ParserStatementError>> {
6471        if self.parse_keyword(CLUSTER) {
6472            Some(self.parse_alter_set_cluster(if_exists, name.clone(), object_type))
6473        } else {
6474            None
6475        }
6476    }
6477
6478    /// Parses `IN CLUSTER name` fragments into a [`AlterSetClusterStatement`].
6479    fn parse_alter_set_cluster(
6480        &mut self,
6481        if_exists: bool,
6482        name: UnresolvedItemName,
6483        object_type: ObjectType,
6484    ) -> Result<Statement<Raw>, ParserStatementError> {
6485        let set_cluster = self
6486            .parse_raw_ident()
6487            .map_parser_err(StatementKind::AlterSetCluster)?;
6488        Ok(Statement::AlterSetCluster(AlterSetClusterStatement {
6489            name,
6490            if_exists,
6491            set_cluster,
6492            object_type,
6493        }))
6494    }
6495
6496    /// Parse a copy statement
6497    fn parse_copy(&mut self) -> Result<Statement<Raw>, ParserStatementError> {
6498        // We support an optional "INTO" keyword for COPY INTO <table> FROM
6499        let maybe_into_pos = if self.parse_keyword(Keyword::Into) {
6500            Some(self.peek_prev_pos())
6501        } else {
6502            None
6503        };
6504
6505        let relation = if self.consume_token(&Token::LParen) {
6506            let query = self.parse_statement()?.ast;
6507            self.expect_token(&Token::RParen)
6508                .map_parser_err(StatementKind::Copy)?;
6509            match query {
6510                Statement::Select(stmt) => CopyRelation::Select(stmt),
6511                Statement::Subscribe(stmt) => CopyRelation::Subscribe(stmt),
6512                _ => {
6513                    return parser_err!(self, self.peek_prev_pos(), "unsupported query in COPY")
6514                        .map_parser_err(StatementKind::Copy);
6515                }
6516            }
6517        } else {
6518            let name = self.parse_raw_name().map_parser_err(StatementKind::Copy)?;
6519            let columns = self
6520                .parse_parenthesized_column_list(Optional)
6521                .map_parser_err(StatementKind::Copy)?;
6522            CopyRelation::Named { name, columns }
6523        };
6524        let (direction, target) = match self
6525            .expect_one_of_keywords(&[FROM, TO])
6526            .map_parser_err(StatementKind::Copy)?
6527        {
6528            FROM => {
6529                if let CopyRelation::Named { .. } = relation {
6530                    // Ok.
6531                } else {
6532                    return parser_err!(
6533                        self,
6534                        self.peek_prev_pos(),
6535                        "queries not allowed in COPY FROM"
6536                    )
6537                    .map_no_statement_parser_err();
6538                }
6539                if self.parse_keyword(STDIN) {
6540                    (CopyDirection::From, CopyTarget::Stdin)
6541                } else {
6542                    let url_expr = self.parse_expr().map_parser_err(StatementKind::Copy)?;
6543                    (CopyDirection::From, CopyTarget::Expr(url_expr))
6544                }
6545            }
6546            TO => {
6547                // We only support the INTO keyword for 'COPY FROM'.
6548                if let Some(into_pos) = maybe_into_pos {
6549                    return self
6550                        .expected(into_pos, "identifier", Some(Token::Keyword(Keyword::Into)))
6551                        .map_parser_err(StatementKind::Copy);
6552                }
6553
6554                if self.parse_keyword(STDOUT) {
6555                    (CopyDirection::To, CopyTarget::Stdout)
6556                } else {
6557                    let url_expr = self.parse_expr().map_parser_err(StatementKind::Copy)?;
6558                    (CopyDirection::To, CopyTarget::Expr(url_expr))
6559                }
6560            }
6561            _ => unreachable!(),
6562        };
6563        // WITH must be followed by LParen. The WITH in COPY is optional for backward
6564        // compat with Postgres but is required elsewhere, which is why we don't use
6565        // parse_with_options here.
6566        let has_options = if self.parse_keyword(WITH) {
6567            self.expect_token(&Token::LParen)
6568                .map_parser_err(StatementKind::Copy)?;
6569            true
6570        } else {
6571            self.consume_token(&Token::LParen)
6572        };
6573        let options = if has_options {
6574            let o = self
6575                .parse_comma_separated(Parser::parse_copy_option)
6576                .map_parser_err(StatementKind::Copy)?;
6577            self.expect_token(&Token::RParen)
6578                .map_parser_err(StatementKind::Copy)?;
6579            o
6580        } else {
6581            vec![]
6582        };
6583        Ok(Statement::Copy(CopyStatement {
6584            relation,
6585            direction,
6586            target,
6587            options,
6588        }))
6589    }
6590
6591    fn parse_copy_option(&mut self) -> Result<CopyOption<Raw>, ParserError> {
6592        let name = match self.expect_one_of_keywords(&[
6593            FORMAT, DELIMITER, NULL, ESCAPE, QUOTE, HEADER, AWS, MAX, FILES, PATTERN,
6594        ])? {
6595            FORMAT => CopyOptionName::Format,
6596            DELIMITER => CopyOptionName::Delimiter,
6597            NULL => CopyOptionName::Null,
6598            ESCAPE => CopyOptionName::Escape,
6599            QUOTE => CopyOptionName::Quote,
6600            HEADER => CopyOptionName::Header,
6601            AWS => {
6602                self.expect_keyword(CONNECTION)?;
6603                return Ok(CopyOption {
6604                    name: CopyOptionName::AwsConnection,
6605                    value: Some(self.parse_object_option_value()?),
6606                });
6607            }
6608            MAX => {
6609                self.expect_keywords(&[FILE, SIZE])?;
6610                CopyOptionName::MaxFileSize
6611            }
6612            FILES => CopyOptionName::Files,
6613            PATTERN => CopyOptionName::Pattern,
6614            _ => unreachable!(),
6615        };
6616        Ok(CopyOption {
6617            name,
6618            value: self.parse_optional_option_value()?,
6619        })
6620    }
6621
6622    /// Parse a literal value (numbers, strings, date/time, booleans)
6623    fn parse_value(&mut self) -> Result<Value, ParserError> {
6624        match self.next_token() {
6625            Some(t) => match t {
6626                Token::Keyword(TRUE) => Ok(Value::Boolean(true)),
6627                Token::Keyword(FALSE) => Ok(Value::Boolean(false)),
6628                Token::Keyword(NULL) => Ok(Value::Null),
6629                Token::Keyword(INTERVAL) => Ok(Value::Interval(self.parse_interval_value()?)),
6630                Token::Keyword(kw) => {
6631                    parser_err!(
6632                        self,
6633                        self.peek_prev_pos(),
6634                        format!("No value parser for keyword {}", kw)
6635                    )
6636                }
6637                Token::Op(ref op) if op == "-" => match self.next_token() {
6638                    Some(Token::Number(n)) => Ok(Value::Number(format!("-{}", n))),
6639                    other => self.expected(self.peek_prev_pos(), "literal int", other),
6640                },
6641                Token::Number(ref n) => Ok(Value::Number(n.to_string())),
6642                Token::String(ref s) => Ok(Value::String(s.to_string())),
6643                Token::HexString(ref s) => Ok(Value::HexString(s.to_string())),
6644                _ => parser_err!(
6645                    self,
6646                    self.peek_prev_pos(),
6647                    format!("Unsupported value: {:?}", t)
6648                ),
6649            },
6650            None => parser_err!(
6651                self,
6652                self.peek_prev_pos(),
6653                "Expecting a value, but found EOF"
6654            ),
6655        }
6656    }
6657
6658    fn parse_array(&mut self) -> Result<Expr<Raw>, ParserError> {
6659        if self.consume_token(&Token::LParen) {
6660            let subquery = self.parse_query()?;
6661            self.expect_token(&Token::RParen)?;
6662            Ok(Expr::ArraySubquery(Box::new(subquery)))
6663        } else {
6664            self.parse_sequence(Self::parse_array).map(Expr::Array)
6665        }
6666    }
6667
6668    fn parse_list(&mut self) -> Result<Expr<Raw>, ParserError> {
6669        if self.consume_token(&Token::LParen) {
6670            let subquery = self.parse_query()?;
6671            self.expect_token(&Token::RParen)?;
6672            Ok(Expr::ListSubquery(Box::new(subquery)))
6673        } else {
6674            self.parse_sequence(Self::parse_list).map(Expr::List)
6675        }
6676    }
6677
6678    fn parse_map(&mut self) -> Result<Expr<Raw>, ParserError> {
6679        if self.consume_token(&Token::LParen) {
6680            let subquery = self.parse_query()?;
6681            self.expect_token(&Token::RParen)?;
6682            return Ok(Expr::MapSubquery(Box::new(subquery)));
6683        }
6684
6685        self.expect_token(&Token::LBracket)?;
6686        let mut exprs = vec![];
6687        loop {
6688            if let Some(Token::RBracket) = self.peek_token() {
6689                break;
6690            }
6691            let key = self.parse_expr()?;
6692            self.expect_token(&Token::Arrow)?;
6693            let value = if let Some(Token::LBracket) = self.peek_token() {
6694                self.parse_map()?
6695            } else {
6696                self.parse_expr()?
6697            };
6698            exprs.push(MapEntry { key, value });
6699            if !self.consume_token(&Token::Comma) {
6700                break;
6701            }
6702        }
6703        self.expect_token(&Token::RBracket)?;
6704        Ok(Expr::Map(exprs))
6705    }
6706
6707    fn parse_sequence<F>(&mut self, mut f: F) -> Result<Vec<Expr<Raw>>, ParserError>
6708    where
6709        F: FnMut(&mut Self) -> Result<Expr<Raw>, ParserError>,
6710    {
6711        self.expect_token(&Token::LBracket)?;
6712        let mut exprs = vec![];
6713        loop {
6714            if let Some(Token::RBracket) = self.peek_token() {
6715                break;
6716            }
6717            let expr = if let Some(Token::LBracket) = self.peek_token() {
6718                f(self)?
6719            } else {
6720                self.parse_expr()?
6721            };
6722            exprs.push(expr);
6723            if !self.consume_token(&Token::Comma) {
6724                break;
6725            }
6726        }
6727        self.expect_token(&Token::RBracket)?;
6728        Ok(exprs)
6729    }
6730
6731    fn parse_number_value(&mut self) -> Result<Value, ParserError> {
6732        match self.parse_value()? {
6733            v @ Value::Number(_) => Ok(v),
6734            _ => {
6735                self.prev_token();
6736                self.expected(self.peek_pos(), "literal number", self.peek_token())
6737            }
6738        }
6739    }
6740
6741    fn parse_version(&mut self) -> Result<Version, ParserError> {
6742        let version = self.parse_literal_uint()?;
6743        Ok(Version(version))
6744    }
6745
6746    /// Parse a signed literal integer.
6747    fn parse_literal_int(&mut self) -> Result<i64, ParserError> {
6748        let negative = self.consume_token(&Token::Op("-".into()));
6749        match self.next_token() {
6750            Some(Token::Number(s)) => {
6751                let n = s.parse::<i64>().map_err(|e| {
6752                    self.error(
6753                        self.peek_prev_pos(),
6754                        format!("Could not parse '{}' as i64: {}", s, e),
6755                    )
6756                })?;
6757                if negative {
6758                    n.checked_neg().ok_or_else(|| {
6759                        self.error(
6760                            self.peek_prev_pos(),
6761                            format!("Could not parse '{}' as i64: overflows i64", s),
6762                        )
6763                    })
6764                } else {
6765                    Ok(n)
6766                }
6767            }
6768            other => self.expected(self.peek_prev_pos(), "literal integer", other),
6769        }
6770    }
6771
6772    /// Parse an unsigned literal integer.
6773    fn parse_literal_uint(&mut self) -> Result<u64, ParserError> {
6774        match self.next_token() {
6775            Some(Token::Number(s)) => s.parse::<u64>().map_err(|e| {
6776                self.error(
6777                    self.peek_prev_pos(),
6778                    format!("Could not parse '{}' as u64: {}", s, e),
6779                )
6780            }),
6781            other => self.expected(self.peek_prev_pos(), "literal unsigned integer", other),
6782        }
6783    }
6784
6785    /// Parse a literal string
6786    fn parse_literal_string(&mut self) -> Result<String, ParserError> {
6787        match self.next_token() {
6788            Some(Token::String(ref s)) => Ok(s.clone()),
6789            other => self.expected(self.peek_prev_pos(), "literal string", other),
6790        }
6791    }
6792
6793    /// Parse a SQL datatype (in the context of a CREATE TABLE statement for example)
6794    fn parse_data_type(&mut self) -> Result<RawDataType, ParserError> {
6795        let other = |ident| RawDataType::Other {
6796            name: RawItemName::Name(UnresolvedItemName::unqualified(ident)),
6797            typ_mod: vec![],
6798        };
6799
6800        let mut data_type = match self.next_token() {
6801            Some(Token::Keyword(kw)) => match kw {
6802                // Text-like types
6803                CHAR | CHARACTER => {
6804                    let name = if self.parse_keyword(VARYING) {
6805                        ident!("varchar")
6806                    } else {
6807                        ident!("bpchar")
6808                    };
6809                    RawDataType::Other {
6810                        name: RawItemName::Name(UnresolvedItemName::unqualified(name)),
6811                        typ_mod: self.parse_typ_mod()?,
6812                    }
6813                }
6814                BPCHAR => RawDataType::Other {
6815                    name: RawItemName::Name(UnresolvedItemName::unqualified(ident!("bpchar"))),
6816                    typ_mod: self.parse_typ_mod()?,
6817                },
6818                VARCHAR => RawDataType::Other {
6819                    name: RawItemName::Name(UnresolvedItemName::unqualified(ident!("varchar"))),
6820                    typ_mod: self.parse_typ_mod()?,
6821                },
6822                STRING => other(ident!("text")),
6823
6824                // Number-like types
6825                BIGINT => other(ident!("int8")),
6826                SMALLINT => other(ident!("int2")),
6827                DEC | DECIMAL => RawDataType::Other {
6828                    name: RawItemName::Name(UnresolvedItemName::unqualified(ident!("numeric"))),
6829                    typ_mod: self.parse_typ_mod()?,
6830                },
6831                DOUBLE => {
6832                    let _ = self.parse_keyword(PRECISION);
6833                    other(ident!("float8"))
6834                }
6835                FLOAT => match self.parse_optional_precision()?.unwrap_or(53) {
6836                    v if v == 0 || v > 53 => {
6837                        return Err(self.error(
6838                            self.peek_prev_pos(),
6839                            "precision for type float must be within ([1-53])".into(),
6840                        ));
6841                    }
6842                    v if v < 25 => other(ident!("float4")),
6843                    _ => other(ident!("float8")),
6844                },
6845                INT | INTEGER => other(ident!("int4")),
6846                REAL => other(ident!("float4")),
6847
6848                // Time-like types
6849                TIME => {
6850                    if self.parse_keyword(WITH) {
6851                        self.expect_keywords(&[TIME, ZONE])?;
6852                        other(ident!("timetz"))
6853                    } else {
6854                        if self.parse_keyword(WITHOUT) {
6855                            self.expect_keywords(&[TIME, ZONE])?;
6856                        }
6857                        other(ident!("time"))
6858                    }
6859                }
6860                TIMESTAMP => {
6861                    let typ_mod = self.parse_timestamp_precision()?;
6862                    if self.parse_keyword(WITH) {
6863                        self.expect_keywords(&[TIME, ZONE])?;
6864                        RawDataType::Other {
6865                            name: RawItemName::Name(UnresolvedItemName::unqualified(ident!(
6866                                "timestamptz"
6867                            ))),
6868                            typ_mod,
6869                        }
6870                    } else {
6871                        if self.parse_keyword(WITHOUT) {
6872                            self.expect_keywords(&[TIME, ZONE])?;
6873                        }
6874                        RawDataType::Other {
6875                            name: RawItemName::Name(UnresolvedItemName::unqualified(ident!(
6876                                "timestamp"
6877                            ))),
6878                            typ_mod,
6879                        }
6880                    }
6881                }
6882                TIMESTAMPTZ => {
6883                    let typ_mod = self.parse_timestamp_precision()?;
6884                    RawDataType::Other {
6885                        name: RawItemName::Name(UnresolvedItemName::unqualified(ident!(
6886                            "timestamptz"
6887                        ))),
6888                        typ_mod,
6889                    }
6890                }
6891
6892                // MZ "proprietary" types
6893                MAP => {
6894                    return self.parse_map_type();
6895                }
6896
6897                // Misc.
6898                BOOLEAN => other(ident!("bool")),
6899                BYTES => other(ident!("bytea")),
6900                JSON => other(ident!("jsonb")),
6901                _ => {
6902                    self.prev_token();
6903                    RawDataType::Other {
6904                        name: RawItemName::Name(self.parse_item_name()?),
6905                        typ_mod: self.parse_typ_mod()?,
6906                    }
6907                }
6908            },
6909            Some(Token::Ident(_) | Token::LBracket) => {
6910                self.prev_token();
6911                RawDataType::Other {
6912                    name: self.parse_raw_name()?,
6913                    typ_mod: self.parse_typ_mod()?,
6914                }
6915            }
6916            other => self.expected(self.peek_prev_pos(), "a data type name", other)?,
6917        };
6918
6919        loop {
6920            match self.peek_token() {
6921                Some(Token::Keyword(LIST)) => {
6922                    self.next_token();
6923                    data_type = RawDataType::List(Box::new(data_type));
6924                }
6925                Some(Token::LBracket) => {
6926                    // Handle array suffixes. Note that `int[]`, `int[][][]`,
6927                    // and `int[2][2]` all parse to the same "int array" type.
6928                    self.next_token();
6929                    let _ = self.maybe_parse(|parser| parser.parse_number_value());
6930                    self.expect_token(&Token::RBracket)?;
6931                    if !matches!(data_type, RawDataType::Array(_)) {
6932                        data_type = RawDataType::Array(Box::new(data_type));
6933                    }
6934                }
6935                _ => break,
6936            }
6937        }
6938        Ok(data_type)
6939    }
6940
6941    fn parse_typ_mod(&mut self) -> Result<Vec<i64>, ParserError> {
6942        if self.consume_token(&Token::LParen) {
6943            let typ_mod = self.parse_comma_separated(Parser::parse_literal_int)?;
6944            self.expect_token(&Token::RParen)?;
6945            Ok(typ_mod)
6946        } else {
6947            Ok(vec![])
6948        }
6949    }
6950
6951    // parses the precision in timestamp(<precision>) and timestamptz(<precision>)
6952    fn parse_timestamp_precision(&mut self) -> Result<Vec<i64>, ParserError> {
6953        if self.consume_token(&Token::LParen) {
6954            let typ_mod = self.parse_literal_int()?;
6955            self.expect_token(&Token::RParen)?;
6956            Ok(vec![typ_mod])
6957        } else {
6958            Ok(vec![])
6959        }
6960    }
6961
6962    /// Parse `AS identifier` (or simply `identifier` if it's not a reserved keyword)
6963    /// Some examples with aliases: `SELECT 1 foo`, `SELECT COUNT(*) AS cnt`,
6964    /// `SELECT ... FROM t1 foo, t2 bar`, `SELECT ... FROM (...) AS bar`
6965    fn parse_optional_alias<F>(&mut self, is_reserved: F) -> Result<Option<Ident>, ParserError>
6966    where
6967        F: FnOnce(Keyword) -> bool,
6968    {
6969        let after_as = self.parse_keyword(AS);
6970        match self.next_token() {
6971            // Do not accept `AS OF`, which is reserved for providing timestamp information
6972            // to queries.
6973            Some(Token::Keyword(OF)) => {
6974                self.prev_token();
6975                if after_as {
6976                    self.prev_token();
6977                }
6978                Ok(None)
6979            }
6980            // Accept any other identifier after `AS` (though many dialects have restrictions on
6981            // keywords that may appear here). If there's no `AS`: don't parse keywords,
6982            // which may start a construct allowed in this position, to be parsed as aliases.
6983            // (For example, in `FROM t1 JOIN` the `JOIN` will always be parsed as a keyword,
6984            // not an alias.)
6985            Some(Token::Keyword(kw)) if after_as || !is_reserved(kw) => Ok(Some(kw.into())),
6986            Some(Token::Ident(id)) => Ok(Some(self.new_identifier(id)?)),
6987            not_an_ident => {
6988                if after_as {
6989                    return self.expected(
6990                        self.peek_prev_pos(),
6991                        "an identifier after AS",
6992                        not_an_ident,
6993                    );
6994                }
6995                self.prev_token();
6996                Ok(None) // no alias found
6997            }
6998        }
6999    }
7000
7001    /// Parse `AS identifier` when the AS is describing a table-valued object,
7002    /// like in `... FROM generate_series(1, 10) AS t (col)`. In this case
7003    /// the alias is allowed to optionally name the columns in the table, in
7004    /// addition to the table itself.
7005    fn parse_optional_table_alias(&mut self) -> Result<Option<TableAlias>, ParserError> {
7006        match self.parse_optional_alias(Keyword::is_reserved_in_table_alias)? {
7007            Some(name) => {
7008                let columns = self.parse_parenthesized_column_list(Optional)?;
7009                Ok(Some(TableAlias {
7010                    name,
7011                    columns,
7012                    strict: false,
7013                }))
7014            }
7015            None => Ok(None),
7016        }
7017    }
7018
7019    fn parse_deferred_item_name(&mut self) -> Result<DeferredItemName<Raw>, ParserError> {
7020        Ok(match self.parse_raw_name()? {
7021            named @ RawItemName::Id(..) => DeferredItemName::Named(named),
7022            RawItemName::Name(name) => DeferredItemName::Deferred(name),
7023        })
7024    }
7025
7026    fn parse_raw_name(&mut self) -> Result<RawItemName, ParserError> {
7027        if self.consume_token(&Token::LBracket) {
7028            let id = match self.next_token() {
7029                Some(Token::Ident(id)) => id.into_inner(),
7030                _ => return parser_err!(self, self.peek_prev_pos(), "expected id"),
7031            };
7032            self.expect_keyword(AS)?;
7033            let name = self.parse_item_name()?;
7034            // TODO(justin): is there a more idiomatic way to detect a fully-qualified name?
7035            if name.0.len() < 2 {
7036                return parser_err!(
7037                    self,
7038                    self.peek_prev_pos(),
7039                    "table name in square brackets must be fully qualified"
7040                );
7041            }
7042
7043            let version = if self.parse_keywords(&[VERSION]) {
7044                let version = self.parse_version()?;
7045                Some(version)
7046            } else {
7047                None
7048            };
7049
7050            self.expect_token(&Token::RBracket)?;
7051            Ok(RawItemName::Id(id, name, version))
7052        } else {
7053            Ok(RawItemName::Name(self.parse_item_name()?))
7054        }
7055    }
7056
7057    fn parse_column_name(&mut self) -> Result<ColumnName<Raw>, ParserError> {
7058        let start = self.peek_pos();
7059        let mut item_name = self.parse_raw_name()?;
7060        let column_name = match &mut item_name {
7061            RawItemName::Name(UnresolvedItemName(identifiers)) => {
7062                if identifiers.len() < 2 {
7063                    return Err(ParserError::new(
7064                        start,
7065                        "need to specify an object and a column",
7066                    ));
7067                }
7068                identifiers.pop().unwrap()
7069            }
7070            RawItemName::Id(_, _, _) => {
7071                self.expect_token(&Token::Dot)?;
7072                self.parse_identifier()?
7073            }
7074        };
7075
7076        Ok(ColumnName {
7077            relation: item_name,
7078            column: column_name,
7079        })
7080    }
7081
7082    /// Parse a possibly quoted database identifier, e.g.
7083    /// `foo` or `"mydatabase"`
7084    fn parse_database_name(&mut self) -> Result<UnresolvedDatabaseName, ParserError> {
7085        Ok(UnresolvedDatabaseName(self.parse_identifier()?))
7086    }
7087
7088    /// Parse a possibly qualified, possibly quoted schema identifier, e.g.
7089    /// `foo` or `mydatabase."schema"`
7090    fn parse_schema_name(&mut self) -> Result<UnresolvedSchemaName, ParserError> {
7091        Ok(UnresolvedSchemaName(self.parse_identifiers()?))
7092    }
7093
7094    /// Parse a possibly qualified, possibly quoted object identifier, e.g.
7095    /// `foo` or `myschema."table"`
7096    fn parse_item_name(&mut self) -> Result<UnresolvedItemName, ParserError> {
7097        Ok(UnresolvedItemName(self.parse_identifiers()?))
7098    }
7099
7100    /// Parse an object name.
7101    fn parse_object_name(
7102        &mut self,
7103        object_type: ObjectType,
7104    ) -> Result<UnresolvedObjectName, ParserError> {
7105        Ok(match object_type {
7106            ObjectType::Table
7107            | ObjectType::View
7108            | ObjectType::MaterializedView
7109            | ObjectType::Source
7110            | ObjectType::Subsource
7111            | ObjectType::Sink
7112            | ObjectType::Index
7113            | ObjectType::Type
7114            | ObjectType::Secret
7115            | ObjectType::Connection
7116            | ObjectType::Func
7117            | ObjectType::ContinualTask => UnresolvedObjectName::Item(self.parse_item_name()?),
7118            ObjectType::Role => UnresolvedObjectName::Role(self.parse_identifier()?),
7119            ObjectType::Cluster => UnresolvedObjectName::Cluster(self.parse_identifier()?),
7120            ObjectType::ClusterReplica => {
7121                UnresolvedObjectName::ClusterReplica(self.parse_cluster_replica_name()?)
7122            }
7123            ObjectType::Database => UnresolvedObjectName::Database(self.parse_database_name()?),
7124            ObjectType::Schema => UnresolvedObjectName::Schema(self.parse_schema_name()?),
7125            ObjectType::NetworkPolicy => {
7126                UnresolvedObjectName::NetworkPolicy(self.parse_identifier()?)
7127            }
7128        })
7129    }
7130
7131    ///Parse one or more simple one-word identifiers separated by a '.'
7132    fn parse_identifiers(&mut self) -> Result<Vec<Ident>, ParserError> {
7133        let mut idents = vec![];
7134        loop {
7135            idents.push(self.parse_identifier()?);
7136            if !self.consume_token(&Token::Dot) {
7137                break;
7138            }
7139        }
7140        Ok(idents)
7141    }
7142
7143    /// Parse a simple one-word identifier (possibly quoted, possibly a keyword)
7144    fn parse_identifier(&mut self) -> Result<Ident, ParserError> {
7145        match self.consume_identifier()? {
7146            Some(id) => {
7147                if id.as_str().is_empty() {
7148                    return parser_err!(
7149                        self,
7150                        self.peek_prev_pos(),
7151                        "zero-length delimited identifier",
7152                    );
7153                }
7154                Ok(id)
7155            }
7156            None => self.expected(self.peek_pos(), "identifier", self.peek_token()),
7157        }
7158    }
7159
7160    fn consume_identifier(&mut self) -> Result<Option<Ident>, ParserError> {
7161        match self.peek_token() {
7162            Some(Token::Keyword(kw)) => {
7163                self.next_token();
7164                Ok(Some(kw.into()))
7165            }
7166            Some(Token::Ident(id)) => {
7167                self.next_token();
7168                Ok(Some(self.new_identifier(id)?))
7169            }
7170            _ => Ok(None),
7171        }
7172    }
7173
7174    fn parse_qualified_identifier(&mut self, id: Ident) -> Result<Expr<Raw>, ParserError> {
7175        let mut id_parts = vec![id];
7176        match self.peek_token() {
7177            Some(Token::LParen) | Some(Token::Dot) => {
7178                let mut ends_with_wildcard = false;
7179                while self.consume_token(&Token::Dot) {
7180                    match self.next_token() {
7181                        Some(Token::Keyword(kw)) => id_parts.push(kw.into()),
7182                        Some(Token::Ident(id)) => id_parts.push(self.new_identifier(id)?),
7183                        Some(Token::Star) => {
7184                            ends_with_wildcard = true;
7185                            break;
7186                        }
7187                        unexpected => {
7188                            return self.expected(
7189                                self.peek_prev_pos(),
7190                                "an identifier or a '*' after '.'",
7191                                unexpected,
7192                            );
7193                        }
7194                    }
7195                }
7196                if ends_with_wildcard {
7197                    Ok(Expr::QualifiedWildcard(id_parts))
7198                } else if self.peek_token() == Some(Token::LParen) {
7199                    let function =
7200                        self.parse_function(RawItemName::Name(UnresolvedItemName(id_parts)))?;
7201                    Ok(Expr::Function(function))
7202                } else {
7203                    Ok(Expr::Identifier(id_parts))
7204                }
7205            }
7206            _ => Ok(Expr::Identifier(id_parts)),
7207        }
7208    }
7209
7210    /// Parse a parenthesized comma-separated list of unqualified, possibly quoted identifiers
7211    fn parse_parenthesized_column_list(
7212        &mut self,
7213        optional: IsOptional,
7214    ) -> Result<Vec<Ident>, ParserError> {
7215        if self.consume_token(&Token::LParen) {
7216            let cols = self.parse_comma_separated(Parser::parse_identifier)?;
7217            self.expect_token(&Token::RParen)?;
7218            Ok(cols)
7219        } else if optional == Optional {
7220            Ok(vec![])
7221        } else {
7222            self.expected(
7223                self.peek_pos(),
7224                "a list of columns in parentheses",
7225                self.peek_token(),
7226            )
7227        }
7228    }
7229
7230    fn parse_optional_precision(&mut self) -> Result<Option<u64>, ParserError> {
7231        if self.consume_token(&Token::LParen) {
7232            let n = self.parse_literal_uint()?;
7233            self.expect_token(&Token::RParen)?;
7234            Ok(Some(n))
7235        } else {
7236            Ok(None)
7237        }
7238    }
7239
7240    fn parse_map_type(&mut self) -> Result<RawDataType, ParserError> {
7241        self.expect_token(&Token::LBracket)?;
7242        let key_type = Box::new(self.parse_data_type()?);
7243        self.expect_token(&Token::Arrow)?;
7244        let value_type = Box::new(self.parse_data_type()?);
7245        self.expect_token(&Token::RBracket)?;
7246        Ok(RawDataType::Map {
7247            key_type,
7248            value_type,
7249        })
7250    }
7251
7252    fn parse_delete(&mut self) -> Result<Statement<Raw>, ParserError> {
7253        self.expect_keyword(FROM)?;
7254        let table_name = RawItemName::Name(self.parse_item_name()?);
7255        let alias = self.parse_optional_table_alias()?;
7256        let using = if self.parse_keyword(USING) {
7257            self.parse_comma_separated(Parser::parse_table_and_joins)?
7258        } else {
7259            vec![]
7260        };
7261        let selection = if self.parse_keyword(WHERE) {
7262            Some(self.parse_expr()?)
7263        } else {
7264            None
7265        };
7266
7267        Ok(Statement::Delete(DeleteStatement {
7268            table_name,
7269            alias,
7270            using,
7271            selection,
7272        }))
7273    }
7274
7275    /// Parses a SELECT (or WITH, VALUES, TABLE) statement with optional AS OF.
7276    fn parse_select_statement(&mut self) -> Result<SelectStatement<Raw>, ParserError> {
7277        Ok(SelectStatement {
7278            query: self.parse_query()?,
7279            as_of: self.parse_optional_as_of()?,
7280        })
7281    }
7282
7283    /// Parse a query expression, i.e. a `SELECT` statement optionally
7284    /// preceded with some `WITH` CTE declarations and optionally followed
7285    /// by `ORDER BY`. Unlike some other parse_... methods, this one doesn't
7286    /// expect the initial keyword to be already consumed
7287    fn parse_query(&mut self) -> Result<Query<Raw>, ParserError> {
7288        self.checked_recur_mut(|parser| {
7289            let cte_block = if parser.parse_keyword(WITH) {
7290                if parser.parse_keyword(MUTUALLY) {
7291                    parser.expect_keyword(RECURSIVE)?;
7292                    let options = if parser.consume_token(&Token::LParen) {
7293                        let options =
7294                            parser.parse_comma_separated(Self::parse_mut_rec_block_option)?;
7295                        parser.expect_token(&Token::RParen)?;
7296                        options
7297                    } else {
7298                        vec![]
7299                    };
7300                    CteBlock::MutuallyRecursive(MutRecBlock {
7301                        options,
7302                        ctes: parser.parse_comma_separated(Parser::parse_cte_mut_rec)?,
7303                    })
7304                } else {
7305                    // TODO: optional RECURSIVE
7306                    CteBlock::Simple(parser.parse_comma_separated(Parser::parse_cte)?)
7307                }
7308            } else {
7309                CteBlock::empty()
7310            };
7311
7312            let body = parser.parse_query_body(SetPrecedence::Zero)?;
7313
7314            parser.parse_query_tail(cte_block, body)
7315        })
7316    }
7317
7318    fn parse_mut_rec_block_option(&mut self) -> Result<MutRecBlockOption<Raw>, ParserError> {
7319        match self.expect_one_of_keywords(&[RECURSION, RETURN, ERROR])? {
7320            RECURSION => {
7321                self.expect_keyword(LIMIT)?;
7322                Ok(MutRecBlockOption {
7323                    name: MutRecBlockOptionName::RecursionLimit,
7324                    value: self.parse_optional_option_value()?,
7325                })
7326            }
7327            RETURN => {
7328                self.expect_keywords(&[AT, RECURSION, LIMIT])?;
7329                Ok(MutRecBlockOption {
7330                    name: MutRecBlockOptionName::ReturnAtRecursionLimit,
7331                    value: self.parse_optional_option_value()?,
7332                })
7333            }
7334            ERROR => {
7335                self.expect_keywords(&[AT, RECURSION, LIMIT])?;
7336                Ok(MutRecBlockOption {
7337                    name: MutRecBlockOptionName::ErrorAtRecursionLimit,
7338                    value: self.parse_optional_option_value()?,
7339                })
7340            }
7341            _ => unreachable!(),
7342        }
7343    }
7344
7345    fn parse_query_tail(
7346        &mut self,
7347        ctes: CteBlock<Raw>,
7348        body: SetExpr<Raw>,
7349    ) -> Result<Query<Raw>, ParserError> {
7350        let (inner_ctes, inner_order_by, inner_limit, inner_offset, body) = match body {
7351            SetExpr::Query(query) => {
7352                let Query {
7353                    ctes,
7354                    body,
7355                    order_by,
7356                    limit,
7357                    offset,
7358                } = *query;
7359                (ctes, order_by, limit, offset, body)
7360            }
7361            _ => (CteBlock::empty(), vec![], None, None, body),
7362        };
7363
7364        let ctes = if ctes.is_empty() {
7365            inner_ctes
7366        } else if !inner_ctes.is_empty() {
7367            return parser_err!(self, self.peek_pos(), "multiple WITH clauses not allowed");
7368        } else {
7369            ctes
7370        };
7371
7372        let order_by = if self.parse_keywords(&[ORDER, BY]) {
7373            if !inner_order_by.is_empty() {
7374                return parser_err!(
7375                    self,
7376                    self.peek_prev_pos(),
7377                    "multiple ORDER BY clauses not allowed"
7378                );
7379            }
7380            self.parse_comma_separated(Parser::parse_order_by_expr)?
7381        } else {
7382            inner_order_by
7383        };
7384
7385        // Parse LIMIT, FETCH, OFFSET in any order, but:
7386        // - Only at most one of LIMIT or FETCH is allowed.
7387        // - Only at most one occurrence is allowed from each of these.
7388        let mut limit = inner_limit;
7389        let mut offset = inner_offset;
7390        while let Some(parsed_keyword) = self.parse_one_of_keywords(&[LIMIT, OFFSET, FETCH]) {
7391            match parsed_keyword {
7392                LIMIT => {
7393                    if limit.is_some() {
7394                        return parser_err!(
7395                            self,
7396                            self.peek_prev_pos(),
7397                            "multiple LIMIT/FETCH clauses not allowed"
7398                        );
7399                    }
7400                    limit = if self.parse_keyword(ALL) {
7401                        None
7402                    } else {
7403                        Some(Limit {
7404                            with_ties: false,
7405                            quantity: self.parse_expr()?,
7406                        })
7407                    };
7408                }
7409                OFFSET => {
7410                    if offset.is_some() {
7411                        return parser_err!(
7412                            self,
7413                            self.peek_prev_pos(),
7414                            "multiple OFFSET clauses not allowed"
7415                        );
7416                    }
7417                    let value = self.parse_expr()?;
7418                    let _ = self.parse_one_of_keywords(&[ROW, ROWS]);
7419                    offset = Some(value);
7420                }
7421                FETCH => {
7422                    if limit.is_some() {
7423                        return parser_err!(
7424                            self,
7425                            self.peek_prev_pos(),
7426                            "multiple LIMIT/FETCH clauses not allowed"
7427                        );
7428                    }
7429                    self.expect_one_of_keywords(&[FIRST, NEXT])?;
7430                    let quantity = if self.parse_one_of_keywords(&[ROW, ROWS]).is_some() {
7431                        Expr::Value(Value::Number('1'.into()))
7432                    } else {
7433                        let quantity = self.parse_expr()?;
7434                        self.expect_one_of_keywords(&[ROW, ROWS])?;
7435                        quantity
7436                    };
7437                    let with_ties = if self.parse_keyword(ONLY) {
7438                        false
7439                    } else if self.parse_keywords(&[WITH, TIES]) {
7440                        true
7441                    } else {
7442                        return self.expected(
7443                            self.peek_pos(),
7444                            "one of ONLY or WITH TIES",
7445                            self.peek_token(),
7446                        );
7447                    };
7448                    limit = Some(Limit {
7449                        with_ties,
7450                        quantity,
7451                    });
7452                }
7453                _ => unreachable!(),
7454            }
7455        }
7456
7457        Ok(Query {
7458            ctes,
7459            body,
7460            order_by,
7461            limit,
7462            offset,
7463        })
7464    }
7465
7466    /// Parse a CTE (`alias [( col1, col2, ... )] AS (subquery)`)
7467    fn parse_cte(&mut self) -> Result<Cte<Raw>, ParserError> {
7468        let alias = TableAlias {
7469            name: self.parse_identifier()?,
7470            columns: self.parse_parenthesized_column_list(Optional)?,
7471            strict: false,
7472        };
7473        self.expect_keyword(AS)?;
7474        self.expect_token(&Token::LParen)?;
7475        let query = self.parse_query()?;
7476        self.expect_token(&Token::RParen)?;
7477        Ok(Cte {
7478            alias,
7479            query,
7480            id: (),
7481        })
7482    }
7483
7484    /// Parse a mutually recursive CTE (`alias ( col1: typ1, col2: typ2, ... ) AS (subquery)`).
7485    ///
7486    /// The main distinction from `parse_cte` is that the column names and types are mandatory.
7487    /// This is not how SQL works for `WITH RECURSIVE`, but we are doing it for now to make the
7488    /// query interpretation that much easier.
7489    fn parse_cte_mut_rec(&mut self) -> Result<CteMutRec<Raw>, ParserError> {
7490        let name = self.parse_identifier()?;
7491        self.expect_token(&Token::LParen)?;
7492        let columns = self.parse_comma_separated(|parser| {
7493            Ok(CteMutRecColumnDef {
7494                name: parser.parse_identifier()?,
7495                data_type: parser.parse_data_type()?,
7496            })
7497        })?;
7498        self.expect_token(&Token::RParen)?;
7499        self.expect_keyword(AS)?;
7500        self.expect_token(&Token::LParen)?;
7501        let query = self.parse_query()?;
7502        self.expect_token(&Token::RParen)?;
7503        Ok(CteMutRec {
7504            name,
7505            columns,
7506            query,
7507            id: (),
7508        })
7509    }
7510
7511    /// Parse a "query body", which is an expression with roughly the
7512    /// following grammar:
7513    /// ```text
7514    ///   query_body ::= restricted_select | '(' subquery ')' | set_operation
7515    ///   restricted_select ::= 'SELECT' [expr_list] [ from ] [ where ] [ groupby_having ]
7516    ///   subquery ::= query_body [ order_by_limit ]
7517    ///   set_operation ::= query_body { 'UNION' | 'EXCEPT' | 'INTERSECT' } [ 'ALL' ] query_body
7518    /// ```
7519    fn parse_query_body(&mut self, precedence: SetPrecedence) -> Result<SetExpr<Raw>, ParserError> {
7520        // We parse the expression using a Pratt parser, as in `parse_expr()`.
7521        // Start by parsing a restricted SELECT or a `(subquery)`:
7522        let expr = if self.parse_keyword(SELECT) {
7523            SetExpr::Select(Box::new(self.parse_select()?))
7524        } else if self.consume_token(&Token::LParen) {
7525            // CTEs are not allowed here, but the parser currently accepts them
7526            let subquery = self.parse_query()?;
7527            self.expect_token(&Token::RParen)?;
7528            SetExpr::Query(Box::new(subquery))
7529        } else if self.parse_keyword(VALUES) {
7530            SetExpr::Values(self.parse_values()?)
7531        } else if self.parse_keyword(SHOW) {
7532            SetExpr::Show(self.parse_show()?)
7533        } else if self.parse_keyword(TABLE) {
7534            SetExpr::Table(self.parse_raw_name()?)
7535        } else {
7536            return self.expected(
7537                self.peek_pos(),
7538                "SELECT, VALUES, or a subquery in the query body",
7539                self.peek_token(),
7540            );
7541        };
7542
7543        self.parse_query_body_seeded(precedence, expr)
7544    }
7545
7546    fn parse_query_body_seeded(
7547        &mut self,
7548        precedence: SetPrecedence,
7549        mut expr: SetExpr<Raw>,
7550    ) -> Result<SetExpr<Raw>, ParserError> {
7551        loop {
7552            // The query can be optionally followed by a set operator:
7553            let next_token = self.peek_token();
7554            let op = self.parse_set_operator(&next_token);
7555            let next_precedence = match op {
7556                // UNION and EXCEPT have the same precedence and evaluate left-to-right
7557                Some(SetOperator::Union) | Some(SetOperator::Except) => SetPrecedence::UnionExcept,
7558                // INTERSECT has higher precedence than UNION/EXCEPT
7559                Some(SetOperator::Intersect) => SetPrecedence::Intersect,
7560                // Unexpected token or EOF => stop parsing the query body
7561                None => break,
7562            };
7563            if precedence >= next_precedence {
7564                break;
7565            }
7566            self.next_token(); // skip past the set operator
7567
7568            let all = self.parse_keyword(ALL);
7569            let distinct = self.parse_keyword(DISTINCT);
7570            if all && distinct {
7571                return parser_err!(
7572                    self,
7573                    self.peek_prev_pos(),
7574                    "Cannot specify both ALL and DISTINCT in set operation"
7575                );
7576            }
7577            expr = SetExpr::SetOperation {
7578                left: Box::new(expr),
7579                op: op.unwrap(),
7580                all,
7581                right: Box::new(self.parse_query_body(next_precedence)?),
7582            };
7583        }
7584
7585        Ok(expr)
7586    }
7587
7588    fn parse_set_operator(&self, token: &Option<Token>) -> Option<SetOperator> {
7589        match token {
7590            Some(Token::Keyword(UNION)) => Some(SetOperator::Union),
7591            Some(Token::Keyword(EXCEPT)) => Some(SetOperator::Except),
7592            Some(Token::Keyword(INTERSECT)) => Some(SetOperator::Intersect),
7593            _ => None,
7594        }
7595    }
7596
7597    /// Parse a restricted `SELECT` statement (no CTEs / `UNION` / `ORDER BY`),
7598    /// assuming the initial `SELECT` was already consumed
7599    fn parse_select(&mut self) -> Result<Select<Raw>, ParserError> {
7600        let all = self.parse_keyword(ALL);
7601        let distinct = self.parse_keyword(DISTINCT);
7602        if all && distinct {
7603            return parser_err!(
7604                self,
7605                self.peek_prev_pos(),
7606                "Cannot specify both ALL and DISTINCT in SELECT"
7607            );
7608        }
7609        let distinct = if distinct && self.parse_keyword(ON) {
7610            self.expect_token(&Token::LParen)?;
7611            let exprs = self.parse_comma_separated(Parser::parse_expr)?;
7612            self.expect_token(&Token::RParen)?;
7613            Some(Distinct::On(exprs))
7614        } else if distinct {
7615            Some(Distinct::EntireRow)
7616        } else {
7617            None
7618        };
7619
7620        let projection = match self.peek_token() {
7621            // An empty target list is permissible to match PostgreSQL, which
7622            // permits these for symmetry with zero column tables. We need
7623            // to sniff out `AS` here specially to support `SELECT AS OF ...`.
7624            Some(Token::Keyword(kw)) if kw.is_reserved() || kw == AS => vec![],
7625            Some(Token::Semicolon) | Some(Token::RParen) | None => vec![],
7626            _ => {
7627                let mut projection = vec![];
7628                loop {
7629                    projection.push(self.parse_select_item()?);
7630                    if !self.consume_token(&Token::Comma) {
7631                        break;
7632                    }
7633                    if self.peek_keyword(FROM) {
7634                        return parser_err!(
7635                            self,
7636                            self.peek_prev_pos(),
7637                            "invalid trailing comma in SELECT list",
7638                        );
7639                    }
7640                }
7641                projection
7642            }
7643        };
7644
7645        // Note that for keywords to be properly handled here, they need to be
7646        // added to `RESERVED_FOR_COLUMN_ALIAS` / `RESERVED_FOR_TABLE_ALIAS`,
7647        // otherwise they may be parsed as an alias as part of the `projection`
7648        // or `from`.
7649
7650        let from = if self.parse_keyword(FROM) {
7651            self.parse_comma_separated(Parser::parse_table_and_joins)?
7652        } else {
7653            vec![]
7654        };
7655
7656        let selection = if self.parse_keyword(WHERE) {
7657            Some(self.parse_expr()?)
7658        } else {
7659            None
7660        };
7661
7662        let group_by = if self.parse_keywords(&[GROUP, BY]) {
7663            self.parse_comma_separated(Parser::parse_expr)?
7664        } else {
7665            vec![]
7666        };
7667
7668        let having = if self.parse_keyword(HAVING) {
7669            Some(self.parse_expr()?)
7670        } else {
7671            None
7672        };
7673
7674        let qualify = if self.parse_keyword(QUALIFY) {
7675            Some(self.parse_expr()?)
7676        } else {
7677            None
7678        };
7679
7680        let options = if self.parse_keyword(OPTIONS) {
7681            self.expect_token(&Token::LParen)?;
7682            let options = self.parse_comma_separated(Self::parse_select_option)?;
7683            self.expect_token(&Token::RParen)?;
7684            options
7685        } else {
7686            vec![]
7687        };
7688
7689        Ok(Select {
7690            distinct,
7691            projection,
7692            from,
7693            selection,
7694            group_by,
7695            having,
7696            qualify,
7697            options,
7698        })
7699    }
7700
7701    fn parse_select_option(&mut self) -> Result<SelectOption<Raw>, ParserError> {
7702        let name = match self.expect_one_of_keywords(&[EXPECTED, AGGREGATE, DISTINCT, LIMIT])? {
7703            EXPECTED => {
7704                self.expect_keywords(&[GROUP, SIZE])?;
7705                SelectOptionName::ExpectedGroupSize
7706            }
7707            AGGREGATE => {
7708                self.expect_keywords(&[INPUT, GROUP, SIZE])?;
7709                SelectOptionName::AggregateInputGroupSize
7710            }
7711            DISTINCT => {
7712                self.expect_keywords(&[ON, INPUT, GROUP, SIZE])?;
7713                SelectOptionName::DistinctOnInputGroupSize
7714            }
7715            LIMIT => {
7716                self.expect_keywords(&[INPUT, GROUP, SIZE])?;
7717                SelectOptionName::LimitInputGroupSize
7718            }
7719            _ => unreachable!(),
7720        };
7721        Ok(SelectOption {
7722            name,
7723            value: self.parse_optional_option_value()?,
7724        })
7725    }
7726
7727    fn parse_set(&mut self) -> Result<Statement<Raw>, ParserStatementError> {
7728        let modifier = self.parse_one_of_keywords(&[SESSION, LOCAL]);
7729        let mut variable = self.parse_identifier().map_no_statement_parser_err()?;
7730        let mut normal = self.consume_token(&Token::Eq) || self.parse_keyword(TO);
7731        if !normal {
7732            match variable.as_str().parse() {
7733                Ok(TIME) => {
7734                    self.expect_keyword(ZONE).map_no_statement_parser_err()?;
7735                    variable = ident!("timezone");
7736                    normal = true;
7737                }
7738                Ok(NAMES) => {
7739                    variable = ident!("client_encoding");
7740                    normal = true;
7741                }
7742                _ => {}
7743            }
7744        }
7745        if variable.as_str().parse() == Ok(SCHEMA) {
7746            variable = ident!("search_path");
7747            let to = self
7748                .parse_set_schema_to()
7749                .map_parser_err(StatementKind::SetVariable)?;
7750            Ok(Statement::SetVariable(SetVariableStatement {
7751                local: modifier == Some(LOCAL),
7752                variable,
7753                to,
7754            }))
7755        } else if normal {
7756            let to = self
7757                .parse_set_variable_to()
7758                .map_parser_err(StatementKind::SetVariable)?;
7759            Ok(Statement::SetVariable(SetVariableStatement {
7760                local: modifier == Some(LOCAL),
7761                variable,
7762                to,
7763            }))
7764        } else if variable.as_str().parse() == Ok(TRANSACTION) && modifier.is_none() {
7765            // SET TRANSACTION transaction_mode
7766            Ok(Statement::SetTransaction(SetTransactionStatement {
7767                local: true,
7768                modes: self
7769                    .parse_transaction_modes(true)
7770                    .map_parser_err(StatementKind::SetTransaction)?,
7771            }))
7772        } else if modifier == Some(SESSION)
7773            && variable.as_str().parse() == Ok(CHARACTERISTICS)
7774            && self.parse_keywords(&[AS, TRANSACTION])
7775        {
7776            // SET SESSION CHARACTERISTICS AS TRANSACTION transaction_mode
7777            Ok(Statement::SetTransaction(SetTransactionStatement {
7778                local: false,
7779                modes: self
7780                    .parse_transaction_modes(true)
7781                    .map_parser_err(StatementKind::SetTransaction)?,
7782            }))
7783        } else {
7784            self.expected(self.peek_pos(), "equals sign or TO", self.peek_token())
7785                .map_no_statement_parser_err()
7786        }
7787    }
7788
7789    fn parse_set_schema_to(&mut self) -> Result<SetVariableTo, ParserError> {
7790        if self.parse_keyword(DEFAULT) {
7791            Ok(SetVariableTo::Default)
7792        } else {
7793            let to = self.parse_set_variable_value()?;
7794            Ok(SetVariableTo::Values(vec![to]))
7795        }
7796    }
7797
7798    fn parse_set_variable_to(&mut self) -> Result<SetVariableTo, ParserError> {
7799        if self.parse_keyword(DEFAULT) {
7800            Ok(SetVariableTo::Default)
7801        } else {
7802            Ok(SetVariableTo::Values(
7803                self.parse_comma_separated(Parser::parse_set_variable_value)?,
7804            ))
7805        }
7806    }
7807
7808    fn parse_set_variable_value(&mut self) -> Result<SetVariableValue, ParserError> {
7809        if let Some(value) = self.maybe_parse(Parser::parse_value) {
7810            Ok(SetVariableValue::Literal(value))
7811        } else if let Some(ident) = self.maybe_parse(Parser::parse_identifier) {
7812            Ok(SetVariableValue::Ident(ident))
7813        } else {
7814            self.expected(self.peek_pos(), "variable value", self.peek_token())
7815        }
7816    }
7817
7818    fn parse_reset(&mut self) -> Result<Statement<Raw>, ParserError> {
7819        let mut variable = self.parse_identifier()?;
7820        if variable.as_str().parse() == Ok(SCHEMA) {
7821            variable = ident!("search_path");
7822        }
7823        Ok(Statement::ResetVariable(ResetVariableStatement {
7824            variable,
7825        }))
7826    }
7827
7828    fn parse_show(&mut self) -> Result<ShowStatement<Raw>, ParserError> {
7829        let redacted = self.parse_keyword(REDACTED);
7830        if redacted && !self.peek_keyword(CREATE) {
7831            return parser_err!(
7832                self,
7833                self.peek_pos(),
7834                "SHOW REDACTED is only supported for SHOW REDACTED CREATE ..."
7835            );
7836        }
7837        if self.parse_one_of_keywords(&[COLUMNS, FIELDS]).is_some() {
7838            self.parse_show_columns()
7839        } else if self.parse_keyword(OBJECTS) {
7840            let from = if self.parse_keywords(&[FROM]) {
7841                Some(self.parse_schema_name()?)
7842            } else {
7843                None
7844            };
7845            Ok(ShowStatement::ShowObjects(ShowObjectsStatement {
7846                object_type: ShowObjectType::Object,
7847                from,
7848                filter: self.parse_show_statement_filter()?,
7849            }))
7850        } else if let Some(object_type) = self.parse_plural_object_type() {
7851            let from = if object_type.lives_in_schema() {
7852                if self.parse_keywords(&[FROM]) {
7853                    Some(self.parse_schema_name()?)
7854                } else {
7855                    None
7856                }
7857            } else {
7858                None
7859            };
7860
7861            let show_object_type = match object_type {
7862                ObjectType::Database => ShowObjectType::Database,
7863                ObjectType::Schema => {
7864                    let from = if self.parse_keyword(FROM) {
7865                        Some(self.parse_database_name()?)
7866                    } else {
7867                        None
7868                    };
7869                    ShowObjectType::Schema { from }
7870                }
7871                ObjectType::Table => {
7872                    let on_source = if self.parse_one_of_keywords(&[ON]).is_some() {
7873                        Some(self.parse_raw_name()?)
7874                    } else {
7875                        None
7876                    };
7877                    ShowObjectType::Table { on_source }
7878                }
7879                ObjectType::View => ShowObjectType::View,
7880                ObjectType::Source => {
7881                    let in_cluster = self.parse_optional_in_cluster()?;
7882                    ShowObjectType::Source { in_cluster }
7883                }
7884                ObjectType::Subsource => {
7885                    let on_source = if self.parse_one_of_keywords(&[ON]).is_some() {
7886                        Some(self.parse_raw_name()?)
7887                    } else {
7888                        None
7889                    };
7890
7891                    if from.is_some() && on_source.is_some() {
7892                        return parser_err!(
7893                            self,
7894                            self.peek_prev_pos(),
7895                            "Cannot specify both FROM and ON"
7896                        );
7897                    }
7898
7899                    ShowObjectType::Subsource { on_source }
7900                }
7901                ObjectType::Sink => {
7902                    let in_cluster = self.parse_optional_in_cluster()?;
7903                    ShowObjectType::Sink { in_cluster }
7904                }
7905                ObjectType::Type => ShowObjectType::Type,
7906                ObjectType::Role => ShowObjectType::Role,
7907                ObjectType::ClusterReplica => ShowObjectType::ClusterReplica,
7908                ObjectType::Secret => ShowObjectType::Secret,
7909                ObjectType::Connection => ShowObjectType::Connection,
7910                ObjectType::Cluster => ShowObjectType::Cluster,
7911                ObjectType::NetworkPolicy => ShowObjectType::NetworkPolicy,
7912                ObjectType::MaterializedView => {
7913                    let in_cluster = self.parse_optional_in_cluster()?;
7914                    ShowObjectType::MaterializedView { in_cluster }
7915                }
7916                ObjectType::ContinualTask => {
7917                    let in_cluster = self.parse_optional_in_cluster()?;
7918                    ShowObjectType::ContinualTask { in_cluster }
7919                }
7920                ObjectType::Index => {
7921                    let on_object = if self.parse_one_of_keywords(&[ON]).is_some() {
7922                        Some(self.parse_raw_name()?)
7923                    } else {
7924                        None
7925                    };
7926
7927                    if from.is_some() && on_object.is_some() {
7928                        return parser_err!(
7929                            self,
7930                            self.peek_prev_pos(),
7931                            "Cannot specify both FROM and ON"
7932                        );
7933                    }
7934
7935                    let in_cluster = self.parse_optional_in_cluster()?;
7936                    ShowObjectType::Index {
7937                        in_cluster,
7938                        on_object,
7939                    }
7940                }
7941                ObjectType::Func => {
7942                    return parser_err!(
7943                        self,
7944                        self.peek_prev_pos(),
7945                        format!("Unsupported SHOW on {object_type}")
7946                    );
7947                }
7948            };
7949            Ok(ShowStatement::ShowObjects(ShowObjectsStatement {
7950                object_type: show_object_type,
7951                from,
7952                filter: self.parse_show_statement_filter()?,
7953            }))
7954        } else if self.parse_keyword(CLUSTER) {
7955            Ok(ShowStatement::ShowVariable(ShowVariableStatement {
7956                variable: ident!("cluster"),
7957            }))
7958        } else if self.parse_keyword(PRIVILEGES) {
7959            self.parse_show_privileges()
7960        } else if self.parse_keywords(&[DEFAULT, PRIVILEGES]) {
7961            self.parse_show_default_privileges()
7962        } else if self.parse_keyword(ROLE) {
7963            self.expect_keyword(MEMBERSHIP)?;
7964            let role = if self.parse_keyword(FOR) {
7965                Some(self.parse_identifier()?)
7966            } else {
7967                None
7968            };
7969            Ok(ShowStatement::ShowObjects(ShowObjectsStatement {
7970                object_type: ShowObjectType::RoleMembership { role },
7971                from: None,
7972                filter: self.parse_show_statement_filter()?,
7973            }))
7974        } else if self.parse_keywords(&[CREATE, VIEW]) {
7975            Ok(ShowStatement::ShowCreateView(ShowCreateViewStatement {
7976                view_name: self.parse_raw_name()?,
7977                redacted,
7978            }))
7979        } else if self.parse_keywords(&[CREATE, MATERIALIZED, VIEW]) {
7980            Ok(ShowStatement::ShowCreateMaterializedView(
7981                ShowCreateMaterializedViewStatement {
7982                    materialized_view_name: self.parse_raw_name()?,
7983                    redacted,
7984                },
7985            ))
7986        } else if self.parse_keywords(&[CREATE, SOURCE]) {
7987            Ok(ShowStatement::ShowCreateSource(ShowCreateSourceStatement {
7988                source_name: self.parse_raw_name()?,
7989                redacted,
7990            }))
7991        } else if self.parse_keywords(&[CREATE, TABLE]) {
7992            Ok(ShowStatement::ShowCreateTable(ShowCreateTableStatement {
7993                table_name: self.parse_raw_name()?,
7994                redacted,
7995            }))
7996        } else if self.parse_keywords(&[CREATE, SINK]) {
7997            Ok(ShowStatement::ShowCreateSink(ShowCreateSinkStatement {
7998                sink_name: self.parse_raw_name()?,
7999                redacted,
8000            }))
8001        } else if self.parse_keywords(&[CREATE, INDEX]) {
8002            Ok(ShowStatement::ShowCreateIndex(ShowCreateIndexStatement {
8003                index_name: self.parse_raw_name()?,
8004                redacted,
8005            }))
8006        } else if self.parse_keywords(&[CREATE, CONNECTION]) {
8007            Ok(ShowStatement::ShowCreateConnection(
8008                ShowCreateConnectionStatement {
8009                    connection_name: self.parse_raw_name()?,
8010                    redacted,
8011                },
8012            ))
8013        } else if self.parse_keywords(&[CREATE, CLUSTER]) {
8014            if redacted {
8015                return parser_err!(
8016                    self,
8017                    self.peek_prev_pos(),
8018                    "SHOW REDACTED CREATE CLUSTER is not supported"
8019                );
8020            }
8021            Ok(ShowStatement::ShowCreateCluster(
8022                ShowCreateClusterStatement {
8023                    cluster_name: RawClusterName::Unresolved(self.parse_identifier()?),
8024                },
8025            ))
8026        } else {
8027            let variable = if self.parse_keywords(&[TRANSACTION, ISOLATION, LEVEL]) {
8028                ident!("transaction_isolation")
8029            } else if self.parse_keywords(&[TIME, ZONE]) {
8030                ident!("timezone")
8031            } else {
8032                self.parse_identifier()?
8033            };
8034            Ok(ShowStatement::ShowVariable(ShowVariableStatement {
8035                variable,
8036            }))
8037        }
8038    }
8039
8040    fn parse_show_columns(&mut self) -> Result<ShowStatement<Raw>, ParserError> {
8041        self.expect_one_of_keywords(&[FROM, IN])?;
8042        let table_name = self.parse_raw_name()?;
8043        // MySQL also supports FROM <database> here. In other words, MySQL
8044        // allows both FROM <table> FROM <database> and FROM <database>.<table>,
8045        // while we only support the latter for now.
8046        let filter = self.parse_show_statement_filter()?;
8047        Ok(ShowStatement::ShowColumns(ShowColumnsStatement {
8048            table_name,
8049            filter,
8050        }))
8051    }
8052
8053    fn parse_show_statement_filter(
8054        &mut self,
8055    ) -> Result<Option<ShowStatementFilter<Raw>>, ParserError> {
8056        if self.parse_keyword(LIKE) {
8057            Ok(Some(ShowStatementFilter::Like(
8058                self.parse_literal_string()?,
8059            )))
8060        } else if self.parse_keyword(WHERE) {
8061            Ok(Some(ShowStatementFilter::Where(self.parse_expr()?)))
8062        } else {
8063            Ok(None)
8064        }
8065    }
8066
8067    fn parse_show_privileges(&mut self) -> Result<ShowStatement<Raw>, ParserError> {
8068        let object_type = if self.parse_keyword(ON) {
8069            Some(self.expect_plural_system_object_type_for_privileges()?)
8070        } else {
8071            None
8072        };
8073        let role = if self.parse_keyword(FOR) {
8074            Some(self.parse_identifier()?)
8075        } else {
8076            None
8077        };
8078        Ok(ShowStatement::ShowObjects(ShowObjectsStatement {
8079            object_type: ShowObjectType::Privileges { object_type, role },
8080            from: None,
8081            filter: self.parse_show_statement_filter()?,
8082        }))
8083    }
8084
8085    fn parse_show_default_privileges(&mut self) -> Result<ShowStatement<Raw>, ParserError> {
8086        let object_type = if self.parse_keyword(ON) {
8087            Some(self.expect_plural_object_type_for_privileges()?)
8088        } else {
8089            None
8090        };
8091        let role = if self.parse_keyword(FOR) {
8092            Some(self.parse_identifier()?)
8093        } else {
8094            None
8095        };
8096        Ok(ShowStatement::ShowObjects(ShowObjectsStatement {
8097            object_type: ShowObjectType::DefaultPrivileges { object_type, role },
8098            from: None,
8099            filter: self.parse_show_statement_filter()?,
8100        }))
8101    }
8102
8103    fn parse_inspect(&mut self) -> Result<ShowStatement<Raw>, ParserError> {
8104        self.expect_keyword(SHARD)?;
8105        let id = self.parse_literal_string()?;
8106        Ok(ShowStatement::InspectShard(InspectShardStatement { id }))
8107    }
8108
8109    fn parse_table_and_joins(&mut self) -> Result<TableWithJoins<Raw>, ParserError> {
8110        let relation = self.parse_table_factor()?;
8111
8112        // Note that for keywords to be properly handled here, they need to be
8113        // added to `RESERVED_FOR_TABLE_ALIAS`, otherwise they may be parsed as
8114        // a table alias.
8115        let mut joins = vec![];
8116        loop {
8117            let join = if self.parse_keyword(CROSS) {
8118                self.expect_keyword(JOIN)?;
8119                Join {
8120                    relation: self.parse_table_factor()?,
8121                    join_operator: JoinOperator::CrossJoin,
8122                }
8123            } else {
8124                let natural = self.parse_keyword(NATURAL);
8125                let peek_keyword = if let Some(Token::Keyword(kw)) = self.peek_token() {
8126                    Some(kw)
8127                } else {
8128                    None
8129                };
8130
8131                let join_operator_type = match peek_keyword {
8132                    Some(INNER) | Some(JOIN) => {
8133                        let _ = self.parse_keyword(INNER);
8134                        self.expect_keyword(JOIN)?;
8135                        JoinOperator::Inner
8136                    }
8137                    Some(kw @ LEFT) | Some(kw @ RIGHT) | Some(kw @ FULL) => {
8138                        let _ = self.next_token();
8139                        let _ = self.parse_keyword(OUTER);
8140                        self.expect_keyword(JOIN)?;
8141                        match kw {
8142                            LEFT => JoinOperator::LeftOuter,
8143                            RIGHT => JoinOperator::RightOuter,
8144                            FULL => JoinOperator::FullOuter,
8145                            _ => unreachable!(),
8146                        }
8147                    }
8148                    Some(OUTER) => {
8149                        return self.expected(
8150                            self.peek_pos(),
8151                            "LEFT, RIGHT, or FULL",
8152                            self.peek_token(),
8153                        );
8154                    }
8155                    None if natural => {
8156                        return self.expected(
8157                            self.peek_pos(),
8158                            "a join type after NATURAL",
8159                            self.peek_token(),
8160                        );
8161                    }
8162                    _ => break,
8163                };
8164                let relation = self.parse_table_factor()?;
8165                let join_constraint = self.parse_join_constraint(natural)?;
8166                Join {
8167                    relation,
8168                    join_operator: join_operator_type(join_constraint),
8169                }
8170            };
8171            joins.push(join);
8172        }
8173        Ok(TableWithJoins { relation, joins })
8174    }
8175
8176    /// A table name or a parenthesized subquery, followed by optional `[AS] alias`
8177    fn parse_table_factor(&mut self) -> Result<TableFactor<Raw>, ParserError> {
8178        if self.parse_keyword(LATERAL) {
8179            // LATERAL must always be followed by a subquery or table function.
8180            if self.consume_token(&Token::LParen) {
8181                return self.parse_derived_table_factor(Lateral);
8182            } else if self.parse_keywords(&[ROWS, FROM]) {
8183                return self.parse_rows_from();
8184            } else {
8185                let name = self.parse_raw_name()?;
8186                self.expect_token(&Token::LParen)?;
8187                let args = self.parse_optional_args(false)?;
8188                let (with_ordinality, alias) = self.parse_table_function_suffix()?;
8189                return Ok(TableFactor::Function {
8190                    function: Function {
8191                        name,
8192                        args,
8193                        filter: None,
8194                        over: None,
8195                        distinct: false,
8196                    },
8197                    alias,
8198                    with_ordinality,
8199                });
8200            }
8201        }
8202
8203        if self.consume_token(&Token::LParen) {
8204            // A left paren introduces either a derived table (i.e., a subquery)
8205            // or a nested join. It's nearly impossible to determine ahead of
8206            // time which it is... so we just try to parse both.
8207            //
8208            // Here's an example that demonstrates the complexity:
8209            //                     /-------------------------------------------------------\
8210            //                     | /-----------------------------------\                 |
8211            //     SELECT * FROM ( ( ( (SELECT 1) UNION (SELECT 2) ) AS t1 NATURAL JOIN t2 ) )
8212            //                   ^ ^ ^ ^
8213            //                   | | | |
8214            //                   | | | |
8215            //                   | | | (4) belongs to a SetExpr::Query inside the subquery
8216            //                   | | (3) starts a derived table (subquery)
8217            //                   | (2) starts a nested join
8218            //                   (1) an additional set of parens around a nested join
8219            //
8220
8221            // Check if the recently consumed '(' started a derived table, in
8222            // which case we've parsed the subquery, followed by the closing
8223            // ')', and the alias of the derived table. In the example above
8224            // this is case (3), and the next token would be `NATURAL`.
8225            maybe!(self.maybe_parse(|parser| parser.parse_derived_table_factor(NotLateral)));
8226
8227            // The '(' we've recently consumed does not start a derived table.
8228            // For valid input this can happen either when the token following
8229            // the paren can't start a query (e.g. `foo` in `FROM (foo NATURAL
8230            // JOIN bar)`, or when the '(' we've consumed is followed by another
8231            // '(' that starts a derived table, like (3), or another nested join
8232            // (2).
8233            //
8234            // Ignore the error and back up to where we were before. Either
8235            // we'll be able to parse a valid nested join, or we won't, and
8236            // we'll return that error instead.
8237            let table_and_joins = self.parse_table_and_joins()?;
8238            match table_and_joins.relation {
8239                TableFactor::NestedJoin { .. } => (),
8240                _ => {
8241                    if table_and_joins.joins.is_empty() {
8242                        // The SQL spec prohibits derived tables and bare
8243                        // tables from appearing alone in parentheses.
8244                        self.expected(self.peek_pos(), "joined table", self.peek_token())?
8245                    }
8246                }
8247            }
8248            self.expect_token(&Token::RParen)?;
8249            Ok(TableFactor::NestedJoin {
8250                join: Box::new(table_and_joins),
8251                alias: self.parse_optional_table_alias()?,
8252            })
8253        } else if self.parse_keywords(&[ROWS, FROM]) {
8254            Ok(self.parse_rows_from()?)
8255        } else {
8256            let name = self.parse_raw_name()?;
8257            if self.consume_token(&Token::LParen) {
8258                let args = self.parse_optional_args(false)?;
8259                let (with_ordinality, alias) = self.parse_table_function_suffix()?;
8260                Ok(TableFactor::Function {
8261                    function: Function {
8262                        name,
8263                        args,
8264                        filter: None,
8265                        over: None,
8266                        distinct: false,
8267                    },
8268                    alias,
8269                    with_ordinality,
8270                })
8271            } else {
8272                Ok(TableFactor::Table {
8273                    name,
8274                    alias: self.parse_optional_table_alias()?,
8275                })
8276            }
8277        }
8278    }
8279
8280    fn parse_rows_from(&mut self) -> Result<TableFactor<Raw>, ParserError> {
8281        self.expect_token(&Token::LParen)?;
8282        let functions = self.parse_comma_separated(Parser::parse_named_function)?;
8283        self.expect_token(&Token::RParen)?;
8284        let (with_ordinality, alias) = self.parse_table_function_suffix()?;
8285        Ok(TableFactor::RowsFrom {
8286            functions,
8287            alias,
8288            with_ordinality,
8289        })
8290    }
8291
8292    /// Parses the things that can come after the argument list of a table function call. These are
8293    /// - optional WITH ORDINALITY
8294    /// - optional table alias
8295    /// - optional WITH ORDINALITY again! This is allowed just to keep supporting our earlier buggy
8296    ///   order where we allowed WITH ORDINALITY only after the table alias. (Postgres and other
8297    ///   systems support it only before the table alias.)
8298    fn parse_table_function_suffix(&mut self) -> Result<(bool, Option<TableAlias>), ParserError> {
8299        let with_ordinality_1 = self.parse_keywords(&[WITH, ORDINALITY]);
8300        let alias = self.parse_optional_table_alias()?;
8301        let with_ordinality_2 = self.parse_keywords(&[WITH, ORDINALITY]);
8302        if with_ordinality_1 && with_ordinality_2 {
8303            return parser_err!(
8304                self,
8305                self.peek_prev_pos(),
8306                "WITH ORDINALITY specified twice"
8307            );
8308        }
8309        Ok((with_ordinality_1 || with_ordinality_2, alias))
8310    }
8311
8312    fn parse_named_function(&mut self) -> Result<Function<Raw>, ParserError> {
8313        let name = self.parse_raw_name()?;
8314        self.parse_function(name)
8315    }
8316
8317    fn parse_derived_table_factor(
8318        &mut self,
8319        lateral: IsLateral,
8320    ) -> Result<TableFactor<Raw>, ParserError> {
8321        let subquery = Box::new(self.parse_query()?);
8322        self.expect_token(&Token::RParen)?;
8323        let alias = self.parse_optional_table_alias()?;
8324        Ok(TableFactor::Derived {
8325            lateral: match lateral {
8326                Lateral => true,
8327                NotLateral => false,
8328            },
8329            subquery,
8330            alias,
8331        })
8332    }
8333
8334    fn parse_join_constraint(&mut self, natural: bool) -> Result<JoinConstraint<Raw>, ParserError> {
8335        if natural {
8336            Ok(JoinConstraint::Natural)
8337        } else if self.parse_keyword(ON) {
8338            let constraint = self.parse_expr()?;
8339            Ok(JoinConstraint::On(constraint))
8340        } else if self.parse_keyword(USING) {
8341            let columns = self.parse_parenthesized_column_list(Mandatory)?;
8342            let alias = self.parse_optional_alias(Keyword::is_reserved_in_table_alias)?;
8343
8344            Ok(JoinConstraint::Using { columns, alias })
8345        } else {
8346            self.expected(
8347                self.peek_pos(),
8348                "ON, or USING after JOIN",
8349                self.peek_token(),
8350            )
8351        }
8352    }
8353
8354    /// Parse an INSERT statement
8355    fn parse_insert(&mut self) -> Result<Statement<Raw>, ParserError> {
8356        self.expect_keyword(INTO)?;
8357        let table_name = self.parse_raw_name()?;
8358        let columns = self.parse_parenthesized_column_list(Optional)?;
8359        let source = if self.parse_keywords(&[DEFAULT, VALUES]) {
8360            InsertSource::DefaultValues
8361        } else {
8362            InsertSource::Query(self.parse_query()?)
8363        };
8364        let returning = self.parse_returning()?;
8365        Ok(Statement::Insert(InsertStatement {
8366            table_name,
8367            columns,
8368            source,
8369            returning,
8370        }))
8371    }
8372
8373    fn parse_returning(&mut self) -> Result<Vec<SelectItem<Raw>>, ParserError> {
8374        Ok(if self.parse_keyword(RETURNING) {
8375            self.parse_comma_separated(Parser::parse_select_item)?
8376        } else {
8377            Vec::new()
8378        })
8379    }
8380
8381    fn parse_update(&mut self) -> Result<Statement<Raw>, ParserError> {
8382        let table_name = RawItemName::Name(self.parse_item_name()?);
8383        // The alias here doesn't support columns, so don't use parse_optional_table_alias.
8384        let alias = self.parse_optional_alias(Keyword::is_reserved_in_table_alias)?;
8385        let alias = alias.map(|name| TableAlias {
8386            name,
8387            columns: Vec::new(),
8388            strict: false,
8389        });
8390
8391        self.expect_keyword(SET)?;
8392        let assignments = self.parse_comma_separated(Parser::parse_assignment)?;
8393        let selection = if self.parse_keyword(WHERE) {
8394            Some(self.parse_expr()?)
8395        } else {
8396            None
8397        };
8398
8399        Ok(Statement::Update(UpdateStatement {
8400            table_name,
8401            alias,
8402            assignments,
8403            selection,
8404        }))
8405    }
8406
8407    /// Parse a `var = expr` assignment, used in an UPDATE statement
8408    fn parse_assignment(&mut self) -> Result<Assignment<Raw>, ParserError> {
8409        let id = self.parse_identifier()?;
8410        self.expect_token(&Token::Eq)?;
8411        let value = self.parse_expr()?;
8412        Ok(Assignment { id, value })
8413    }
8414
8415    fn parse_optional_args(
8416        &mut self,
8417        allow_order_by: bool,
8418    ) -> Result<FunctionArgs<Raw>, ParserError> {
8419        if self.consume_token(&Token::Star) {
8420            self.expect_token(&Token::RParen)?;
8421            Ok(FunctionArgs::Star)
8422        } else if self.consume_token(&Token::RParen) {
8423            Ok(FunctionArgs::args(vec![]))
8424        } else {
8425            let args = self.parse_comma_separated(Parser::parse_expr)?;
8426            // ORDER BY can only appear after at least one argument, and not after a
8427            // star. We can ignore checking for it in the other branches. See:
8428            // https://www.postgresql.org/docs/current/sql-expressions.html#SYNTAX-AGGREGATES
8429            let order_by = if allow_order_by && self.parse_keywords(&[ORDER, BY]) {
8430                self.parse_comma_separated(Parser::parse_order_by_expr)?
8431            } else {
8432                vec![]
8433            };
8434            self.expect_token(&Token::RParen)?;
8435            Ok(FunctionArgs::Args { args, order_by })
8436        }
8437    }
8438
8439    /// Parse `AS OF`, if present.
8440    fn parse_optional_as_of(&mut self) -> Result<Option<AsOf<Raw>>, ParserError> {
8441        if self.parse_keyword(AS) {
8442            self.expect_keyword(OF)?;
8443            if self.parse_keywords(&[AT, LEAST]) {
8444                match self.parse_expr() {
8445                    Ok(expr) => Ok(Some(AsOf::AtLeast(expr))),
8446                    Err(e) => self.expected(
8447                        e.pos,
8448                        "a timestamp value after 'AS OF AT LEAST'",
8449                        self.peek_token(),
8450                    ),
8451                }
8452            } else {
8453                match self.parse_expr() {
8454                    Ok(expr) => Ok(Some(AsOf::At(expr))),
8455                    Err(e) => {
8456                        self.expected(e.pos, "a timestamp value after 'AS OF'", self.peek_token())
8457                    }
8458                }
8459            }
8460        } else {
8461            Ok(None)
8462        }
8463    }
8464
8465    /// Parse `UP TO`, if present
8466    fn parse_optional_up_to(&mut self) -> Result<Option<Expr<Raw>>, ParserError> {
8467        if self.parse_keyword(UP) {
8468            self.expect_keyword(TO)?;
8469            self.parse_expr().map(Some)
8470        } else {
8471            Ok(None)
8472        }
8473    }
8474
8475    /// Parse `AS OF`, if present.
8476    ///
8477    /// In contrast to `parse_optional_as_of`, this parser only supports `AS OF <time>` syntax and
8478    /// directly returns an `u64`. It is only meant to be used for internal SQL syntax.
8479    fn parse_optional_internal_as_of(&mut self) -> Result<Option<u64>, ParserError> {
8480        fn try_parse_u64(parser: &mut Parser) -> Option<u64> {
8481            let value = parser.parse_value().ok()?;
8482            let Value::Number(s) = value else { return None };
8483            s.parse().ok()
8484        }
8485
8486        if self.parse_keywords(&[AS, OF]) {
8487            match try_parse_u64(self) {
8488                Some(time) => Ok(Some(time)),
8489                None => {
8490                    self.prev_token();
8491                    self.expected(self.peek_pos(), "`u64` literal", self.peek_token())
8492                }
8493            }
8494        } else {
8495            Ok(None)
8496        }
8497    }
8498
8499    /// Parse a comma-delimited list of projections after SELECT
8500    fn parse_select_item(&mut self) -> Result<SelectItem<Raw>, ParserError> {
8501        if self.consume_token(&Token::Star) {
8502            return Ok(SelectItem::Wildcard);
8503        }
8504        Ok(SelectItem::Expr {
8505            expr: self.parse_expr()?,
8506            alias: self.parse_optional_alias(Keyword::is_reserved_in_column_alias)?,
8507        })
8508    }
8509
8510    /// Parse an expression, optionally followed by ASC or DESC,
8511    /// and then `[NULLS { FIRST | LAST }]` (used in ORDER BY)
8512    fn parse_order_by_expr(&mut self) -> Result<OrderByExpr<Raw>, ParserError> {
8513        let expr = self.parse_expr()?;
8514
8515        let asc = if self.parse_keyword(ASC) {
8516            Some(true)
8517        } else if self.parse_keyword(DESC) {
8518            Some(false)
8519        } else {
8520            None
8521        };
8522
8523        let nulls_last = if self.parse_keyword(NULLS) {
8524            let last = self.expect_one_of_keywords(&[FIRST, LAST])? == LAST;
8525            Some(last)
8526        } else {
8527            None
8528        };
8529
8530        Ok(OrderByExpr {
8531            expr,
8532            asc,
8533            nulls_last,
8534        })
8535    }
8536
8537    fn parse_values(&mut self) -> Result<Values<Raw>, ParserError> {
8538        let values = self.parse_comma_separated(|parser| {
8539            parser.expect_token(&Token::LParen)?;
8540            let exprs = parser.parse_comma_separated(Parser::parse_expr)?;
8541            parser.expect_token(&Token::RParen)?;
8542            Ok(exprs)
8543        })?;
8544        Ok(Values(values))
8545    }
8546
8547    fn parse_start_transaction(&mut self) -> Result<Statement<Raw>, ParserError> {
8548        self.expect_keyword(TRANSACTION)?;
8549        Ok(Statement::StartTransaction(StartTransactionStatement {
8550            modes: self.parse_transaction_modes(false)?,
8551        }))
8552    }
8553
8554    fn parse_begin(&mut self) -> Result<Statement<Raw>, ParserError> {
8555        let _ = self.parse_one_of_keywords(&[TRANSACTION, WORK]);
8556        Ok(Statement::StartTransaction(StartTransactionStatement {
8557            modes: self.parse_transaction_modes(false)?,
8558        }))
8559    }
8560
8561    fn parse_transaction_modes(
8562        &mut self,
8563        mut required: bool,
8564    ) -> Result<Vec<TransactionMode>, ParserError> {
8565        let mut modes = vec![];
8566        loop {
8567            let mode = if self.parse_keywords(&[ISOLATION, LEVEL]) {
8568                let iso_level = if self.parse_keywords(&[READ, UNCOMMITTED]) {
8569                    TransactionIsolationLevel::ReadUncommitted
8570                } else if self.parse_keywords(&[READ, COMMITTED]) {
8571                    TransactionIsolationLevel::ReadCommitted
8572                } else if self.parse_keywords(&[REPEATABLE, READ]) {
8573                    TransactionIsolationLevel::RepeatableRead
8574                } else if self.parse_keyword(SERIALIZABLE) {
8575                    TransactionIsolationLevel::Serializable
8576                } else if self.parse_keywords(&[STRONG, SESSION, SERIALIZABLE]) {
8577                    TransactionIsolationLevel::StrongSessionSerializable
8578                } else if self.parse_keywords(&[STRICT, SERIALIZABLE]) {
8579                    TransactionIsolationLevel::StrictSerializable
8580                } else {
8581                    self.expected(self.peek_pos(), "isolation level", self.peek_token())?
8582                };
8583                TransactionMode::IsolationLevel(iso_level)
8584            } else if self.parse_keywords(&[READ, ONLY]) {
8585                TransactionMode::AccessMode(TransactionAccessMode::ReadOnly)
8586            } else if self.parse_keywords(&[READ, WRITE]) {
8587                TransactionMode::AccessMode(TransactionAccessMode::ReadWrite)
8588            } else if required {
8589                self.expected(self.peek_pos(), "transaction mode", self.peek_token())?
8590            } else {
8591                break;
8592            };
8593            modes.push(mode);
8594            // ANSI requires a comma after each transaction mode, but
8595            // PostgreSQL, for historical reasons, does not. We follow
8596            // PostgreSQL in making the comma optional, since that is strictly
8597            // more general.
8598            required = self.consume_token(&Token::Comma);
8599        }
8600        Ok(modes)
8601    }
8602
8603    fn parse_commit(&mut self) -> Result<Statement<Raw>, ParserError> {
8604        Ok(Statement::Commit(CommitStatement {
8605            chain: self.parse_commit_rollback_chain()?,
8606        }))
8607    }
8608
8609    fn parse_rollback(&mut self) -> Result<Statement<Raw>, ParserError> {
8610        Ok(Statement::Rollback(RollbackStatement {
8611            chain: self.parse_commit_rollback_chain()?,
8612        }))
8613    }
8614
8615    fn parse_commit_rollback_chain(&mut self) -> Result<bool, ParserError> {
8616        let _ = self.parse_one_of_keywords(&[TRANSACTION, WORK]);
8617        if self.parse_keyword(AND) {
8618            let chain = !self.parse_keyword(NO);
8619            self.expect_keyword(CHAIN)?;
8620            Ok(chain)
8621        } else {
8622            Ok(false)
8623        }
8624    }
8625
8626    fn parse_tail(&self) -> Result<Statement<Raw>, ParserError> {
8627        parser_err!(
8628            self,
8629            self.peek_prev_pos(),
8630            "TAIL has been renamed to SUBSCRIBE"
8631        )
8632    }
8633
8634    fn parse_subscribe(&mut self) -> Result<Statement<Raw>, ParserError> {
8635        let _ = self.parse_keyword(TO);
8636        let relation = if self.consume_token(&Token::LParen) {
8637            let query = self.parse_query()?;
8638            self.expect_token(&Token::RParen)?;
8639            SubscribeRelation::Query(query)
8640        } else {
8641            SubscribeRelation::Name(self.parse_raw_name()?)
8642        };
8643        let mut output = self.parse_subscribe_output()?;
8644        let options = if self.parse_keyword(WITH) {
8645            self.expect_token(&Token::LParen)?;
8646            let options = self.parse_comma_separated(Self::parse_subscribe_option)?;
8647            self.expect_token(&Token::RParen)?;
8648            options
8649        } else {
8650            vec![]
8651        };
8652        let as_of = self.parse_optional_as_of()?;
8653        let up_to = self.parse_optional_up_to()?;
8654        // For backwards compatibility, we allow parsing output options
8655        // (`ENVELOPE`, `WITHIN TIMESTAMP ORDER BY`) at the end of the
8656        // statement, if they haven't already been specified where we prefer
8657        // them, before the `WITH` options and before the `AS OF`/`UP TO`
8658        // options. Our preferred syntax better aligns with the option ordering
8659        // for `CREATE SINK` and `SELECT`.
8660        if output == SubscribeOutput::Diffs {
8661            output = self.parse_subscribe_output()?;
8662        }
8663        Ok(Statement::Subscribe(SubscribeStatement {
8664            relation,
8665            options,
8666            as_of,
8667            up_to,
8668            output,
8669        }))
8670    }
8671
8672    fn parse_subscribe_option(&mut self) -> Result<SubscribeOption<Raw>, ParserError> {
8673        let name = match self.expect_one_of_keywords(&[PROGRESS, SNAPSHOT])? {
8674            PROGRESS => SubscribeOptionName::Progress,
8675            SNAPSHOT => SubscribeOptionName::Snapshot,
8676            _ => unreachable!(),
8677        };
8678        Ok(SubscribeOption {
8679            name,
8680            value: self.parse_optional_option_value()?,
8681        })
8682    }
8683
8684    fn parse_subscribe_output(&mut self) -> Result<SubscribeOutput<Raw>, ParserError> {
8685        if self.parse_keywords(&[ENVELOPE]) {
8686            let keyword = self.expect_one_of_keywords(&[UPSERT, DEBEZIUM])?;
8687            self.expect_token(&Token::LParen)?;
8688            self.expect_keyword(KEY)?;
8689            let key_columns = self.parse_parenthesized_column_list(Mandatory)?;
8690            let output = match keyword {
8691                UPSERT => SubscribeOutput::EnvelopeUpsert { key_columns },
8692                DEBEZIUM => SubscribeOutput::EnvelopeDebezium { key_columns },
8693                _ => unreachable!("no other keyword allowed"),
8694            };
8695            self.expect_token(&Token::RParen)?;
8696            Ok(output)
8697        } else if self.parse_keywords(&[WITHIN, TIMESTAMP, ORDER, BY]) {
8698            Ok(SubscribeOutput::WithinTimestampOrderBy {
8699                order_by: self.parse_comma_separated(Parser::parse_order_by_expr)?,
8700            })
8701        } else {
8702            Ok(SubscribeOutput::Diffs)
8703        }
8704    }
8705
8706    /// Parse an `EXPLAIN` statement, assuming that the `EXPLAIN` token
8707    /// has already been consumed.
8708    fn parse_explain(&mut self) -> Result<Statement<Raw>, ParserStatementError> {
8709        if self.parse_keyword(TIMESTAMP) {
8710            self.parse_explain_timestamp()
8711                .map_parser_err(StatementKind::ExplainTimestamp)
8712        } else if self.parse_keywords(&[FILTER, PUSHDOWN]) {
8713            self.parse_explain_pushdown()
8714                .map_parser_err(StatementKind::ExplainPushdown)
8715        } else if self.parse_keyword(ANALYZE) || self.parse_keyword(ANALYSE) {
8716            self.parse_explain_analyze()
8717                .map_parser_err(StatementKind::ExplainAnalyze)
8718        } else if self.peek_keyword(KEY) || self.peek_keyword(VALUE) {
8719            self.parse_explain_schema()
8720                .map_parser_err(StatementKind::ExplainSinkSchema)
8721        } else {
8722            self.parse_explain_plan()
8723                .map_parser_err(StatementKind::ExplainPlan)
8724        }
8725    }
8726
8727    fn parse_explainee(&mut self) -> Result<Explainee<Raw>, ParserError> {
8728        let explainee = if self.parse_keyword(VIEW) {
8729            // Parse: `VIEW name`
8730            Explainee::View(self.parse_raw_name()?)
8731        } else if self.parse_keywords(&[MATERIALIZED, VIEW]) {
8732            // Parse: `MATERIALIZED VIEW name`
8733            Explainee::MaterializedView(self.parse_raw_name()?)
8734        } else if self.parse_keyword(INDEX) {
8735            // Parse: `INDEX name`
8736            Explainee::Index(self.parse_raw_name()?)
8737        } else if self.parse_keywords(&[REPLAN, VIEW]) {
8738            // Parse: `REPLAN VIEW name`
8739            Explainee::ReplanView(self.parse_raw_name()?)
8740        } else if self.parse_keywords(&[REPLAN, MATERIALIZED, VIEW]) {
8741            // Parse: `REPLAN MATERIALIZED VIEW name`
8742            Explainee::ReplanMaterializedView(self.parse_raw_name()?)
8743        } else if self.parse_keywords(&[REPLAN, INDEX]) {
8744            // Parse: `REPLAN INDEX name`
8745            Explainee::ReplanIndex(self.parse_raw_name()?)
8746        } else {
8747            let broken = self.parse_keyword(BROKEN);
8748
8749            if self.peek_keywords(&[CREATE, VIEW])
8750                || self.peek_keywords(&[CREATE, OR, REPLACE, VIEW])
8751            {
8752                // Parse: `BROKEN? CREATE [OR REPLACE] VIEW ...`
8753                let _ = self.parse_keyword(CREATE); // consume CREATE token
8754                let stmt = match self.parse_create_view()? {
8755                    Statement::CreateView(stmt) => stmt,
8756                    _ => panic!("Unexpected statement type return after parsing"),
8757                };
8758
8759                Explainee::CreateView(Box::new(stmt), broken)
8760            } else if self.peek_keywords(&[CREATE, MATERIALIZED, VIEW])
8761                || self.peek_keywords(&[CREATE, OR, REPLACE, MATERIALIZED, VIEW])
8762            {
8763                // Parse: `BROKEN? CREATE [OR REPLACE] MATERIALIZED VIEW ...`
8764                let _ = self.parse_keyword(CREATE); // consume CREATE token
8765                let stmt = match self.parse_create_materialized_view()? {
8766                    Statement::CreateMaterializedView(stmt) => stmt,
8767                    _ => panic!("Unexpected statement type return after parsing"),
8768                };
8769
8770                Explainee::CreateMaterializedView(Box::new(stmt), broken)
8771            } else if self.peek_keywords(&[CREATE, INDEX])
8772                || self.peek_keywords(&[CREATE, DEFAULT, INDEX])
8773            {
8774                // Parse: `BROKEN? CREATE INDEX ...`
8775                let _ = self.parse_keyword(CREATE); // consume CREATE token
8776                let stmt = match self.parse_create_index()? {
8777                    Statement::CreateIndex(stmt) => stmt,
8778                    _ => panic!("Unexpected statement type return after parsing"),
8779                };
8780
8781                Explainee::CreateIndex(Box::new(stmt), broken)
8782            } else {
8783                // Parse: `BROKEN? query`
8784                let query = self.parse_select_statement()?;
8785                Explainee::Select(Box::new(query), broken)
8786            }
8787        };
8788        Ok(explainee)
8789    }
8790
8791    /// Parse an `EXPLAIN ... PLAN` statement, assuming that the `EXPLAIN` token
8792    /// has already been consumed.
8793    fn parse_explain_plan(&mut self) -> Result<Statement<Raw>, ParserError> {
8794        let start = self.peek_pos();
8795        let (has_stage, stage) = match self.parse_one_of_keywords(&[
8796            RAW,
8797            DECORRELATED,
8798            LOCALLY,
8799            OPTIMIZED,
8800            PHYSICAL,
8801            OPTIMIZER,
8802            PLAN,
8803        ]) {
8804            Some(RAW) => {
8805                self.expect_keyword(PLAN)?;
8806                (true, Some(ExplainStage::RawPlan))
8807            }
8808            Some(DECORRELATED) => {
8809                self.expect_keyword(PLAN)?;
8810                (true, Some(ExplainStage::DecorrelatedPlan))
8811            }
8812            Some(LOCALLY) => {
8813                self.expect_keywords(&[OPTIMIZED, PLAN])?;
8814                (true, Some(ExplainStage::LocalPlan))
8815            }
8816            Some(OPTIMIZED) => {
8817                self.expect_keyword(PLAN)?;
8818                (true, Some(ExplainStage::GlobalPlan))
8819            }
8820            Some(PHYSICAL) => {
8821                self.expect_keyword(PLAN)?;
8822                (true, Some(ExplainStage::PhysicalPlan))
8823            }
8824            Some(OPTIMIZER) => {
8825                self.expect_keyword(TRACE)?;
8826                (true, Some(ExplainStage::Trace))
8827            }
8828            Some(PLAN) => {
8829                if self.parse_keyword(INSIGHTS) {
8830                    (true, Some(ExplainStage::PlanInsights))
8831                } else {
8832                    // Use the default plan for the explainee.
8833                    (true, None)
8834                }
8835            }
8836            None => {
8837                // Use the default plan for the explainee.
8838                (false, None)
8839            }
8840            _ => unreachable!(),
8841        };
8842
8843        let with_options = if self.parse_keyword(WITH) {
8844            if self.consume_token(&Token::LParen) {
8845                let options = self.parse_comma_separated(Parser::parse_explain_plan_option)?;
8846                self.expect_token(&Token::RParen)?;
8847                options
8848            } else {
8849                self.prev_token(); // push back WITH in case it's actually a CTE
8850                vec![]
8851            }
8852        } else {
8853            vec![]
8854        };
8855
8856        let format = if self.parse_keyword(AS) {
8857            match self.parse_one_of_keywords(&[TEXT, JSON, DOT, VERBOSE]) {
8858                Some(TEXT) => Some(ExplainFormat::Text),
8859                Some(JSON) => Some(ExplainFormat::Json),
8860                Some(DOT) => Some(ExplainFormat::Dot),
8861                Some(VERBOSE) => {
8862                    self.expect_keyword(TEXT)?;
8863                    Some(ExplainFormat::VerboseText)
8864                }
8865                None => return Err(ParserError::new(self.index, "expected a format")),
8866                _ => unreachable!(),
8867            }
8868        } else if has_stage && stage == Some(ExplainStage::PhysicalPlan) {
8869            // if EXPLAIN PHYSICAL PLAN is explicitly specified without AS, default to VERBOSE TEXT
8870            Some(ExplainFormat::VerboseText)
8871        } else {
8872            None
8873        };
8874
8875        if has_stage {
8876            self.expect_keyword(FOR)?;
8877        }
8878
8879        let explainee = self.parse_explainee()?;
8880
8881        // Explainees that represent a view only work in association with an
8882        // explicitly defined stage.
8883        if matches!((explainee.is_view(), &stage), (true, None)) {
8884            let msg = "EXPLAIN statement for a view needs an explicit stage".to_string();
8885            return Err(self.error(start, msg));
8886        }
8887
8888        Ok(Statement::ExplainPlan(ExplainPlanStatement {
8889            stage,
8890            with_options,
8891            format,
8892            explainee,
8893        }))
8894    }
8895
8896    fn parse_explain_plan_option(&mut self) -> Result<ExplainPlanOption<Raw>, ParserError> {
8897        Ok(ExplainPlanOption {
8898            name: self.parse_explain_plan_option_name()?,
8899            value: self.parse_optional_option_value()?,
8900        })
8901    }
8902
8903    /// Parse an `EXPLAIN FILTER PUSHDOWN` statement, assuming that the `EXPLAIN
8904    /// PUSHDOWN` tokens have already been consumed.
8905    fn parse_explain_pushdown(&mut self) -> Result<Statement<Raw>, ParserError> {
8906        self.expect_keyword(FOR)?;
8907
8908        let explainee = self.parse_explainee()?;
8909
8910        Ok(Statement::ExplainPushdown(ExplainPushdownStatement {
8911            explainee,
8912        }))
8913    }
8914
8915    fn parse_explain_analyze(&mut self) -> Result<Statement<Raw>, ParserError> {
8916        // EXPLAIN ANALYZE ((MEMORY | CPU) [WITH SKEW] | HINTS) FOR (INDEX ... | MATERIALIZED VIEW ...) [AS SQL]
8917
8918        let properties = if self.parse_keyword(HINTS) {
8919            ExplainAnalyzeProperty::Hints
8920        } else {
8921            let mut computation_properties = vec![CPU, MEMORY];
8922            let (kw, property) =
8923                self.parse_explain_analyze_computation_property(&computation_properties)?;
8924            let mut properties = vec![property];
8925            computation_properties.retain(|p| p != &kw);
8926
8927            while self.consume_token(&Token::Comma) {
8928                let (kw, property) =
8929                    self.parse_explain_analyze_computation_property(&computation_properties)?;
8930                computation_properties.retain(|p| p != &kw);
8931                properties.push(property);
8932            }
8933
8934            let skew = self.parse_keywords(&[WITH, SKEW]);
8935
8936            ExplainAnalyzeProperty::Computation { properties, skew }
8937        };
8938
8939        self.expect_keyword(FOR)?;
8940
8941        let explainee = match self.expect_one_of_keywords(&[INDEX, MATERIALIZED])? {
8942            INDEX => Explainee::Index(self.parse_raw_name()?),
8943            MATERIALIZED => {
8944                self.expect_keyword(VIEW)?;
8945                Explainee::MaterializedView(self.parse_raw_name()?)
8946            }
8947            _ => unreachable!(),
8948        };
8949
8950        let as_sql = self.parse_keywords(&[AS, SQL]);
8951
8952        Ok(Statement::ExplainAnalyze(ExplainAnalyzeStatement {
8953            properties,
8954            explainee,
8955            as_sql,
8956        }))
8957    }
8958
8959    fn parse_explain_analyze_computation_property(
8960        &mut self,
8961        properties: &[Keyword],
8962    ) -> Result<(Keyword, ExplainAnalyzeComputationProperty), ParserError> {
8963        if properties.is_empty() {
8964            return Err(ParserError::new(
8965                self.peek_pos(),
8966                "both CPU and MEMORY were specified, expected WITH SKEW or FOR",
8967            ));
8968        }
8969
8970        match self.expect_one_of_keywords(properties)? {
8971            CPU => Ok((CPU, ExplainAnalyzeComputationProperty::Cpu)),
8972            MEMORY => Ok((MEMORY, ExplainAnalyzeComputationProperty::Memory)),
8973            _ => unreachable!(),
8974        }
8975    }
8976
8977    /// Parse an `EXPLAIN TIMESTAMP` statement, assuming that the `EXPLAIN
8978    /// TIMESTAMP` tokens have already been consumed.
8979    fn parse_explain_timestamp(&mut self) -> Result<Statement<Raw>, ParserError> {
8980        let format = if self.parse_keyword(AS) {
8981            match self.parse_one_of_keywords(&[TEXT, JSON, DOT]) {
8982                Some(TEXT) => Some(ExplainFormat::Text),
8983                Some(JSON) => Some(ExplainFormat::Json),
8984                None => return Err(ParserError::new(self.index, "expected a format")),
8985                _ => unreachable!(),
8986            }
8987        } else {
8988            None
8989        };
8990
8991        self.expect_keyword(FOR)?;
8992
8993        let query = self.parse_select_statement()?;
8994
8995        Ok(Statement::ExplainTimestamp(ExplainTimestampStatement {
8996            format,
8997            select: query,
8998        }))
8999    }
9000    /// Parse an `EXPLAIN [KEY|VALUE] SCHEMA` statement assuming that the `EXPLAIN` token
9001    /// have already been consumed
9002    fn parse_explain_schema(&mut self) -> Result<Statement<Raw>, ParserError> {
9003        let schema_for = match self.expect_one_of_keywords(&[KEY, VALUE])? {
9004            KEY => ExplainSinkSchemaFor::Key,
9005            VALUE => ExplainSinkSchemaFor::Value,
9006            _ => unreachable!(),
9007        };
9008
9009        self.expect_keyword(SCHEMA)?;
9010
9011        let format = if self.parse_keyword(AS) {
9012            // only json format is supported
9013            self.expect_keyword(JSON)?;
9014            Some(ExplainFormat::Json)
9015        } else {
9016            None
9017        };
9018
9019        self.expect_keywords(&[FOR, CREATE])?;
9020
9021        if let Statement::CreateSink(statement) = self.parse_create_sink()? {
9022            Ok(Statement::ExplainSinkSchema(ExplainSinkSchemaStatement {
9023                schema_for,
9024                format,
9025                statement,
9026            }))
9027        } else {
9028            unreachable!("only create sink can be returned here");
9029        }
9030    }
9031
9032    /// Parse a `DECLARE` statement, assuming that the `DECLARE` token
9033    /// has already been consumed.
9034    fn parse_declare(&mut self) -> Result<Statement<Raw>, ParserStatementError> {
9035        let name = self
9036            .parse_identifier()
9037            .map_parser_err(StatementKind::Declare)?;
9038        self.expect_keyword(CURSOR)
9039            .map_parser_err(StatementKind::Declare)?;
9040        if self.parse_keyword(WITH) {
9041            let err = parser_err!(
9042                self,
9043                self.peek_prev_pos(),
9044                format!("WITH HOLD is unsupported for cursors")
9045            )
9046            .map_parser_err(StatementKind::Declare);
9047            self.expect_keyword(HOLD)
9048                .map_parser_err(StatementKind::Declare)?;
9049            return err;
9050        }
9051        // WITHOUT HOLD is optional and the default behavior so we can ignore it.
9052        let _ = self.parse_keywords(&[WITHOUT, HOLD]);
9053        self.expect_keyword(FOR)
9054            .map_parser_err(StatementKind::Declare)?;
9055        let StatementParseResult { ast, sql } = self.parse_statement()?;
9056        Ok(Statement::Declare(DeclareStatement {
9057            name,
9058            stmt: Box::new(ast),
9059            sql: sql.to_string(),
9060        }))
9061    }
9062
9063    /// Parse a `CLOSE` statement, assuming that the `CLOSE` token
9064    /// has already been consumed.
9065    fn parse_close(&mut self) -> Result<Statement<Raw>, ParserError> {
9066        let name = self.parse_identifier()?;
9067        Ok(Statement::Close(CloseStatement { name }))
9068    }
9069
9070    /// Parse a `PREPARE` statement, assuming that the `PREPARE` token
9071    /// has already been consumed.
9072    fn parse_prepare(&mut self) -> Result<Statement<Raw>, ParserStatementError> {
9073        let name = self
9074            .parse_identifier()
9075            .map_parser_err(StatementKind::Prepare)?;
9076        self.expect_keyword(AS)
9077            .map_parser_err(StatementKind::Prepare)?;
9078        let pos = self.peek_pos();
9079        //
9080        let StatementParseResult { ast, sql } = self.parse_statement()?;
9081        if !matches!(
9082            ast,
9083            Statement::Select(_)
9084                | Statement::Insert(_)
9085                | Statement::Delete(_)
9086                | Statement::Update(_),
9087        ) {
9088            return parser_err!(self, pos, "unpreparable statement").map_no_statement_parser_err();
9089        }
9090        Ok(Statement::Prepare(PrepareStatement {
9091            name,
9092            stmt: Box::new(ast),
9093            sql: sql.to_string(),
9094        }))
9095    }
9096
9097    /// Parse a `EXECUTE` statement, assuming that the `EXECUTE` token
9098    /// has already been consumed.
9099    fn parse_execute(&mut self) -> Result<Statement<Raw>, ParserError> {
9100        let name = self.parse_identifier()?;
9101        let params = if self.consume_token(&Token::LParen) {
9102            let params = self.parse_comma_separated(Parser::parse_expr)?;
9103            self.expect_token(&Token::RParen)?;
9104            params
9105        } else {
9106            Vec::new()
9107        };
9108        Ok(Statement::Execute(ExecuteStatement { name, params }))
9109    }
9110
9111    /// Parse a `DEALLOCATE` statement, assuming that the `DEALLOCATE` token
9112    /// has already been consumed.
9113    fn parse_deallocate(&mut self) -> Result<Statement<Raw>, ParserError> {
9114        let _ = self.parse_keyword(PREPARE);
9115        let name = if self.parse_keyword(ALL) {
9116            None
9117        } else {
9118            Some(self.parse_identifier()?)
9119        };
9120        Ok(Statement::Deallocate(DeallocateStatement { name }))
9121    }
9122
9123    /// Parse a `FETCH` statement, assuming that the `FETCH` token
9124    /// has already been consumed.
9125    fn parse_fetch(&mut self) -> Result<Statement<Raw>, ParserError> {
9126        let _ = self.parse_keyword(FORWARD);
9127        let count = if let Some(count) = self.maybe_parse(Parser::parse_literal_uint) {
9128            Some(FetchDirection::ForwardCount(count))
9129        } else if self.parse_keyword(ALL) {
9130            Some(FetchDirection::ForwardAll)
9131        } else {
9132            None
9133        };
9134        let _ = self.parse_keyword(FROM);
9135        let name = self.parse_identifier()?;
9136        let options = if self.parse_keyword(WITH) {
9137            self.expect_token(&Token::LParen)?;
9138            let options = self.parse_comma_separated(Self::parse_fetch_option)?;
9139            self.expect_token(&Token::RParen)?;
9140            options
9141        } else {
9142            vec![]
9143        };
9144        Ok(Statement::Fetch(FetchStatement {
9145            name,
9146            count,
9147            options,
9148        }))
9149    }
9150
9151    fn parse_fetch_option(&mut self) -> Result<FetchOption<Raw>, ParserError> {
9152        self.expect_keyword(TIMEOUT)?;
9153        Ok(FetchOption {
9154            name: FetchOptionName::Timeout,
9155            value: self.parse_optional_option_value()?,
9156        })
9157    }
9158
9159    /// Parse a `RAISE` statement, assuming that the `RAISE` token
9160    /// has already been consumed.
9161    fn parse_raise(&mut self) -> Result<Statement<Raw>, ParserError> {
9162        let severity = match self.parse_one_of_keywords(&[DEBUG, INFO, LOG, NOTICE, WARNING]) {
9163            Some(DEBUG) => NoticeSeverity::Debug,
9164            Some(INFO) => NoticeSeverity::Info,
9165            Some(LOG) => NoticeSeverity::Log,
9166            Some(NOTICE) => NoticeSeverity::Notice,
9167            Some(WARNING) => NoticeSeverity::Warning,
9168            Some(_) => unreachable!(),
9169            None => self.expected(self.peek_pos(), "severity level", self.peek_token())?,
9170        };
9171
9172        Ok(Statement::Raise(RaiseStatement { severity }))
9173    }
9174
9175    /// Parse a `GRANT` statement, assuming that the `GRANT` token
9176    /// has already been consumed.
9177    fn parse_grant(&mut self) -> Result<Statement<Raw>, ParserStatementError> {
9178        match self.parse_privilege_specification() {
9179            Some(privileges) => self
9180                .parse_grant_privilege(privileges)
9181                .map_parser_err(StatementKind::GrantPrivileges),
9182            None => self
9183                .parse_grant_role()
9184                .map_parser_err(StatementKind::GrantRole),
9185        }
9186    }
9187
9188    /// Parse a `GRANT PRIVILEGE` statement, assuming that the `GRANT` token
9189    /// and all privileges have already been consumed.
9190    fn parse_grant_privilege(
9191        &mut self,
9192        privileges: PrivilegeSpecification,
9193    ) -> Result<Statement<Raw>, ParserError> {
9194        self.expect_keyword(ON)?;
9195        let target = self.expect_grant_target_specification("GRANT")?;
9196        self.expect_keyword(TO)?;
9197        let roles = self.parse_comma_separated(Parser::expect_role_specification)?;
9198        Ok(Statement::GrantPrivileges(GrantPrivilegesStatement {
9199            privileges,
9200            target,
9201            roles,
9202        }))
9203    }
9204
9205    /// Parse a `GRANT ROLE` statement, assuming that the `GRANT` token
9206    /// has already been consumed.
9207    fn parse_grant_role(&mut self) -> Result<Statement<Raw>, ParserError> {
9208        let role_names = self.parse_comma_separated(Parser::parse_identifier)?;
9209        self.expect_keyword(TO)?;
9210        let member_names = self.parse_comma_separated(Parser::expect_role_specification)?;
9211        Ok(Statement::GrantRole(GrantRoleStatement {
9212            role_names,
9213            member_names,
9214        }))
9215    }
9216
9217    /// Parse a `REVOKE` statement, assuming that the `REVOKE` token
9218    /// has already been consumed.
9219    fn parse_revoke(&mut self) -> Result<Statement<Raw>, ParserStatementError> {
9220        match self.parse_privilege_specification() {
9221            Some(privileges) => self
9222                .parse_revoke_privilege(privileges)
9223                .map_parser_err(StatementKind::RevokePrivileges),
9224            None => self
9225                .parse_revoke_role()
9226                .map_parser_err(StatementKind::RevokeRole),
9227        }
9228    }
9229
9230    /// Parse a `REVOKE PRIVILEGE` statement, assuming that the `REVOKE` token
9231    /// and all privileges have already been consumed.
9232    fn parse_revoke_privilege(
9233        &mut self,
9234        privileges: PrivilegeSpecification,
9235    ) -> Result<Statement<Raw>, ParserError> {
9236        self.expect_keyword(ON)?;
9237        let target = self.expect_grant_target_specification("REVOKE")?;
9238        self.expect_keyword(FROM)?;
9239        let roles = self.parse_comma_separated(Parser::expect_role_specification)?;
9240        Ok(Statement::RevokePrivileges(RevokePrivilegesStatement {
9241            privileges,
9242            target,
9243            roles,
9244        }))
9245    }
9246
9247    /// Parse a `REVOKE ROLE` statement, assuming that the `REVOKE` token
9248    /// has already been consumed.
9249    fn parse_revoke_role(&mut self) -> Result<Statement<Raw>, ParserError> {
9250        let role_names = self.parse_comma_separated(Parser::parse_identifier)?;
9251        self.expect_keyword(FROM)?;
9252        let member_names = self.parse_comma_separated(Parser::expect_role_specification)?;
9253        Ok(Statement::RevokeRole(RevokeRoleStatement {
9254            role_names,
9255            member_names,
9256        }))
9257    }
9258
9259    fn expect_grant_target_specification(
9260        &mut self,
9261        statement_type: &str,
9262    ) -> Result<GrantTargetSpecification<Raw>, ParserError> {
9263        if self.parse_keyword(SYSTEM) {
9264            return Ok(GrantTargetSpecification::System);
9265        }
9266
9267        let (object_type, object_spec_inner) = if self.parse_keyword(ALL) {
9268            let object_type = self.expect_grant_revoke_plural_object_type(statement_type)?;
9269            let object_spec_inner = if self.parse_keyword(IN) {
9270                if !object_type.lives_in_schema() && object_type != ObjectType::Schema {
9271                    return parser_err!(
9272                        self,
9273                        self.peek_prev_pos(),
9274                        format!("IN invalid for {object_type}S")
9275                    );
9276                }
9277                match self.expect_one_of_keywords(&[DATABASE, SCHEMA])? {
9278                    DATABASE => GrantTargetSpecificationInner::All(
9279                        GrantTargetAllSpecification::AllDatabases {
9280                            databases: self.parse_comma_separated(Parser::parse_database_name)?,
9281                        },
9282                    ),
9283                    SCHEMA => {
9284                        if object_type == ObjectType::Schema {
9285                            self.prev_token();
9286                            self.expected(self.peek_pos(), DATABASE, self.peek_token())?;
9287                        }
9288                        GrantTargetSpecificationInner::All(
9289                            GrantTargetAllSpecification::AllSchemas {
9290                                schemas: self.parse_comma_separated(Parser::parse_schema_name)?,
9291                            },
9292                        )
9293                    }
9294                    _ => unreachable!(),
9295                }
9296            } else {
9297                GrantTargetSpecificationInner::All(GrantTargetAllSpecification::All)
9298            };
9299            (object_type, object_spec_inner)
9300        } else {
9301            let object_type = self.expect_grant_revoke_object_type(statement_type)?;
9302            let object_spec_inner = GrantTargetSpecificationInner::Objects {
9303                names: self
9304                    .parse_comma_separated(|parser| parser.parse_object_name(object_type))?,
9305            };
9306            (object_type, object_spec_inner)
9307        };
9308
9309        Ok(GrantTargetSpecification::Object {
9310            object_type,
9311            object_spec_inner,
9312        })
9313    }
9314
9315    /// Bail out if the current token is not an object type suitable for a GRANT/REVOKE, or consume
9316    /// and return it if it is.
9317    fn expect_grant_revoke_object_type(
9318        &mut self,
9319        statement_type: &str,
9320    ) -> Result<ObjectType, ParserError> {
9321        // If the object type is omitted, then it is assumed to be a table.
9322        let object_type = self.parse_object_type().unwrap_or(ObjectType::Table);
9323        self.expect_grant_revoke_object_type_inner(statement_type, object_type)
9324    }
9325
9326    /// Bail out if the current token is not a plural object type suitable for a GRANT/REVOKE, or consume
9327    /// and return it if it is.
9328    fn expect_grant_revoke_plural_object_type(
9329        &mut self,
9330        statement_type: &str,
9331    ) -> Result<ObjectType, ParserError> {
9332        let object_type = self.expect_plural_object_type().map_err(|_| {
9333            // Limit the error message to allowed object types.
9334            self.expected::<_, ObjectType>(
9335                self.peek_pos(),
9336                "one of TABLES or TYPES or SECRETS or CONNECTIONS or SCHEMAS or DATABASES or CLUSTERS",
9337                self.peek_token(),
9338            )
9339                .unwrap_err()
9340        })?;
9341        self.expect_grant_revoke_object_type_inner(statement_type, object_type)?;
9342        Ok(object_type)
9343    }
9344
9345    fn expect_grant_revoke_object_type_inner(
9346        &self,
9347        statement_type: &str,
9348        object_type: ObjectType,
9349    ) -> Result<ObjectType, ParserError> {
9350        match object_type {
9351            ObjectType::View
9352            | ObjectType::MaterializedView
9353            | ObjectType::Source
9354            | ObjectType::ContinualTask => {
9355                parser_err!(
9356                    self,
9357                    self.peek_prev_pos(),
9358                    format!(
9359                        "For object type {object_type}, you must specify 'TABLE' or omit the object type"
9360                    )
9361                )
9362            }
9363            ObjectType::Sink
9364            | ObjectType::Index
9365            | ObjectType::ClusterReplica
9366            | ObjectType::Role
9367            | ObjectType::Func
9368            | ObjectType::Subsource => {
9369                parser_err!(
9370                    self,
9371                    self.peek_prev_pos(),
9372                    format!("Unsupported {statement_type} on {object_type}")
9373                )
9374            }
9375            ObjectType::Table
9376            | ObjectType::Type
9377            | ObjectType::Cluster
9378            | ObjectType::Secret
9379            | ObjectType::Connection
9380            | ObjectType::Database
9381            | ObjectType::Schema
9382            | ObjectType::NetworkPolicy => Ok(object_type),
9383        }
9384    }
9385
9386    /// Bail out if the current token is not an object type, or consume and return it if it is.
9387    fn expect_object_type(&mut self) -> Result<ObjectType, ParserError> {
9388        Ok(
9389            match self.expect_one_of_keywords(&[
9390                TABLE,
9391                VIEW,
9392                MATERIALIZED,
9393                SOURCE,
9394                SINK,
9395                INDEX,
9396                TYPE,
9397                ROLE,
9398                USER,
9399                CLUSTER,
9400                SECRET,
9401                CONNECTION,
9402                DATABASE,
9403                SCHEMA,
9404                FUNCTION,
9405                CONTINUAL,
9406                NETWORK,
9407            ])? {
9408                TABLE => ObjectType::Table,
9409                VIEW => ObjectType::View,
9410                MATERIALIZED => {
9411                    if let Err(e) = self.expect_keyword(VIEW) {
9412                        self.prev_token();
9413                        return Err(e);
9414                    }
9415                    ObjectType::MaterializedView
9416                }
9417                SOURCE => ObjectType::Source,
9418                SINK => ObjectType::Sink,
9419                INDEX => ObjectType::Index,
9420                TYPE => ObjectType::Type,
9421                ROLE | USER => ObjectType::Role,
9422                CLUSTER => {
9423                    if self.parse_keyword(REPLICA) {
9424                        ObjectType::ClusterReplica
9425                    } else {
9426                        ObjectType::Cluster
9427                    }
9428                }
9429                SECRET => ObjectType::Secret,
9430                CONNECTION => ObjectType::Connection,
9431                DATABASE => ObjectType::Database,
9432                SCHEMA => ObjectType::Schema,
9433                FUNCTION => ObjectType::Func,
9434                CONTINUAL => {
9435                    if let Err(e) = self.expect_keyword(TASK) {
9436                        self.prev_token();
9437                        return Err(e);
9438                    }
9439                    ObjectType::ContinualTask
9440                }
9441                NETWORK => {
9442                    if let Err(e) = self.expect_keyword(POLICY) {
9443                        self.prev_token();
9444                        return Err(e);
9445                    }
9446                    ObjectType::NetworkPolicy
9447                }
9448                _ => unreachable!(),
9449            },
9450        )
9451    }
9452
9453    /// Look for an object type and return it if it matches.
9454    fn parse_object_type(&mut self) -> Option<ObjectType> {
9455        Some(
9456            match self.parse_one_of_keywords(&[
9457                TABLE,
9458                VIEW,
9459                MATERIALIZED,
9460                SOURCE,
9461                SINK,
9462                INDEX,
9463                TYPE,
9464                ROLE,
9465                USER,
9466                CLUSTER,
9467                SECRET,
9468                CONNECTION,
9469                DATABASE,
9470                SCHEMA,
9471                FUNCTION,
9472            ])? {
9473                TABLE => ObjectType::Table,
9474                VIEW => ObjectType::View,
9475                MATERIALIZED => {
9476                    if self.parse_keyword(VIEW) {
9477                        ObjectType::MaterializedView
9478                    } else {
9479                        self.prev_token();
9480                        return None;
9481                    }
9482                }
9483                SOURCE => ObjectType::Source,
9484                SINK => ObjectType::Sink,
9485                INDEX => ObjectType::Index,
9486                TYPE => ObjectType::Type,
9487                ROLE | USER => ObjectType::Role,
9488                CLUSTER => {
9489                    if self.parse_keyword(REPLICA) {
9490                        ObjectType::ClusterReplica
9491                    } else {
9492                        ObjectType::Cluster
9493                    }
9494                }
9495                SECRET => ObjectType::Secret,
9496                CONNECTION => ObjectType::Connection,
9497                DATABASE => ObjectType::Database,
9498                SCHEMA => ObjectType::Schema,
9499                FUNCTION => ObjectType::Func,
9500                _ => unreachable!(),
9501            },
9502        )
9503    }
9504
9505    /// Bail out if the current token is not an object type in the plural form, or consume and return it if it is.
9506    fn expect_plural_object_type(&mut self) -> Result<ObjectType, ParserError> {
9507        Ok(
9508            match self.expect_one_of_keywords(&[
9509                TABLES,
9510                VIEWS,
9511                MATERIALIZED,
9512                SOURCES,
9513                SINKS,
9514                INDEXES,
9515                TYPES,
9516                ROLES,
9517                USERS,
9518                CLUSTER,
9519                CLUSTERS,
9520                SECRETS,
9521                CONNECTIONS,
9522                DATABASES,
9523                SCHEMAS,
9524                POLICIES,
9525            ])? {
9526                TABLES => ObjectType::Table,
9527                VIEWS => ObjectType::View,
9528                MATERIALIZED => {
9529                    if let Err(e) = self.expect_keyword(VIEWS) {
9530                        self.prev_token();
9531                        return Err(e);
9532                    }
9533                    ObjectType::MaterializedView
9534                }
9535                SOURCES => ObjectType::Source,
9536                SINKS => ObjectType::Sink,
9537                INDEXES => ObjectType::Index,
9538                TYPES => ObjectType::Type,
9539                ROLES | USERS => ObjectType::Role,
9540                CLUSTER => {
9541                    if let Err(e) = self.expect_keyword(REPLICAS) {
9542                        self.prev_token();
9543                        return Err(e);
9544                    }
9545                    ObjectType::ClusterReplica
9546                }
9547                CLUSTERS => ObjectType::Cluster,
9548                SECRETS => ObjectType::Secret,
9549                CONNECTIONS => ObjectType::Connection,
9550                DATABASES => ObjectType::Database,
9551                SCHEMAS => ObjectType::Schema,
9552                POLICIES => ObjectType::NetworkPolicy,
9553                _ => unreachable!(),
9554            },
9555        )
9556    }
9557
9558    /// Look for an object type in the plural form and return it if it matches.
9559    fn parse_plural_object_type(&mut self) -> Option<ObjectType> {
9560        Some(
9561            match self.parse_one_of_keywords(&[
9562                TABLES,
9563                VIEWS,
9564                MATERIALIZED,
9565                SOURCES,
9566                SINKS,
9567                INDEXES,
9568                TYPES,
9569                ROLES,
9570                USERS,
9571                CLUSTER,
9572                CLUSTERS,
9573                SECRETS,
9574                CONNECTIONS,
9575                DATABASES,
9576                SCHEMAS,
9577                SUBSOURCES,
9578                CONTINUAL,
9579                NETWORK,
9580            ])? {
9581                TABLES => ObjectType::Table,
9582                VIEWS => ObjectType::View,
9583                MATERIALIZED => {
9584                    if self.parse_keyword(VIEWS) {
9585                        ObjectType::MaterializedView
9586                    } else {
9587                        self.prev_token();
9588                        return None;
9589                    }
9590                }
9591                SOURCES => ObjectType::Source,
9592                SINKS => ObjectType::Sink,
9593                INDEXES => ObjectType::Index,
9594                TYPES => ObjectType::Type,
9595                ROLES | USERS => ObjectType::Role,
9596                CLUSTER => {
9597                    if self.parse_keyword(REPLICAS) {
9598                        ObjectType::ClusterReplica
9599                    } else {
9600                        self.prev_token();
9601                        return None;
9602                    }
9603                }
9604                CLUSTERS => ObjectType::Cluster,
9605                SECRETS => ObjectType::Secret,
9606                CONNECTIONS => ObjectType::Connection,
9607                DATABASES => ObjectType::Database,
9608                SCHEMAS => ObjectType::Schema,
9609                SUBSOURCES => ObjectType::Subsource,
9610                CONTINUAL => {
9611                    if self.parse_keyword(TASKS) {
9612                        ObjectType::ContinualTask
9613                    } else {
9614                        self.prev_token();
9615                        return None;
9616                    }
9617                }
9618                NETWORK => {
9619                    if self.parse_keyword(POLICIES) {
9620                        ObjectType::NetworkPolicy
9621                    } else {
9622                        self.prev_token();
9623                        return None;
9624                    }
9625                }
9626                _ => unreachable!(),
9627            },
9628        )
9629    }
9630
9631    /// Bail out if the current token is not a privilege object type, or consume and
9632    /// return it if it is.
9633    fn expect_plural_object_type_for_privileges(&mut self) -> Result<ObjectType, ParserError> {
9634        if let Some(object_type) = self.parse_one_of_keywords(&[VIEWS, SOURCES]) {
9635            return parser_err!(
9636                self,
9637                self.peek_prev_pos(),
9638                format!("For object type {object_type}, you must specify 'TABLES'")
9639            );
9640        }
9641        if self.parse_keywords(&[MATERIALIZED, VIEWS]) {
9642            self.prev_token();
9643            return parser_err!(
9644                self,
9645                self.peek_prev_pos(),
9646                format!("For object type MATERIALIZED VIEWS, you must specify 'TABLES'")
9647            );
9648        }
9649
9650        Ok(
9651            match self.expect_one_of_keywords(&[
9652                TABLES,
9653                TYPES,
9654                CLUSTERS,
9655                SECRETS,
9656                CONNECTIONS,
9657                DATABASES,
9658                SCHEMAS,
9659            ])? {
9660                TABLES => ObjectType::Table,
9661                TYPES => ObjectType::Type,
9662                CLUSTERS => ObjectType::Cluster,
9663                SECRETS => ObjectType::Secret,
9664                CONNECTIONS => ObjectType::Connection,
9665                DATABASES => ObjectType::Database,
9666                SCHEMAS => ObjectType::Schema,
9667                _ => unreachable!(),
9668            },
9669        )
9670    }
9671
9672    /// Bail out if the current token is not a privilege object type in the plural form, or consume and
9673    /// return it if it is.
9674    fn expect_plural_system_object_type_for_privileges(
9675        &mut self,
9676    ) -> Result<SystemObjectType, ParserError> {
9677        if let Some(object_type) = self.parse_one_of_keywords(&[VIEWS, SOURCES]) {
9678            return parser_err!(
9679                self,
9680                self.peek_prev_pos(),
9681                format!("For object type {object_type}, you must specify 'TABLES'")
9682            );
9683        }
9684        if self.parse_keywords(&[MATERIALIZED, VIEWS]) {
9685            self.prev_token();
9686            return parser_err!(
9687                self,
9688                self.peek_prev_pos(),
9689                format!("For object type MATERIALIZED VIEWS, you must specify 'TABLES'")
9690            );
9691        }
9692
9693        Ok(
9694            match self.expect_one_of_keywords(&[
9695                SYSTEM,
9696                TABLES,
9697                TYPES,
9698                CLUSTERS,
9699                SECRETS,
9700                CONNECTIONS,
9701                DATABASES,
9702                SCHEMAS,
9703            ])? {
9704                SYSTEM => SystemObjectType::System,
9705                TABLES => SystemObjectType::Object(ObjectType::Table),
9706                TYPES => SystemObjectType::Object(ObjectType::Type),
9707                CLUSTERS => SystemObjectType::Object(ObjectType::Cluster),
9708                SECRETS => SystemObjectType::Object(ObjectType::Secret),
9709                CONNECTIONS => SystemObjectType::Object(ObjectType::Connection),
9710                DATABASES => SystemObjectType::Object(ObjectType::Database),
9711                SCHEMAS => SystemObjectType::Object(ObjectType::Schema),
9712                _ => unreachable!(),
9713            },
9714        )
9715    }
9716
9717    /// Look for a privilege and return it if it matches.
9718    fn parse_privilege(&mut self) -> Option<Privilege> {
9719        Some(
9720            match self.parse_one_of_keywords(&[
9721                INSERT,
9722                SELECT,
9723                UPDATE,
9724                DELETE,
9725                USAGE,
9726                CREATE,
9727                CREATEROLE,
9728                CREATEDB,
9729                CREATECLUSTER,
9730                CREATENETWORKPOLICY,
9731            ])? {
9732                INSERT => Privilege::INSERT,
9733                SELECT => Privilege::SELECT,
9734                UPDATE => Privilege::UPDATE,
9735                DELETE => Privilege::DELETE,
9736                USAGE => Privilege::USAGE,
9737                CREATE => Privilege::CREATE,
9738                CREATEROLE => Privilege::CREATEROLE,
9739                CREATEDB => Privilege::CREATEDB,
9740                CREATECLUSTER => Privilege::CREATECLUSTER,
9741                CREATENETWORKPOLICY => Privilege::CREATENETWORKPOLICY,
9742                _ => unreachable!(),
9743            },
9744        )
9745    }
9746
9747    /// Parse one or more privileges separated by a ','.
9748    fn parse_privilege_specification(&mut self) -> Option<PrivilegeSpecification> {
9749        if self.parse_keyword(ALL) {
9750            let _ = self.parse_keyword(PRIVILEGES);
9751            return Some(PrivilegeSpecification::All);
9752        }
9753
9754        let mut privileges = Vec::new();
9755        while let Some(privilege) = self.parse_privilege() {
9756            privileges.push(privilege);
9757            if !self.consume_token(&Token::Comma) {
9758                break;
9759            }
9760        }
9761
9762        if privileges.is_empty() {
9763            None
9764        } else {
9765            Some(PrivilegeSpecification::Privileges(privileges))
9766        }
9767    }
9768
9769    /// Bail out if the current token is not a role specification, or consume and return it if it is.
9770    fn expect_role_specification(&mut self) -> Result<Ident, ParserError> {
9771        let _ = self.parse_keyword(GROUP);
9772        self.parse_identifier()
9773    }
9774
9775    /// Parse a `REASSIGN OWNED` statement, assuming that the `REASSIGN` token
9776    /// has already been consumed.
9777    fn parse_reassign_owned(&mut self) -> Result<Statement<Raw>, ParserError> {
9778        self.expect_keywords(&[OWNED, BY])?;
9779        let old_roles = self.parse_comma_separated(Parser::parse_identifier)?;
9780        self.expect_keyword(TO)?;
9781        let new_role = self.parse_identifier()?;
9782        Ok(Statement::ReassignOwned(ReassignOwnedStatement {
9783            old_roles,
9784            new_role,
9785        }))
9786    }
9787
9788    fn parse_comment(&mut self) -> Result<Statement<Raw>, ParserError> {
9789        self.expect_keyword(ON)?;
9790
9791        let object = match self.expect_one_of_keywords(&[
9792            TABLE,
9793            VIEW,
9794            COLUMN,
9795            MATERIALIZED,
9796            SOURCE,
9797            SINK,
9798            INDEX,
9799            FUNCTION,
9800            CONNECTION,
9801            TYPE,
9802            SECRET,
9803            ROLE,
9804            DATABASE,
9805            SCHEMA,
9806            CLUSTER,
9807            CONTINUAL,
9808            NETWORK,
9809        ])? {
9810            TABLE => {
9811                let name = self.parse_raw_name()?;
9812                CommentObjectType::Table { name }
9813            }
9814            VIEW => {
9815                let name = self.parse_raw_name()?;
9816                CommentObjectType::View { name }
9817            }
9818            MATERIALIZED => {
9819                self.expect_keyword(VIEW)?;
9820                let name = self.parse_raw_name()?;
9821                CommentObjectType::MaterializedView { name }
9822            }
9823            SOURCE => {
9824                let name = self.parse_raw_name()?;
9825                CommentObjectType::Source { name }
9826            }
9827            SINK => {
9828                let name = self.parse_raw_name()?;
9829                CommentObjectType::Sink { name }
9830            }
9831            INDEX => {
9832                let name = self.parse_raw_name()?;
9833                CommentObjectType::Index { name }
9834            }
9835            FUNCTION => {
9836                let name = self.parse_raw_name()?;
9837                CommentObjectType::Func { name }
9838            }
9839            CONNECTION => {
9840                let name = self.parse_raw_name()?;
9841                CommentObjectType::Connection { name }
9842            }
9843            TYPE => {
9844                let ty = self.parse_data_type()?;
9845                CommentObjectType::Type { ty }
9846            }
9847            SECRET => {
9848                let name = self.parse_raw_name()?;
9849                CommentObjectType::Secret { name }
9850            }
9851            ROLE => {
9852                let name = self.parse_identifier()?;
9853                CommentObjectType::Role { name }
9854            }
9855            DATABASE => {
9856                let name = self.parse_database_name()?;
9857                CommentObjectType::Database { name }
9858            }
9859            SCHEMA => {
9860                let name = self.parse_schema_name()?;
9861                CommentObjectType::Schema { name }
9862            }
9863            CLUSTER => {
9864                if self.parse_keyword(REPLICA) {
9865                    let name = self.parse_cluster_replica_name()?;
9866                    CommentObjectType::ClusterReplica { name }
9867                } else {
9868                    let name = self.parse_raw_ident()?;
9869                    CommentObjectType::Cluster { name }
9870                }
9871            }
9872            COLUMN => {
9873                let name = self.parse_column_name()?;
9874                CommentObjectType::Column { name }
9875            }
9876            CONTINUAL => {
9877                self.expect_keyword(TASK)?;
9878                let name = self.parse_raw_name()?;
9879                CommentObjectType::ContinualTask { name }
9880            }
9881            NETWORK => {
9882                self.expect_keyword(POLICY)?;
9883                let name = self.parse_raw_network_policy_name()?;
9884                CommentObjectType::NetworkPolicy { name }
9885            }
9886            _ => unreachable!(),
9887        };
9888
9889        self.expect_keyword(IS)?;
9890        let comment = match self.next_token() {
9891            Some(Token::Keyword(NULL)) => None,
9892            Some(Token::String(s)) => Some(s),
9893            other => return self.expected(self.peek_prev_pos(), "NULL or literal string", other),
9894        };
9895
9896        Ok(Statement::Comment(CommentStatement { object, comment }))
9897    }
9898
9899    pub fn new_identifier<S>(&self, s: S) -> Result<Ident, ParserError>
9900    where
9901        S: TryInto<IdentString>,
9902        <S as TryInto<IdentString>>::Error: fmt::Display,
9903    {
9904        Ident::new(s).map_err(|e| ParserError {
9905            pos: self.peek_prev_pos(),
9906            message: e.to_string(),
9907        })
9908    }
9909}
9910
9911impl CheckedRecursion for Parser<'_> {
9912    fn recursion_guard(&self) -> &RecursionGuard {
9913        &self.recursion_guard
9914    }
9915}
9916
9917/// Represents an expression or query (a "fragment") with parentheses around it,
9918/// when it is unknown whether the fragment belongs to a larger expression or
9919/// query.
9920enum ParenthesizedFragment {
9921    Query(Query<Raw>),
9922    Exprs(Vec<Expr<Raw>>),
9923}
9924
9925impl ParenthesizedFragment {
9926    /// Force the fragment into an expression.
9927    fn into_expr(self) -> Expr<Raw> {
9928        match self {
9929            ParenthesizedFragment::Exprs(exprs) => {
9930                // The `ParenthesizedFragment` represents that there were
9931                // parentheses surrounding `exprs`, so...
9932                if exprs.len() == 1 {
9933                    // ...if there was only one expression, the parentheses
9934                    // were simple nesting...
9935                    Expr::Nested(Box::new(exprs.into_element()))
9936                } else {
9937                    // ...and if there were multiple expressions, the
9938                    // parentheses formed an implicit row constructor.
9939                    Expr::Row { exprs }
9940                }
9941            }
9942            // Queries become subquery expressions.
9943            ParenthesizedFragment::Query(query) => Expr::Subquery(Box::new(query)),
9944        }
9945    }
9946}
9947
9948// Include the `Parser::parse_~` implementations for simple options derived by
9949// the crate's build.rs script.
9950include!(concat!(env!("OUT_DIR"), "/parse.simple_options.rs"));