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