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