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