1#[cfg(not(feature = "std"))]
16use alloc::{
17 boxed::Box,
18 format,
19 string::{String, ToString},
20 vec,
21 vec::Vec,
22};
23use core::fmt;
24
25use ddl::WebhookSourceInfo;
26use itertools::Itertools;
27use tracing::{debug, instrument};
28use winnow::combinator::{
29 alt, cut_err, dispatch, fail, opt, peek, preceded, repeat, separated, separated_pair,
30};
31use winnow::{ModalResult, Parser as _};
32
33use crate::ast::*;
34use crate::keywords::{self, Keyword};
35use crate::parser_v2::{
36 ParserExt as _, dollar_quoted_string, keyword, literal_i64, literal_u32, literal_u64,
37 single_quoted_string,
38};
39use crate::tokenizer::*;
40use crate::{impl_parse_to, parser_v2};
41
42pub(crate) const UPSTREAM_SOURCE_KEY: &str = "connector";
43pub(crate) const WEBHOOK_CONNECTOR: &str = "webhook";
44
45const WEBHOOK_WAIT_FOR_PERSISTENCE: &str = "webhook.wait_for_persistence";
46const WEBHOOK_IS_BATCHED: &str = "is_batched";
47
48#[derive(Debug, Clone, PartialEq)]
49pub enum ParserError {
50 TokenizerError(String),
51 ParserError(String),
52}
53
54impl ParserError {
55 pub fn inner_msg(self) -> String {
56 match self {
57 ParserError::TokenizerError(s) | ParserError::ParserError(s) => s,
58 }
59 }
60}
61
62#[derive(Debug, thiserror::Error)]
63#[error("{0}")]
64pub struct StrError(pub String);
65
66#[macro_export]
68macro_rules! parser_err {
69 ($($arg:tt)*) => {
70 return Err(winnow::error::ErrMode::Backtrack(<winnow::error::ContextError as winnow::error::FromExternalError<_, _>>::from_external_error(
71 &Parser::default(),
72 $crate::parser::StrError(format!($($arg)*)),
73 )))
74 };
75}
76
77impl From<StrError> for winnow::error::ErrMode<winnow::error::ContextError> {
78 fn from(e: StrError) -> Self {
79 winnow::error::ErrMode::Backtrack(<winnow::error::ContextError as winnow::error::FromExternalError<_, _>>::from_external_error(
80 &Parser::default(),
81 e,
82 ))
83 }
84}
85
86macro_rules! return_ok_if_some {
88 ($e:expr) => {{
89 if let Some(v) = $e {
90 return Ok(v);
91 }
92 }};
93}
94
95#[derive(PartialEq)]
96pub enum IsOptional {
97 Optional,
98 Mandatory,
99}
100
101use IsOptional::*;
102
103pub enum IsLateral {
104 Lateral,
105 NotLateral,
106}
107
108use IsLateral::*;
109
110use crate::ast::ddl::AlterFragmentOperation;
111
112pub type IncludeOption = Vec<IncludeOptionItem>;
113
114#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
115#[derive(Eq, Clone, Debug, PartialEq, Hash)]
116pub struct IncludeOptionItem {
117 pub column_type: Ident,
118 pub column_alias: Option<Ident>,
119 pub inner_field: Option<String>,
120 pub header_inner_expect_type: Option<DataType>,
121}
122
123#[derive(Debug)]
124pub enum WildcardOrExpr {
125 Expr(Expr),
126 ExprQualifiedWildcard(Expr, Vec<Ident>),
132 QualifiedWildcard(ObjectName, Option<Vec<Expr>>),
134 Wildcard(Option<Vec<Expr>>),
135}
136
137impl From<WildcardOrExpr> for FunctionArgExpr {
138 fn from(wildcard_expr: WildcardOrExpr) -> Self {
139 match wildcard_expr {
140 WildcardOrExpr::Expr(expr) => Self::Expr(expr),
141 WildcardOrExpr::ExprQualifiedWildcard(expr, prefix) => {
142 Self::ExprQualifiedWildcard(expr, prefix)
143 }
144 WildcardOrExpr::QualifiedWildcard(prefix, except) => {
145 Self::QualifiedWildcard(prefix, except)
146 }
147 WildcardOrExpr::Wildcard(except) => Self::Wildcard(except),
148 }
149 }
150}
151
152impl From<TokenizerError> for ParserError {
153 fn from(e: TokenizerError) -> Self {
154 ParserError::TokenizerError(e.to_string())
155 }
156}
157
158impl fmt::Display for ParserError {
159 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
160 write!(
161 f,
162 "sql parser error: {}",
163 match self {
164 ParserError::TokenizerError(s) => s,
165 ParserError::ParserError(s) => s,
166 }
167 )
168 }
169}
170
171#[cfg(feature = "std")]
172impl std::error::Error for ParserError {}
173
174type ColumnsDefTuple = (
175 Vec<ColumnDef>,
176 Vec<TableConstraint>,
177 Vec<SourceWatermark>,
178 Option<usize>,
179);
180
181#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
184pub enum Precedence {
185 Zero = 0,
186 LogicalOr, LogicalXor,
188 LogicalAnd, UnaryNot, Is, Cmp,
192 Like, Between, Other,
195 PlusMinus, MulDiv, Exp,
198 At,
199 Collate,
200 UnaryPosNeg,
201 Array,
202 DoubleColon, }
204
205#[derive(Clone, Copy, Default)]
206pub struct Parser<'a>(pub(crate) &'a [TokenWithLocation]);
207
208impl Parser<'_> {
209 #[instrument(level = "debug")]
211 pub fn parse_sql(sql: &str) -> Result<Vec<Statement>, ParserError> {
212 let mut tokenizer = Tokenizer::new(sql);
213 let tokens = tokenizer.tokenize_with_location()?;
214 let parser = Parser(&tokens);
215 let stmts = Parser::parse_statements.parse(parser).map_err(|e| {
216 let loc = match tokens.get(e.offset()) {
219 Some(token) => token.location.clone(),
220 None => {
221 Location {
223 line: sql.lines().count() as u64,
224 column: sql.lines().last().map_or(0, |l| l.len() as u64) + 1,
225 }
226 }
227 };
228 let prefix = format!("LINE {}: ", loc.line);
229 let sql_line = sql.split('\n').nth(loc.line as usize - 1).unwrap();
230 let cursor = " ".repeat(prefix.len() + loc.column as usize - 1);
231 ParserError::ParserError(format!(
232 "{}\n{}{}\n{}^",
233 e.inner().to_string().replace('\n', ": "),
234 prefix,
235 sql_line,
236 cursor
237 ))
238 })?;
239 Ok(stmts)
240 }
241
242 pub fn parse_exactly_one(sql: &str) -> Result<Statement, ParserError> {
244 Parser::parse_sql(sql)
245 .map_err(|e| {
246 ParserError::ParserError(format!("failed to parse definition sql: {}", e))
247 })?
248 .into_iter()
249 .exactly_one()
250 .map_err(|e| {
251 ParserError::ParserError(format!(
252 "expecting exactly one statement in definition: {}",
253 e
254 ))
255 })
256 }
257
258 pub fn parse_object_name_str(s: &str) -> Result<ObjectName, ParserError> {
260 let mut tokenizer = Tokenizer::new(s);
261 let tokens = tokenizer.tokenize_with_location()?;
262 let parser = Parser(&tokens);
263 Parser::parse_object_name
264 .parse(parser)
265 .map_err(|e| ParserError::ParserError(e.inner().to_string()))
266 }
267
268 pub fn parse_function_desc_str(func: &str) -> Result<FunctionDesc, ParserError> {
270 let mut tokenizer = Tokenizer::new(func);
271 let tokens = tokenizer.tokenize_with_location()?;
272 let parser = Parser(&tokens);
273 Parser::parse_function_desc
274 .parse(parser)
275 .map_err(|e| ParserError::ParserError(e.inner().to_string()))
276 }
277
278 fn parse_statements(&mut self) -> ModalResult<Vec<Statement>> {
280 let mut stmts = Vec::new();
281 let mut expecting_statement_delimiter = false;
282 loop {
283 while self.consume_token(&Token::SemiColon) {
285 expecting_statement_delimiter = false;
286 }
287
288 if self.peek_token() == Token::EOF {
289 break;
290 }
291 if expecting_statement_delimiter {
292 return self.expected("end of statement");
293 }
294
295 let statement = self.parse_statement()?;
296 stmts.push(statement);
297 expecting_statement_delimiter = true;
298 }
299 debug!("parsed statements:\n{:#?}", stmts);
300 Ok(stmts)
301 }
302
303 pub fn parse_statement(&mut self) -> ModalResult<Statement> {
306 let checkpoint = *self;
307 let token = self.next_token();
308 match token.token {
309 Token::Word(w) => match w.keyword {
310 Keyword::EXPLAIN => Ok(self.parse_explain()?),
311 Keyword::ANALYZE => Ok(self.parse_analyze()?),
312 Keyword::SELECT | Keyword::WITH | Keyword::VALUES => {
313 *self = checkpoint;
314 Ok(Statement::Query(Box::new(self.parse_query()?)))
315 }
316 Keyword::DECLARE => Ok(self.parse_declare()?),
317 Keyword::FETCH => Ok(self.parse_fetch_cursor()?),
318 Keyword::CLOSE => Ok(self.parse_close_cursor()?),
319 Keyword::TRUNCATE => Ok(self.parse_truncate()?),
320 Keyword::REFRESH => Ok(self.parse_refresh()?),
321 Keyword::CREATE => Ok(self.parse_create()?),
322 Keyword::DISCARD => Ok(self.parse_discard()?),
323 Keyword::DROP => Ok(self.parse_drop()?),
324 Keyword::DELETE => Ok(self.parse_delete()?),
325 Keyword::INSERT => Ok(self.parse_insert()?),
326 Keyword::UPDATE => Ok(self.parse_update()?),
327 Keyword::ALTER => Ok(self.parse_alter()?),
328 Keyword::COPY => Ok(self.parse_copy()?),
329 Keyword::SET => Ok(self.parse_set()?),
330 Keyword::SHOW => {
331 if self.parse_keyword(Keyword::CREATE) {
332 Ok(self.parse_show_create()?)
333 } else {
334 Ok(self.parse_show()?)
335 }
336 }
337 Keyword::CANCEL => Ok(self.parse_cancel_job()?),
338 Keyword::KILL => Ok(self.parse_kill_process()?),
339 Keyword::DESCRIBE => Ok(self.parse_describe()?),
340 Keyword::GRANT => Ok(self.parse_grant()?),
341 Keyword::REVOKE => Ok(self.parse_revoke()?),
342 Keyword::START => Ok(self.parse_start_transaction()?),
343 Keyword::ABORT => Ok(Statement::Abort),
344 Keyword::BEGIN => Ok(self.parse_begin()?),
348 Keyword::COMMIT => Ok(self.parse_commit()?),
349 Keyword::ROLLBACK => Ok(self.parse_rollback()?),
350 Keyword::DEALLOCATE => Ok(self.parse_deallocate()?),
353 Keyword::EXECUTE => Ok(self.parse_execute()?),
354 Keyword::PREPARE => Ok(self.parse_prepare()?),
355 Keyword::COMMENT => Ok(self.parse_comment()?),
356 Keyword::FLUSH => Ok(Statement::Flush),
357 Keyword::WAIT => Ok(Statement::Wait),
358 Keyword::RECOVER => Ok(Statement::Recover),
359 Keyword::USE => Ok(self.parse_use()?),
360 Keyword::VACUUM => Ok(self.parse_vacuum()?),
361 _ => self.expected_at(checkpoint, "statement"),
362 },
363 Token::LParen => {
364 *self = checkpoint;
365 Ok(Statement::Query(Box::new(self.parse_query()?)))
366 }
367 _ => self.expected_at(checkpoint, "statement"),
368 }
369 }
370
371 pub fn parse_truncate(&mut self) -> ModalResult<Statement> {
372 let _ = self.parse_keyword(Keyword::TABLE);
373 let table_name = self.parse_object_name()?;
374 Ok(Statement::Truncate { table_name })
375 }
376
377 pub fn parse_refresh(&mut self) -> ModalResult<Statement> {
378 self.expect_keyword(Keyword::TABLE)?;
379 let table_name = self.parse_object_name()?;
380 Ok(Statement::Refresh { table_name })
381 }
382
383 pub fn parse_analyze(&mut self) -> ModalResult<Statement> {
384 let table_name = self.parse_object_name()?;
385
386 Ok(Statement::Analyze { table_name })
387 }
388
389 pub fn parse_vacuum(&mut self) -> ModalResult<Statement> {
390 let full = self.parse_keyword(Keyword::FULL);
391 let object_name = self.parse_object_name()?;
392
393 Ok(Statement::Vacuum { object_name, full })
394 }
395
396 pub fn parse_wildcard_or_expr(&mut self) -> ModalResult<WildcardOrExpr> {
405 let checkpoint = *self;
406
407 match self.next_token().token {
408 Token::Word(w) if self.peek_token() == Token::Period => {
409 let wildcard_expr = self.parse_simple_wildcard_expr(checkpoint)?;
412 return self.word_concat_wildcard_expr(w.to_ident()?, wildcard_expr);
413 }
414 Token::Mul => {
415 return Ok(WildcardOrExpr::Wildcard(self.parse_except()?));
416 }
417 Token::LParen => {
420 let mut expr = self.parse_expr()?;
421 if self.consume_token(&Token::RParen) {
422 while let Expr::Nested(inner) = expr {
424 expr = *inner;
425 }
426 let wildcard_expr = self.parse_simple_wildcard_expr(checkpoint)?;
429 return self.expr_concat_wildcard_expr(expr, wildcard_expr);
430 }
431 }
432 _ => (),
433 };
434
435 *self = checkpoint;
436 self.parse_expr().map(WildcardOrExpr::Expr)
437 }
438
439 pub fn word_concat_wildcard_expr(
441 &mut self,
442 ident: Ident,
443 simple_wildcard_expr: WildcardOrExpr,
444 ) -> ModalResult<WildcardOrExpr> {
445 let mut idents = vec![ident];
446 let mut except_cols = vec![];
447 match simple_wildcard_expr {
448 WildcardOrExpr::QualifiedWildcard(ids, except) => {
449 idents.extend(ids.0);
450 if let Some(cols) = except {
451 except_cols = cols;
452 }
453 }
454 WildcardOrExpr::Wildcard(except) => {
455 if let Some(cols) = except {
456 except_cols = cols;
457 }
458 }
459 WildcardOrExpr::ExprQualifiedWildcard(_, _) => unreachable!(),
460 WildcardOrExpr::Expr(e) => return Ok(WildcardOrExpr::Expr(e)),
461 }
462 Ok(WildcardOrExpr::QualifiedWildcard(
463 ObjectName(idents),
464 if except_cols.is_empty() {
465 None
466 } else {
467 Some(except_cols)
468 },
469 ))
470 }
471
472 pub fn expr_concat_wildcard_expr(
474 &mut self,
475 expr: Expr,
476 simple_wildcard_expr: WildcardOrExpr,
477 ) -> ModalResult<WildcardOrExpr> {
478 if let WildcardOrExpr::Expr(e) = simple_wildcard_expr {
479 return Ok(WildcardOrExpr::Expr(e));
480 }
481
482 let mut idents = vec![];
484 let expr = match expr {
485 Expr::Identifier(_) => expr,
487 Expr::CompoundIdentifier(_) => expr,
489 Expr::Cast { .. } => expr,
491 Expr::Function(_) => expr,
493 Expr::FieldIdentifier(expr, ids) => {
495 idents.extend(ids);
497 *expr
498 }
499 _ => return Ok(WildcardOrExpr::Expr(expr)),
502 };
503
504 match simple_wildcard_expr {
505 WildcardOrExpr::QualifiedWildcard(ids, except) => {
506 if except.is_some() {
507 return self.expected("Expr quantified wildcard does not support except");
508 }
509 idents.extend(ids.0);
510 }
511 WildcardOrExpr::Wildcard(except) => {
512 if except.is_some() {
513 return self.expected("Expr quantified wildcard does not support except");
514 }
515 }
516 WildcardOrExpr::ExprQualifiedWildcard(_, _) => unreachable!(),
517 WildcardOrExpr::Expr(_) => unreachable!(),
518 }
519 Ok(WildcardOrExpr::ExprQualifiedWildcard(expr, idents))
520 }
521
522 pub fn parse_simple_wildcard_expr(&mut self, checkpoint: Self) -> ModalResult<WildcardOrExpr> {
526 let mut id_parts = vec![];
527 while self.consume_token(&Token::Period) {
528 let ckpt = *self;
529 let token = self.next_token();
530 match token.token {
531 Token::Word(w) => id_parts.push(w.to_ident()?),
532 Token::Mul => {
533 return if id_parts.is_empty() {
534 Ok(WildcardOrExpr::Wildcard(self.parse_except()?))
535 } else {
536 Ok(WildcardOrExpr::QualifiedWildcard(
537 ObjectName(id_parts),
538 self.parse_except()?,
539 ))
540 };
541 }
542 _ => {
543 *self = ckpt;
544 return self.expected("an identifier or a '*' after '.'");
545 }
546 }
547 }
548 *self = checkpoint;
549 self.parse_expr().map(WildcardOrExpr::Expr)
550 }
551
552 pub fn parse_except(&mut self) -> ModalResult<Option<Vec<Expr>>> {
553 if !self.parse_keyword(Keyword::EXCEPT) {
554 return Ok(None);
555 }
556 if !self.consume_token(&Token::LParen) {
557 return self.expected("EXCEPT should be followed by (");
558 }
559 let exprs = self.parse_comma_separated(Parser::parse_expr)?;
560 if self.consume_token(&Token::RParen) {
561 Ok(Some(exprs))
562 } else {
563 self.expected("( should be followed by ) after column names")
564 }
565 }
566
567 pub fn parse_expr(&mut self) -> ModalResult<Expr> {
569 self.parse_subexpr(Precedence::Zero)
570 }
571
572 pub fn parse_subexpr(&mut self, precedence: Precedence) -> ModalResult<Expr> {
574 debug!("parsing expr, current token: {:?}", self.peek_token().token);
575 let mut expr = self.parse_prefix()?;
576 debug!("prefix: {:?}", expr);
577 loop {
578 let next_precedence = self.get_next_precedence()?;
579 debug!("precedence: {precedence:?}, next precedence: {next_precedence:?}");
580
581 if precedence >= next_precedence {
582 break;
583 }
584
585 expr = self.parse_infix(expr, next_precedence)?;
586 }
587 Ok(expr)
588 }
589
590 pub fn parse_prefix(&mut self) -> ModalResult<Expr> {
592 return_ok_if_some!(self.maybe_parse(|parser| {
609 match parser.parse_data_type()? {
610 DataType::Interval => parser.parse_literal_interval(),
611 DataType::Custom(..) => parser_err!("dummy"),
619 data_type => Ok(Expr::TypedString {
620 data_type,
621 value: parser.parse_literal_string()?,
622 }),
623 }
624 }));
625
626 let checkpoint = *self;
627 let token = self.next_token();
628 let expr = match token.token.clone() {
629 Token::Word(w) => match w.keyword {
630 Keyword::TRUE | Keyword::FALSE | Keyword::NULL => {
631 *self = checkpoint;
632 Ok(Expr::Value(self.ensure_parse_value()?))
633 }
634 Keyword::CASE => self.parse_case_expr(),
635 Keyword::CAST => self.parse_cast_expr(),
636 Keyword::TRY_CAST => self.parse_try_cast_expr(),
637 Keyword::EXISTS => self.parse_exists_expr(),
638 Keyword::EXTRACT => self.parse_extract_expr(),
639 Keyword::SUBSTRING => self.parse_substring_expr(),
640 Keyword::POSITION => self.parse_position_expr(),
641 Keyword::OVERLAY => self.parse_overlay_expr(),
642 Keyword::TRIM => self.parse_trim_expr(),
643 Keyword::INTERVAL => self.parse_literal_interval(),
644 Keyword::NOT => Ok(Expr::UnaryOp {
645 op: UnaryOperator::Not,
646 expr: Box::new(self.parse_subexpr(Precedence::UnaryNot)?),
647 }),
648 Keyword::ROW => self.parse_row_expr(),
649 Keyword::ARRAY if self.peek_token() == Token::LParen => {
650 self.expect_token(&Token::LParen)?;
652 let exists_node = Expr::ArraySubquery(Box::new(self.parse_query()?));
653 self.expect_token(&Token::RParen)?;
654 Ok(exists_node)
655 }
656 Keyword::ARRAY if self.peek_token() == Token::LBracket => self.parse_array_expr(),
657 Keyword::MAP if self.peek_token() == Token::LBrace => self.parse_map_expr(),
658 Keyword::LEFT | Keyword::RIGHT => {
660 *self = checkpoint;
661 self.parse_function()
662 }
663 Keyword::OPERATOR if self.peek_token().token == Token::LParen => {
664 let op = UnaryOperator::PGQualified(Box::new(self.parse_qualified_operator()?));
665 Ok(Expr::UnaryOp {
666 op,
667 expr: Box::new(self.parse_subexpr(Precedence::Other)?),
668 })
669 }
670 keyword @ (Keyword::ALL | Keyword::ANY | Keyword::SOME) => {
671 self.expect_token(&Token::LParen)?;
672 let sub = self.parse_expr()?;
675 self.expect_token(&Token::RParen)?;
676
677 if let Expr::Subquery(_) = &sub {
679 parser_err!("ANY/SOME/ALL(Subquery) is not implemented");
680 }
681
682 Ok(match keyword {
683 Keyword::ALL => Expr::AllOp(Box::new(sub)),
684 Keyword::ANY | Keyword::SOME => Expr::SomeOp(Box::new(sub)),
686 _ => unreachable!(),
687 })
688 }
689 k if keywords::RESERVED_FOR_COLUMN_OR_TABLE_NAME.contains(&k) => {
690 parser_err!("syntax error at or near {token}")
691 }
692 Keyword::AGGREGATE => {
693 *self = checkpoint;
694 self.parse_function()
695 }
696 _ => match self.peek_token().token {
699 Token::LParen | Token::Period => {
700 *self = checkpoint;
701 if let Ok(object_name) = self.parse_object_name()
702 && !matches!(self.peek_token().token, Token::LParen)
703 {
704 Ok(Expr::CompoundIdentifier(object_name.0))
705 } else {
706 *self = checkpoint;
707 self.parse_function()
708 }
709 }
710 _ => Ok(Expr::Identifier(w.to_ident()?)),
711 },
712 }, tok @ Token::Minus | tok @ Token::Plus => {
715 let op = if tok == Token::Plus {
716 UnaryOperator::Plus
717 } else {
718 UnaryOperator::Minus
719 };
720 let mut sub_expr = self.parse_subexpr(Precedence::UnaryPosNeg)?;
721 if let Expr::Value(Value::Number(ref mut s)) = sub_expr {
722 if tok == Token::Minus {
723 *s = format!("-{}", s);
724 }
725 return Ok(sub_expr);
726 }
727 Ok(Expr::UnaryOp {
728 op,
729 expr: Box::new(sub_expr),
730 })
731 }
732 Token::Op(name) => {
733 let op = UnaryOperator::Custom(name);
734 Ok(Expr::UnaryOp {
737 op,
738 expr: Box::new(self.parse_subexpr(Precedence::Other)?),
739 })
740 }
741 Token::Number(_)
742 | Token::SingleQuotedString(_)
743 | Token::DollarQuotedString(_)
744 | Token::NationalStringLiteral(_)
745 | Token::HexStringLiteral(_)
746 | Token::CstyleEscapesString(_) => {
747 *self = checkpoint;
748 Ok(Expr::Value(self.ensure_parse_value()?))
749 }
750 Token::Parameter(number) => self.parse_param(number),
751 Token::Pipe => {
752 let args = self.parse_comma_separated(Parser::parse_identifier)?;
753 self.expect_token(&Token::Pipe)?;
754 let body = self.parse_expr()?;
755 Ok(Expr::LambdaFunction {
756 args,
757 body: Box::new(body),
758 })
759 }
760 Token::LParen => {
761 let expr = if matches!(self.peek_token().token, Token::Word(w) if w.keyword == Keyword::SELECT || w.keyword == Keyword::WITH)
762 {
763 Expr::Subquery(Box::new(self.parse_query()?))
764 } else {
765 let mut exprs = self.parse_comma_separated(Parser::parse_expr)?;
766 if exprs.len() == 1 {
767 Expr::Nested(Box::new(exprs.pop().unwrap()))
768 } else {
769 Expr::Row(exprs)
770 }
771 };
772 self.expect_token(&Token::RParen)?;
773 if self.peek_token() == Token::Period && matches!(expr, Expr::Nested(_)) {
774 self.parse_struct_selection(expr)
775 } else {
776 Ok(expr)
777 }
778 }
779 _ => self.expected_at(checkpoint, "an expression"),
780 }?;
781
782 if self.parse_keyword(Keyword::COLLATE) {
783 Ok(Expr::Collate {
784 expr: Box::new(expr),
785 collation: self.parse_object_name()?,
786 })
787 } else {
788 Ok(expr)
789 }
790 }
791
792 fn parse_param(&mut self, param: String) -> ModalResult<Expr> {
793 let Ok(index) = param.parse() else {
794 parser_err!("Parameter symbol has a invalid index {}.", param);
795 };
796 Ok(Expr::Parameter { index })
797 }
798
799 pub fn parse_struct_selection(&mut self, expr: Expr) -> ModalResult<Expr> {
801 let mut nested_expr = expr;
802 while let Expr::Nested(inner) = nested_expr {
804 nested_expr = *inner;
805 }
806 let fields = self.parse_fields()?;
807 Ok(Expr::FieldIdentifier(Box::new(nested_expr), fields))
808 }
809
810 pub fn parse_fields(&mut self) -> ModalResult<Vec<Ident>> {
812 repeat(.., preceded(Token::Period, cut_err(Self::parse_identifier))).parse_next(self)
813 }
814
815 pub fn parse_qualified_operator(&mut self) -> ModalResult<QualifiedOperator> {
816 self.expect_token(&Token::LParen)?;
817
818 let checkpoint = *self;
819 let schema = match self.parse_identifier_non_reserved() {
820 Ok(ident) => {
821 self.expect_token(&Token::Period)?;
822 Some(ident)
823 }
824 Err(_) => {
825 *self = checkpoint;
826 None
827 }
828 };
829
830 const OP_CHARS: &[char] = &[
832 '+', '-', '*', '/', '<', '>', '=', '~', '!', '@', '#', '%', '^', '&', '|', '`', '?',
833 ];
834 let name = {
835 let checkpoint = *self;
842 let token = self.next_token();
843 let name = token.token.to_string();
844 if !name.trim_matches(OP_CHARS).is_empty() {
845 return self
846 .expected_at(checkpoint, &format!("one of {}", OP_CHARS.iter().join(" ")));
847 }
848 name
849 };
850
851 self.expect_token(&Token::RParen)?;
852 Ok(QualifiedOperator { schema, name })
853 }
854
855 pub fn parse_function(&mut self) -> ModalResult<Expr> {
857 let scalar_as_agg = if self.parse_keyword(Keyword::AGGREGATE) {
859 self.expect_token(&Token::Colon)?;
860 true
861 } else {
862 false
863 };
864 let name = self.parse_object_name()?;
865 let arg_list = self.parse_argument_list()?;
866
867 let within_group = if self.parse_keywords(&[Keyword::WITHIN, Keyword::GROUP]) {
868 self.expect_token(&Token::LParen)?;
869 self.expect_keywords(&[Keyword::ORDER, Keyword::BY])?;
870 let order_by = self.parse_order_by_expr()?;
871 self.expect_token(&Token::RParen)?;
872 Some(Box::new(order_by.clone()))
873 } else {
874 None
875 };
876
877 let filter = if self.parse_keyword(Keyword::FILTER) {
878 self.expect_token(&Token::LParen)?;
879 self.expect_keyword(Keyword::WHERE)?;
880 let filter_expr = self.parse_expr()?;
881 self.expect_token(&Token::RParen)?;
882 Some(Box::new(filter_expr))
883 } else {
884 None
885 };
886
887 let over = if self.parse_keyword(Keyword::OVER) {
888 if self.peek_token() == Token::LParen {
889 self.expect_token(&Token::LParen)?;
891 let window_spec = self.parse_window_spec()?;
892 self.expect_token(&Token::RParen)?;
893 Some(Window::Spec(window_spec))
894 } else {
895 let window_name = self.parse_identifier()?;
897 Some(Window::Name(window_name))
898 }
899 } else {
900 None
901 };
902
903 Ok(Expr::Function(Function {
904 scalar_as_agg,
905 name,
906 arg_list,
907 within_group,
908 filter,
909 over,
910 }))
911 }
912
913 pub fn parse_window_frame_units(&mut self) -> ModalResult<WindowFrameUnits> {
914 dispatch! { peek(keyword);
915 Keyword::ROWS => keyword.value(WindowFrameUnits::Rows),
916 Keyword::RANGE => keyword.value(WindowFrameUnits::Range),
917 Keyword::GROUPS => keyword.value(WindowFrameUnits::Groups),
918 Keyword::SESSION => keyword.value(WindowFrameUnits::Session),
919 _ => fail,
920 }
921 .expect("ROWS, RANGE, or GROUPS")
922 .parse_next(self)
923 }
924
925 pub fn parse_window_frame(&mut self) -> ModalResult<WindowFrame> {
926 let units = self.parse_window_frame_units()?;
927 let bounds = if self.parse_keyword(Keyword::BETWEEN) {
928 let start = self.parse_window_frame_bound()?;
930 self.expect_keyword(Keyword::AND)?;
931 let end = Some(self.parse_window_frame_bound()?);
932 WindowFrameBounds::Bounds { start, end }
933 } else if self.parse_keywords(&[Keyword::WITH, Keyword::GAP]) {
934 WindowFrameBounds::Gap(Box::new(self.parse_expr()?))
936 } else {
937 WindowFrameBounds::Bounds {
939 start: self.parse_window_frame_bound()?,
940 end: None,
941 }
942 };
943 let exclusion = if self.parse_keyword(Keyword::EXCLUDE) {
944 Some(self.parse_window_frame_exclusion()?)
945 } else {
946 None
947 };
948 Ok(WindowFrame {
949 units,
950 bounds,
951 exclusion,
952 })
953 }
954
955 pub fn parse_window_frame_bound(&mut self) -> ModalResult<WindowFrameBound> {
957 if self.parse_keywords(&[Keyword::CURRENT, Keyword::ROW]) {
958 Ok(WindowFrameBound::CurrentRow)
959 } else {
960 let rows = if self.parse_keyword(Keyword::UNBOUNDED) {
961 None
962 } else {
963 Some(Box::new(self.parse_expr()?))
964 };
965 if self.parse_keyword(Keyword::PRECEDING) {
966 Ok(WindowFrameBound::Preceding(rows))
967 } else if self.parse_keyword(Keyword::FOLLOWING) {
968 Ok(WindowFrameBound::Following(rows))
969 } else {
970 self.expected("PRECEDING or FOLLOWING")
971 }
972 }
973 }
974
975 pub fn parse_window_frame_exclusion(&mut self) -> ModalResult<WindowFrameExclusion> {
976 if self.parse_keywords(&[Keyword::CURRENT, Keyword::ROW]) {
977 Ok(WindowFrameExclusion::CurrentRow)
978 } else if self.parse_keyword(Keyword::GROUP) {
979 Ok(WindowFrameExclusion::Group)
980 } else if self.parse_keyword(Keyword::TIES) {
981 Ok(WindowFrameExclusion::Ties)
982 } else if self.parse_keywords(&[Keyword::NO, Keyword::OTHERS]) {
983 Ok(WindowFrameExclusion::NoOthers)
984 } else {
985 self.expected("CURRENT ROW, GROUP, TIES, or NO OTHERS")
986 }
987 }
988
989 fn parse_group_by_expr(&mut self) -> ModalResult<Expr> {
992 if self.parse_keywords(&[Keyword::GROUPING, Keyword::SETS]) {
993 self.expect_token(&Token::LParen)?;
994 let result = self.parse_comma_separated(|p| p.parse_tuple(true, true))?;
995 self.expect_token(&Token::RParen)?;
996 Ok(Expr::GroupingSets(result))
997 } else if self.parse_keyword(Keyword::CUBE) {
998 self.expect_token(&Token::LParen)?;
999 let result = self.parse_comma_separated(|p| p.parse_tuple(true, false))?;
1000 self.expect_token(&Token::RParen)?;
1001 Ok(Expr::Cube(result))
1002 } else if self.parse_keyword(Keyword::ROLLUP) {
1003 self.expect_token(&Token::LParen)?;
1004 let result = self.parse_comma_separated(|p| p.parse_tuple(true, false))?;
1005 self.expect_token(&Token::RParen)?;
1006 Ok(Expr::Rollup(result))
1007 } else {
1008 self.parse_expr()
1009 }
1010 }
1011
1012 fn parse_tuple(&mut self, lift_singleton: bool, allow_empty: bool) -> ModalResult<Vec<Expr>> {
1016 if lift_singleton {
1017 if self.consume_token(&Token::LParen) {
1018 let result = if allow_empty && self.consume_token(&Token::RParen) {
1019 vec![]
1020 } else {
1021 let result = self.parse_comma_separated(Parser::parse_expr)?;
1022 self.expect_token(&Token::RParen)?;
1023 result
1024 };
1025 Ok(result)
1026 } else {
1027 Ok(vec![self.parse_expr()?])
1028 }
1029 } else {
1030 self.expect_token(&Token::LParen)?;
1031 let result = if allow_empty && self.consume_token(&Token::RParen) {
1032 vec![]
1033 } else {
1034 let result = self.parse_comma_separated(Parser::parse_expr)?;
1035 self.expect_token(&Token::RParen)?;
1036 result
1037 };
1038 Ok(result)
1039 }
1040 }
1041
1042 pub fn parse_case_expr(&mut self) -> ModalResult<Expr> {
1043 parser_v2::expr_case(self)
1044 }
1045
1046 pub fn parse_cast_expr(&mut self) -> ModalResult<Expr> {
1048 parser_v2::expr_cast(self)
1049 }
1050
1051 pub fn parse_try_cast_expr(&mut self) -> ModalResult<Expr> {
1053 parser_v2::expr_try_cast(self)
1054 }
1055
1056 pub fn parse_exists_expr(&mut self) -> ModalResult<Expr> {
1058 self.expect_token(&Token::LParen)?;
1059 let exists_node = Expr::Exists(Box::new(self.parse_query()?));
1060 self.expect_token(&Token::RParen)?;
1061 Ok(exists_node)
1062 }
1063
1064 pub fn parse_extract_expr(&mut self) -> ModalResult<Expr> {
1065 parser_v2::expr_extract(self)
1066 }
1067
1068 pub fn parse_substring_expr(&mut self) -> ModalResult<Expr> {
1069 parser_v2::expr_substring(self)
1070 }
1071
1072 pub fn parse_position_expr(&mut self) -> ModalResult<Expr> {
1074 parser_v2::expr_position(self)
1075 }
1076
1077 pub fn parse_overlay_expr(&mut self) -> ModalResult<Expr> {
1079 parser_v2::expr_overlay(self)
1080 }
1081
1082 pub fn parse_trim_expr(&mut self) -> ModalResult<Expr> {
1085 self.expect_token(&Token::LParen)?;
1086 let mut trim_where = None;
1087 if let Token::Word(word) = self.peek_token().token
1088 && [Keyword::BOTH, Keyword::LEADING, Keyword::TRAILING].contains(&word.keyword)
1089 {
1090 trim_where = Some(self.parse_trim_where()?);
1091 }
1092
1093 let (mut trim_what, expr) = if self.parse_keyword(Keyword::FROM) {
1094 (None, self.parse_expr()?)
1095 } else {
1096 let mut expr = self.parse_expr()?;
1097 if self.parse_keyword(Keyword::FROM) {
1098 let trim_what = std::mem::replace(&mut expr, self.parse_expr()?);
1099 (Some(Box::new(trim_what)), expr)
1100 } else {
1101 (None, expr)
1102 }
1103 };
1104
1105 if trim_what.is_none() && self.consume_token(&Token::Comma) {
1106 trim_what = Some(Box::new(self.parse_expr()?));
1107 }
1108 self.expect_token(&Token::RParen)?;
1109
1110 Ok(Expr::Trim {
1111 expr: Box::new(expr),
1112 trim_where,
1113 trim_what,
1114 })
1115 }
1116
1117 pub fn parse_trim_where(&mut self) -> ModalResult<TrimWhereField> {
1118 dispatch! { peek(keyword);
1119 Keyword::BOTH => keyword.value(TrimWhereField::Both),
1120 Keyword::LEADING => keyword.value(TrimWhereField::Leading),
1121 Keyword::TRAILING => keyword.value(TrimWhereField::Trailing),
1122 _ => fail
1123 }
1124 .expect("BOTH, LEADING, or TRAILING")
1125 .parse_next(self)
1126 }
1127
1128 pub fn parse_array_expr(&mut self) -> ModalResult<Expr> {
1130 let mut expected_depth = None;
1131 let exprs = self.parse_array_inner(0, &mut expected_depth)?;
1132 Ok(Expr::Array(Array {
1133 elem: exprs,
1134 named: true,
1136 }))
1137 }
1138
1139 fn parse_array_inner(
1140 &mut self,
1141 depth: usize,
1142 expected_depth: &mut Option<usize>,
1143 ) -> ModalResult<Vec<Expr>> {
1144 self.expect_token(&Token::LBracket)?;
1145 if let Some(expected_depth) = *expected_depth
1146 && depth > expected_depth
1147 {
1148 return self.expected("]");
1149 }
1150 let exprs = if self.peek_token() == Token::LBracket {
1151 self.parse_comma_separated(|parser| {
1152 let exprs = parser.parse_array_inner(depth + 1, expected_depth)?;
1153 Ok(Expr::Array(Array {
1154 elem: exprs,
1155 named: false,
1156 }))
1157 })?
1158 } else {
1159 if let Some(expected_depth) = *expected_depth {
1160 if depth < expected_depth {
1161 return self.expected("[");
1162 }
1163 } else {
1164 *expected_depth = Some(depth);
1165 }
1166 if self.consume_token(&Token::RBracket) {
1167 return Ok(vec![]);
1168 }
1169 self.parse_comma_separated(Self::parse_expr)?
1170 };
1171 self.expect_token(&Token::RBracket)?;
1172 Ok(exprs)
1173 }
1174
1175 pub fn parse_map_expr(&mut self) -> ModalResult<Expr> {
1177 self.expect_token(&Token::LBrace)?;
1178 if self.consume_token(&Token::RBrace) {
1179 return Ok(Expr::Map { entries: vec![] });
1180 }
1181 let entries = self.parse_comma_separated(|parser| {
1182 let key = parser.parse_expr()?;
1183 parser.expect_token(&Token::Colon)?;
1184 let value = parser.parse_expr()?;
1185 Ok((key, value))
1186 })?;
1187 self.expect_token(&Token::RBrace)?;
1188 Ok(Expr::Map { entries })
1189 }
1190
1191 pub fn parse_date_time_field(&mut self) -> ModalResult<DateTimeField> {
1193 dispatch! { peek(keyword);
1194 Keyword::YEAR => keyword.value(DateTimeField::Year),
1195 Keyword::MONTH => keyword.value(DateTimeField::Month),
1196 Keyword::DAY => keyword.value(DateTimeField::Day),
1197 Keyword::HOUR => keyword.value(DateTimeField::Hour),
1198 Keyword::MINUTE => keyword.value(DateTimeField::Minute),
1199 Keyword::SECOND => keyword.value(DateTimeField::Second),
1200 _ => fail,
1201 }
1202 .expect("date/time field")
1203 .parse_next(self)
1204 }
1205
1206 pub fn parse_date_time_field_in_extract(&mut self) -> ModalResult<String> {
1216 let checkpoint = *self;
1217 let token = self.next_token();
1218 match token.token {
1219 Token::Word(w) => Ok(w.value.to_uppercase()),
1220 Token::SingleQuotedString(s) => Ok(s.to_uppercase()),
1221 _ => {
1222 *self = checkpoint;
1223 self.expected("date/time field")
1224 }
1225 }
1226 }
1227
1228 pub fn parse_literal_interval(&mut self) -> ModalResult<Expr> {
1241 let value = self.parse_literal_string()?;
1249
1250 let leading_field = match self.peek_token().token {
1256 Token::Word(kw)
1257 if [
1258 Keyword::YEAR,
1259 Keyword::MONTH,
1260 Keyword::DAY,
1261 Keyword::HOUR,
1262 Keyword::MINUTE,
1263 Keyword::SECOND,
1264 ]
1265 .contains(&kw.keyword) =>
1266 {
1267 Some(self.parse_date_time_field()?)
1268 }
1269 _ => None,
1270 };
1271
1272 let (leading_precision, last_field, fsec_precision) =
1273 if leading_field == Some(DateTimeField::Second) {
1274 let last_field = None;
1280 let (leading_precision, fsec_precision) = self.parse_optional_precision_scale()?;
1281 (leading_precision, last_field, fsec_precision)
1282 } else {
1283 let leading_precision = self.parse_optional_precision()?;
1284 if self.parse_keyword(Keyword::TO) {
1285 let last_field = Some(self.parse_date_time_field()?);
1286 let fsec_precision = if last_field == Some(DateTimeField::Second) {
1287 self.parse_optional_precision()?
1288 } else {
1289 None
1290 };
1291 (leading_precision, last_field, fsec_precision)
1292 } else {
1293 (leading_precision, None, None)
1294 }
1295 };
1296
1297 Ok(Expr::Value(Value::Interval {
1298 value,
1299 leading_field,
1300 leading_precision,
1301 last_field,
1302 fractional_seconds_precision: fsec_precision,
1303 }))
1304 }
1305
1306 pub fn parse_infix(&mut self, expr: Expr, precedence: Precedence) -> ModalResult<Expr> {
1308 let checkpoint = *self;
1309 let tok = self.next_token();
1310 debug!("parsing infix {:?}", tok.token);
1311 let regular_binary_operator = match &tok.token {
1312 Token::Eq => Some(BinaryOperator::Eq),
1313 Token::Neq => Some(BinaryOperator::NotEq),
1314 Token::Gt => Some(BinaryOperator::Gt),
1315 Token::GtEq => Some(BinaryOperator::GtEq),
1316 Token::Lt => Some(BinaryOperator::Lt),
1317 Token::LtEq => Some(BinaryOperator::LtEq),
1318 Token::Plus => Some(BinaryOperator::Plus),
1319 Token::Minus => Some(BinaryOperator::Minus),
1320 Token::Mul => Some(BinaryOperator::Multiply),
1321 Token::Mod => Some(BinaryOperator::Modulo),
1322 Token::Pipe => Some(BinaryOperator::Custom("|".to_owned())),
1323 Token::Caret => Some(BinaryOperator::Pow),
1324 Token::Div => Some(BinaryOperator::Divide),
1325 Token::Op(name) => Some(BinaryOperator::Custom(name.clone())),
1326 Token::Word(w) => match w.keyword {
1327 Keyword::AND => Some(BinaryOperator::And),
1328 Keyword::OR => Some(BinaryOperator::Or),
1329 Keyword::XOR => Some(BinaryOperator::Xor),
1330 Keyword::OPERATOR if self.peek_token() == Token::LParen => Some(
1331 BinaryOperator::PGQualified(Box::new(self.parse_qualified_operator()?)),
1332 ),
1333 _ => None,
1334 },
1335 _ => None,
1336 };
1337
1338 if let Some(op) = regular_binary_operator {
1339 Ok(Expr::BinaryOp {
1368 left: Box::new(expr),
1369 op,
1370 right: Box::new(self.parse_subexpr(precedence)?),
1371 })
1372 } else if let Token::Word(w) = &tok.token {
1374 match w.keyword {
1375 Keyword::IS => {
1376 if self.parse_keyword(Keyword::TRUE) {
1377 Ok(Expr::IsTrue(Box::new(expr)))
1378 } else if self.parse_keywords(&[Keyword::NOT, Keyword::TRUE]) {
1379 Ok(Expr::IsNotTrue(Box::new(expr)))
1380 } else if self.parse_keyword(Keyword::FALSE) {
1381 Ok(Expr::IsFalse(Box::new(expr)))
1382 } else if self.parse_keywords(&[Keyword::NOT, Keyword::FALSE]) {
1383 Ok(Expr::IsNotFalse(Box::new(expr)))
1384 } else if self.parse_keyword(Keyword::UNKNOWN) {
1385 Ok(Expr::IsUnknown(Box::new(expr)))
1386 } else if self.parse_keywords(&[Keyword::NOT, Keyword::UNKNOWN]) {
1387 Ok(Expr::IsNotUnknown(Box::new(expr)))
1388 } else if self.parse_keyword(Keyword::NULL) {
1389 Ok(Expr::IsNull(Box::new(expr)))
1390 } else if self.parse_keywords(&[Keyword::NOT, Keyword::NULL]) {
1391 Ok(Expr::IsNotNull(Box::new(expr)))
1392 } else if self.parse_keywords(&[Keyword::DISTINCT, Keyword::FROM]) {
1393 let expr2 = self.parse_expr()?;
1394 Ok(Expr::IsDistinctFrom(Box::new(expr), Box::new(expr2)))
1395 } else if self.parse_keywords(&[Keyword::NOT, Keyword::DISTINCT, Keyword::FROM])
1396 {
1397 let expr2 = self.parse_expr()?;
1398 Ok(Expr::IsNotDistinctFrom(Box::new(expr), Box::new(expr2)))
1399 } else {
1400 let negated = self.parse_keyword(Keyword::NOT);
1401
1402 if self.parse_keyword(Keyword::JSON) {
1403 self.parse_is_json(expr, negated)
1404 } else {
1405 self.expected(
1406 "[NOT] { TRUE | FALSE | UNKNOWN | NULL | DISTINCT FROM | JSON } after IS",
1407 )
1408 }
1409 }
1410 }
1411 Keyword::AT => {
1412 assert_eq!(precedence, Precedence::At);
1413 let time_zone = Box::new(
1414 preceded(
1415 (Keyword::TIME, Keyword::ZONE),
1416 cut_err(|p: &mut Self| p.parse_subexpr(precedence)),
1417 )
1418 .parse_next(self)?,
1419 );
1420 Ok(Expr::AtTimeZone {
1421 timestamp: Box::new(expr),
1422 time_zone,
1423 })
1424 }
1425 keyword @ (Keyword::ALL | Keyword::ANY | Keyword::SOME) => {
1426 self.expect_token(&Token::LParen)?;
1427 let sub = self.parse_expr()?;
1430 self.expect_token(&Token::RParen)?;
1431
1432 if let Expr::Subquery(_) = &sub {
1434 parser_err!("ANY/SOME/ALL(Subquery) is not implemented");
1435 }
1436
1437 Ok(match keyword {
1438 Keyword::ALL => Expr::AllOp(Box::new(sub)),
1439 Keyword::ANY | Keyword::SOME => Expr::SomeOp(Box::new(sub)),
1441 _ => unreachable!(),
1442 })
1443 }
1444 Keyword::NOT
1445 | Keyword::IN
1446 | Keyword::BETWEEN
1447 | Keyword::LIKE
1448 | Keyword::ILIKE
1449 | Keyword::SIMILAR => {
1450 *self = checkpoint;
1451 let negated = self.parse_keyword(Keyword::NOT);
1452 if self.parse_keyword(Keyword::IN) {
1453 self.parse_in(expr, negated)
1454 } else if self.parse_keyword(Keyword::BETWEEN) {
1455 self.parse_between(expr, negated)
1456 } else if self.parse_keyword(Keyword::LIKE) {
1457 Ok(Expr::Like {
1458 negated,
1459 expr: Box::new(expr),
1460 pattern: Box::new(self.parse_subexpr(Precedence::Like)?),
1461 escape_char: self.parse_escape()?,
1462 })
1463 } else if self.parse_keyword(Keyword::ILIKE) {
1464 Ok(Expr::ILike {
1465 negated,
1466 expr: Box::new(expr),
1467 pattern: Box::new(self.parse_subexpr(Precedence::Like)?),
1468 escape_char: self.parse_escape()?,
1469 })
1470 } else if self.parse_keywords(&[Keyword::SIMILAR, Keyword::TO]) {
1471 Ok(Expr::SimilarTo {
1472 negated,
1473 expr: Box::new(expr),
1474 pattern: Box::new(self.parse_subexpr(Precedence::Like)?),
1475 escape_char: self.parse_escape()?,
1476 })
1477 } else {
1478 self.expected("IN, BETWEEN or SIMILAR TO after NOT")
1479 }
1480 }
1481 _ => parser_err!("No infix parser for token {:?}", tok),
1483 }
1484 } else if Token::DoubleColon == tok {
1485 self.parse_pg_cast(expr)
1486 } else if Token::LBracket == tok {
1487 self.parse_array_index(expr)
1488 } else {
1489 parser_err!("No infix parser for token {:?}", tok)
1491 }
1492 }
1493
1494 pub fn parse_escape(&mut self) -> ModalResult<Option<EscapeChar>> {
1496 if self.parse_keyword(Keyword::ESCAPE) {
1497 let s = self.parse_literal_string()?;
1498 let mut chs = s.chars();
1499 if let Some(ch) = chs.next() {
1500 if chs.next().is_some() {
1501 parser_err!("Escape string must be empty or one character, found {s:?}")
1502 } else {
1503 Ok(Some(EscapeChar::escape(ch)))
1504 }
1505 } else {
1506 Ok(Some(EscapeChar::empty()))
1507 }
1508 } else {
1509 Ok(None)
1510 }
1511 }
1512
1513 pub fn parse_array_index(&mut self, expr: Expr) -> ModalResult<Expr> {
1516 let new_expr = match self.peek_token().token {
1517 Token::Colon => {
1518 assert!(self.consume_token(&Token::Colon));
1520 let end = match self.peek_token().token {
1521 Token::RBracket => None,
1522 _ => {
1523 let end_index = Box::new(self.parse_expr()?);
1524 Some(end_index)
1525 }
1526 };
1527 Expr::ArrayRangeIndex {
1528 obj: Box::new(expr),
1529 start: None,
1530 end,
1531 }
1532 }
1533 _ => {
1534 let index = Box::new(self.parse_expr()?);
1536 match self.peek_token().token {
1537 Token::Colon => {
1538 assert!(self.consume_token(&Token::Colon));
1540 match self.peek_token().token {
1541 Token::RBracket => {
1542 Expr::ArrayRangeIndex {
1544 obj: Box::new(expr),
1545 start: Some(index),
1546 end: None,
1547 }
1548 }
1549 _ => {
1550 let end = Some(Box::new(self.parse_expr()?));
1552 Expr::ArrayRangeIndex {
1553 obj: Box::new(expr),
1554 start: Some(index),
1555 end,
1556 }
1557 }
1558 }
1559 }
1560 _ => {
1561 Expr::Index {
1563 obj: Box::new(expr),
1564 index,
1565 }
1566 }
1567 }
1568 }
1569 };
1570 self.expect_token(&Token::RBracket)?;
1571 if self.consume_token(&Token::LBracket) {
1573 self.parse_array_index(new_expr)
1574 } else {
1575 Ok(new_expr)
1576 }
1577 }
1578
1579 pub fn parse_is_json(&mut self, expr: Expr, negated: bool) -> ModalResult<Expr> {
1581 let item_type = match self.peek_token().token {
1582 Token::Word(w) => match w.keyword {
1583 Keyword::VALUE => Some(JsonPredicateType::Value),
1584 Keyword::ARRAY => Some(JsonPredicateType::Array),
1585 Keyword::OBJECT => Some(JsonPredicateType::Object),
1586 Keyword::SCALAR => Some(JsonPredicateType::Scalar),
1587 _ => None,
1588 },
1589 _ => None,
1590 };
1591 if item_type.is_some() {
1592 self.next_token();
1593 }
1594 let item_type = item_type.unwrap_or_default();
1595
1596 let unique_keys = self.parse_one_of_keywords(&[Keyword::WITH, Keyword::WITHOUT]);
1597 if unique_keys.is_some() {
1598 self.expect_keyword(Keyword::UNIQUE)?;
1599 _ = self.parse_keyword(Keyword::KEYS);
1600 }
1601 let unique_keys = unique_keys.is_some_and(|w| w == Keyword::WITH);
1602
1603 Ok(Expr::IsJson {
1604 expr: Box::new(expr),
1605 negated,
1606 item_type,
1607 unique_keys,
1608 })
1609 }
1610
1611 pub fn parse_in(&mut self, expr: Expr, negated: bool) -> ModalResult<Expr> {
1613 self.expect_token(&Token::LParen)?;
1614 let in_op = if matches!(self.peek_token().token, Token::Word(w) if w.keyword == Keyword::SELECT || w.keyword == Keyword::WITH)
1615 {
1616 Expr::InSubquery {
1617 expr: Box::new(expr),
1618 subquery: Box::new(self.parse_query()?),
1619 negated,
1620 }
1621 } else {
1622 Expr::InList {
1623 expr: Box::new(expr),
1624 list: self.parse_comma_separated(Parser::parse_expr)?,
1625 negated,
1626 }
1627 };
1628 self.expect_token(&Token::RParen)?;
1629 Ok(in_op)
1630 }
1631
1632 pub fn parse_between(&mut self, expr: Expr, negated: bool) -> ModalResult<Expr> {
1634 let low = self.parse_subexpr(Precedence::Between)?;
1637 self.expect_keyword(Keyword::AND)?;
1638 let high = self.parse_subexpr(Precedence::Between)?;
1639 Ok(Expr::Between {
1640 expr: Box::new(expr),
1641 negated,
1642 low: Box::new(low),
1643 high: Box::new(high),
1644 })
1645 }
1646
1647 pub fn parse_pg_cast(&mut self, expr: Expr) -> ModalResult<Expr> {
1649 Ok(Expr::Cast {
1650 expr: Box::new(expr),
1651 data_type: self.parse_data_type()?,
1652 })
1653 }
1654
1655 pub fn get_next_precedence(&self) -> ModalResult<Precedence> {
1657 use Precedence as P;
1658
1659 let token = self.peek_token();
1660 debug!("get_next_precedence() {:?}", token);
1661 match token.token {
1662 Token::Word(w) if w.keyword == Keyword::OR => Ok(P::LogicalOr),
1663 Token::Word(w) if w.keyword == Keyword::XOR => Ok(P::LogicalXor),
1664 Token::Word(w) if w.keyword == Keyword::AND => Ok(P::LogicalAnd),
1665 Token::Word(w) if w.keyword == Keyword::AT => {
1666 match (self.peek_nth_token(1).token, self.peek_nth_token(2).token) {
1667 (Token::Word(w), Token::Word(w2))
1668 if w.keyword == Keyword::TIME && w2.keyword == Keyword::ZONE =>
1669 {
1670 Ok(P::At)
1671 }
1672 _ => Ok(P::Zero),
1673 }
1674 }
1675
1676 Token::Word(w) if w.keyword == Keyword::NOT => match self.peek_nth_token(1).token {
1677 Token::Word(w) if w.keyword == Keyword::BETWEEN => Ok(P::Between),
1683 Token::Word(w) if w.keyword == Keyword::IN => Ok(P::Between),
1684 Token::Word(w) if w.keyword == Keyword::LIKE => Ok(P::Like),
1685 Token::Word(w) if w.keyword == Keyword::ILIKE => Ok(P::Like),
1686 Token::Word(w) if w.keyword == Keyword::SIMILAR => Ok(P::Like),
1687 _ => Ok(P::Zero),
1688 },
1689
1690 Token::Word(w) if w.keyword == Keyword::IS => Ok(P::Is),
1691 Token::Word(w) if w.keyword == Keyword::ISNULL => Ok(P::Is),
1692 Token::Word(w) if w.keyword == Keyword::NOTNULL => Ok(P::Is),
1693 Token::Eq | Token::Lt | Token::LtEq | Token::Neq | Token::Gt | Token::GtEq => {
1694 Ok(P::Cmp)
1695 }
1696 Token::Word(w) if w.keyword == Keyword::IN => Ok(P::Between),
1697 Token::Word(w) if w.keyword == Keyword::BETWEEN => Ok(P::Between),
1698 Token::Word(w) if w.keyword == Keyword::LIKE => Ok(P::Like),
1699 Token::Word(w) if w.keyword == Keyword::ILIKE => Ok(P::Like),
1700 Token::Word(w) if w.keyword == Keyword::SIMILAR => Ok(P::Like),
1701 Token::Word(w) if w.keyword == Keyword::ALL => Ok(P::Other),
1702 Token::Word(w) if w.keyword == Keyword::ANY => Ok(P::Other),
1703 Token::Word(w) if w.keyword == Keyword::SOME => Ok(P::Other),
1704 Token::Op(_) => Ok(P::Other),
1705 Token::Word(w)
1706 if w.keyword == Keyword::OPERATOR && self.peek_nth_token(1) == Token::LParen =>
1707 {
1708 Ok(P::Other)
1709 }
1710 Token::Pipe => Ok(P::Other),
1714 Token::Plus | Token::Minus => Ok(P::PlusMinus),
1715 Token::Mul | Token::Div | Token::Mod => Ok(P::MulDiv),
1716 Token::Caret => Ok(P::Exp),
1717 Token::LBracket => Ok(P::Array),
1718 Token::DoubleColon => Ok(P::DoubleColon),
1719 _ => Ok(P::Zero),
1720 }
1721 }
1722
1723 pub fn peek_token(&self) -> TokenWithLocation {
1726 self.peek_nth_token(0)
1727 }
1728
1729 pub fn peek_nth_token(&self, mut n: usize) -> TokenWithLocation {
1731 let mut index = 0;
1732 loop {
1733 let token = self.0.get(index);
1734 index += 1;
1735 match token.map(|x| &x.token) {
1736 Some(Token::Whitespace(_)) => continue,
1737 _ => {
1738 if n == 0 {
1739 return token.cloned().unwrap_or(TokenWithLocation::eof());
1740 }
1741 n -= 1;
1742 }
1743 }
1744 }
1745 }
1746
1747 pub fn next_token(&mut self) -> TokenWithLocation {
1751 loop {
1752 let Some(token) = self.0.first() else {
1753 return TokenWithLocation::eof();
1754 };
1755 self.0 = &self.0[1..];
1756 match token.token {
1757 Token::Whitespace(_) => continue,
1758 _ => return token.clone(),
1759 }
1760 }
1761 }
1762
1763 pub fn next_token_no_skip(&mut self) -> Option<&TokenWithLocation> {
1765 if self.0.is_empty() {
1766 None
1767 } else {
1768 let (first, rest) = self.0.split_at(1);
1769 self.0 = rest;
1770 Some(&first[0])
1771 }
1772 }
1773
1774 pub fn expected<T>(&self, expected: &str) -> ModalResult<T> {
1776 parser_err!("expected {}, found: {}", expected, self.peek_token().token)
1777 }
1778
1779 pub fn expected_at<T>(&mut self, checkpoint: Self, expected: &str) -> ModalResult<T> {
1781 *self = checkpoint;
1782 self.expected(expected)
1783 }
1784
1785 pub fn parse_word(&mut self, expected: &str) -> bool {
1788 match self.peek_token().token {
1789 Token::Word(w) if w.value.to_uppercase() == expected => {
1790 self.next_token();
1791 true
1792 }
1793 _ => false,
1794 }
1795 }
1796
1797 pub fn expect_word(&mut self, expected: &str) -> ModalResult<()> {
1798 if self.parse_word(expected) {
1799 Ok(())
1800 } else {
1801 self.expected(expected)
1802 }
1803 }
1804
1805 #[must_use]
1807 pub fn parse_keyword(&mut self, expected: Keyword) -> bool {
1808 match self.peek_token().token {
1809 Token::Word(w) if expected == w.keyword => {
1810 self.next_token();
1811 true
1812 }
1813 _ => false,
1814 }
1815 }
1816
1817 #[must_use]
1819 pub fn parse_keywords(&mut self, keywords: &[Keyword]) -> bool {
1820 let checkpoint = *self;
1821 for &keyword in keywords {
1822 if !self.parse_keyword(keyword) {
1823 *self = checkpoint;
1826 return false;
1827 }
1828 }
1829 true
1830 }
1831
1832 #[must_use]
1834 pub fn parse_one_of_keywords(&mut self, keywords: &[Keyword]) -> Option<Keyword> {
1835 match self.peek_token().token {
1836 Token::Word(w) => {
1837 keywords
1838 .iter()
1839 .find(|keyword| **keyword == w.keyword)
1840 .map(|keyword| {
1841 self.next_token();
1842 *keyword
1843 })
1844 }
1845 _ => None,
1846 }
1847 }
1848
1849 pub fn peek_nth_any_of_keywords(&mut self, n: usize, keywords: &[Keyword]) -> bool {
1850 match self.peek_nth_token(n).token {
1851 Token::Word(w) => keywords.contains(&w.keyword),
1852 _ => false,
1853 }
1854 }
1855
1856 pub fn expect_one_of_keywords(&mut self, keywords: &[Keyword]) -> ModalResult<Keyword> {
1858 if let Some(keyword) = self.parse_one_of_keywords(keywords) {
1859 Ok(keyword)
1860 } else {
1861 let keywords: Vec<String> = keywords.iter().map(|x| format!("{:?}", x)).collect();
1862 self.expected(&format!("one of {}", keywords.join(" or ")))
1863 }
1864 }
1865
1866 pub fn expect_keyword(&mut self, expected: Keyword) -> ModalResult<()> {
1868 if self.parse_keyword(expected) {
1869 Ok(())
1870 } else {
1871 self.expected(format!("{:?}", &expected).as_str())
1872 }
1873 }
1874
1875 pub fn expect_keywords(&mut self, expected: &[Keyword]) -> ModalResult<()> {
1878 for &kw in expected {
1879 self.expect_keyword(kw)?;
1880 }
1881 Ok(())
1882 }
1883
1884 #[must_use]
1886 pub fn consume_token(&mut self, expected: &Token) -> bool {
1887 if self.peek_token() == *expected {
1888 self.next_token();
1889 true
1890 } else {
1891 false
1892 }
1893 }
1894
1895 pub fn expect_token(&mut self, expected: &Token) -> ModalResult<()> {
1897 if self.consume_token(expected) {
1898 Ok(())
1899 } else {
1900 self.expected(&expected.to_string())
1901 }
1902 }
1903
1904 pub fn parse_comma_separated<T, F>(&mut self, mut f: F) -> ModalResult<Vec<T>>
1906 where
1907 F: FnMut(&mut Self) -> ModalResult<T>,
1908 {
1909 let mut values = vec![];
1910 loop {
1911 values.push(f(self)?);
1912 if !self.consume_token(&Token::Comma) {
1913 break;
1914 }
1915 }
1916 Ok(values)
1917 }
1918
1919 #[must_use]
1922 fn maybe_parse<T, F>(&mut self, mut f: F) -> Option<T>
1923 where
1924 F: FnMut(&mut Self) -> ModalResult<T>,
1925 {
1926 let checkpoint = *self;
1927 match f(self) {
1928 Ok(t) => Some(t),
1929 _ => {
1930 *self = checkpoint;
1931 None
1932 }
1933 }
1934 }
1935
1936 pub fn parse_all_or_distinct(&mut self) -> ModalResult<bool> {
1939 let all = self.parse_keyword(Keyword::ALL);
1940 let distinct = self.parse_keyword(Keyword::DISTINCT);
1941 if all && distinct {
1942 parser_err!("Cannot specify both ALL and DISTINCT")
1943 } else {
1944 Ok(distinct)
1945 }
1946 }
1947
1948 pub fn parse_all_or_distinct_on(&mut self) -> ModalResult<Distinct> {
1950 if self.parse_keywords(&[Keyword::DISTINCT, Keyword::ON]) {
1951 self.expect_token(&Token::LParen)?;
1952 let exprs = self.parse_comma_separated(Parser::parse_expr)?;
1953 self.expect_token(&Token::RParen)?;
1954 return Ok(Distinct::DistinctOn(exprs));
1955 } else if self.parse_keyword(Keyword::DISTINCT) {
1956 return Ok(Distinct::Distinct);
1957 };
1958 _ = self.parse_keyword(Keyword::ALL);
1959 Ok(Distinct::All)
1960 }
1961
1962 pub fn parse_create(&mut self) -> ModalResult<Statement> {
1964 let or_replace = self.parse_keywords(&[Keyword::OR, Keyword::REPLACE]);
1965 let temporary = self
1966 .parse_one_of_keywords(&[Keyword::TEMP, Keyword::TEMPORARY])
1967 .is_some();
1968 if self.parse_keyword(Keyword::TABLE) {
1969 self.parse_create_table(or_replace, temporary)
1970 } else if self.parse_keyword(Keyword::VIEW) {
1971 self.parse_create_view(false, or_replace)
1972 } else if self.parse_keywords(&[Keyword::MATERIALIZED, Keyword::VIEW]) {
1973 self.parse_create_view(true, or_replace)
1974 } else if self.parse_keywords(&[Keyword::MATERIALIZED, Keyword::SOURCE]) {
1975 parser_err!("CREATE MATERIALIZED SOURCE has been deprecated, use CREATE TABLE instead")
1976 } else if self.parse_keyword(Keyword::SOURCE) {
1977 self.parse_create_source(or_replace, temporary)
1978 } else if self.parse_keyword(Keyword::SINK) {
1979 self.parse_create_sink(or_replace)
1980 } else if self.parse_keyword(Keyword::SUBSCRIPTION) {
1981 self.parse_create_subscription(or_replace)
1982 } else if self.parse_keyword(Keyword::CONNECTION) {
1983 self.parse_create_connection()
1984 } else if self.parse_keyword(Keyword::FUNCTION) {
1985 self.parse_create_function(or_replace, temporary)
1986 } else if self.parse_keyword(Keyword::AGGREGATE) {
1987 self.parse_create_aggregate(or_replace)
1988 } else if or_replace {
1989 self.expected(
1990 "[EXTERNAL] TABLE or [MATERIALIZED] VIEW or [MATERIALIZED] SOURCE or SINK or FUNCTION after CREATE OR REPLACE",
1991 )
1992 } else if self.parse_keyword(Keyword::INDEX) {
1993 self.parse_create_index(false)
1994 } else if self.parse_keywords(&[Keyword::UNIQUE, Keyword::INDEX]) {
1995 self.parse_create_index(true)
1996 } else if self.parse_keyword(Keyword::SCHEMA) {
1997 self.parse_create_schema()
1998 } else if self.parse_keyword(Keyword::DATABASE) {
1999 self.parse_create_database()
2000 } else if self.parse_keyword(Keyword::USER) {
2001 self.parse_create_user()
2002 } else if self.parse_keyword(Keyword::SECRET) {
2003 self.parse_create_secret()
2004 } else {
2005 self.expected("an object type after CREATE")
2006 }
2007 }
2008
2009 pub fn parse_create_schema(&mut self) -> ModalResult<Statement> {
2010 let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]);
2011 let (schema_name, owner) = if self.parse_keyword(Keyword::AUTHORIZATION) {
2012 let owner = self.parse_object_name()?;
2013 (owner.clone(), Some(owner))
2014 } else {
2015 let schema_name = self.parse_object_name()?;
2016 let owner = if self.parse_keyword(Keyword::AUTHORIZATION) {
2017 Some(self.parse_object_name()?)
2018 } else {
2019 None
2020 };
2021 (schema_name, owner)
2022 };
2023 Ok(Statement::CreateSchema {
2024 schema_name,
2025 if_not_exists,
2026 owner,
2027 })
2028 }
2029
2030 pub fn parse_create_database(&mut self) -> ModalResult<Statement> {
2031 let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]);
2032 let db_name = self.parse_object_name()?;
2033 let _ = self.parse_keyword(Keyword::WITH);
2034
2035 let mut owner = None;
2036 let mut resource_group = None;
2037 let mut barrier_interval_ms = None;
2038 let mut checkpoint_frequency = None;
2039
2040 loop {
2041 if let Some(keyword) =
2042 self.parse_one_of_keywords(&[Keyword::OWNER, Keyword::RESOURCE_GROUP])
2043 {
2044 match keyword {
2045 Keyword::OWNER => {
2046 if owner.is_some() {
2047 parser_err!("duplicate OWNER clause in CREATE DATABASE");
2048 }
2049
2050 let _ = self.consume_token(&Token::Eq);
2051 owner = Some(self.parse_object_name()?);
2052 }
2053 Keyword::RESOURCE_GROUP => {
2054 if resource_group.is_some() {
2055 parser_err!("duplicate RESOURCE_GROUP clause in CREATE DATABASE");
2056 }
2057
2058 let _ = self.consume_token(&Token::Eq);
2059 resource_group = Some(self.parse_set_variable()?);
2060 }
2061 _ => unreachable!(),
2062 }
2063 } else if self.parse_word("BARRIER_INTERVAL_MS") {
2064 if barrier_interval_ms.is_some() {
2065 parser_err!("duplicate BARRIER_INTERVAL_MS clause in CREATE DATABASE");
2066 }
2067
2068 let _ = self.consume_token(&Token::Eq);
2069 barrier_interval_ms = Some(self.parse_literal_u32()?);
2070 } else if self.parse_word("CHECKPOINT_FREQUENCY") {
2071 if checkpoint_frequency.is_some() {
2072 parser_err!("duplicate CHECKPOINT_FREQUENCY clause in CREATE DATABASE");
2073 }
2074
2075 let _ = self.consume_token(&Token::Eq);
2076 checkpoint_frequency = Some(self.parse_literal_u64()?);
2077 } else {
2078 break;
2079 }
2080 }
2081
2082 Ok(Statement::CreateDatabase {
2083 db_name,
2084 if_not_exists,
2085 owner,
2086 resource_group,
2087 barrier_interval_ms,
2088 checkpoint_frequency,
2089 })
2090 }
2091
2092 pub fn parse_create_view(
2093 &mut self,
2094 materialized: bool,
2095 or_replace: bool,
2096 ) -> ModalResult<Statement> {
2097 let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]);
2098 let name = self.parse_object_name()?;
2101 let columns = self.parse_parenthesized_column_list(Optional)?;
2102 let with_options = self.parse_options_with_preceding_keyword(Keyword::WITH)?;
2103 self.expect_keyword(Keyword::AS)?;
2104 let query = Box::new(self.parse_query()?);
2105 let emit_mode = if materialized {
2106 self.parse_emit_mode()?
2107 } else {
2108 None
2109 };
2110 Ok(Statement::CreateView {
2112 if_not_exists,
2113 name,
2114 columns,
2115 query,
2116 materialized,
2117 or_replace,
2118 with_options,
2119 emit_mode,
2120 })
2121 }
2122
2123 pub fn parse_create_source(
2132 &mut self,
2133 _or_replace: bool,
2134 temporary: bool,
2135 ) -> ModalResult<Statement> {
2136 impl_parse_to!(if_not_exists => [Keyword::IF, Keyword::NOT, Keyword::EXISTS], self);
2137 impl_parse_to!(source_name: ObjectName, self);
2138
2139 let (columns, constraints, source_watermarks, wildcard_idx) =
2141 self.parse_columns_with_watermark()?;
2142 let include_options = self.parse_include_options()?;
2143
2144 let with_options = self.parse_with_properties()?;
2145 let option = with_options
2146 .iter()
2147 .find(|&opt| opt.name.real_value() == UPSTREAM_SOURCE_KEY);
2148 let connector: String = option.map(|opt| opt.value.to_string()).unwrap_or_default();
2149 let cdc_source_job = connector.contains("-cdc");
2150 if cdc_source_job && (!columns.is_empty() || !constraints.is_empty()) {
2151 parser_err!("CDC source cannot define columns and constraints");
2152 }
2153
2154 let format_encode = self.parse_format_encode_with_connector(&connector, cdc_source_job)?;
2157
2158 let stmt = CreateSourceStatement {
2159 temporary,
2160 if_not_exists,
2161 columns,
2162 wildcard_idx,
2163 constraints,
2164 source_name,
2165 with_properties: WithProperties(with_options),
2166 format_encode,
2167 source_watermarks,
2168 include_column_options: include_options,
2169 };
2170
2171 Ok(Statement::CreateSource { stmt })
2172 }
2173
2174 pub fn parse_create_sink(&mut self, _or_replace: bool) -> ModalResult<Statement> {
2182 Ok(Statement::CreateSink {
2183 stmt: CreateSinkStatement::parse_to(self)?,
2184 })
2185 }
2186
2187 pub fn parse_create_subscription(&mut self, _or_replace: bool) -> ModalResult<Statement> {
2195 Ok(Statement::CreateSubscription {
2196 stmt: CreateSubscriptionStatement::parse_to(self)?,
2197 })
2198 }
2199
2200 pub fn parse_create_connection(&mut self) -> ModalResult<Statement> {
2206 Ok(Statement::CreateConnection {
2207 stmt: CreateConnectionStatement::parse_to(self)?,
2208 })
2209 }
2210
2211 pub fn parse_create_function(
2212 &mut self,
2213 or_replace: bool,
2214 temporary: bool,
2215 ) -> ModalResult<Statement> {
2216 impl_parse_to!(if_not_exists => [Keyword::IF, Keyword::NOT, Keyword::EXISTS], self);
2217
2218 let FunctionDesc { name, args } = self.parse_function_desc()?;
2219
2220 let return_type = if self.parse_keyword(Keyword::RETURNS) {
2221 if self.parse_keyword(Keyword::TABLE) {
2222 self.expect_token(&Token::LParen)?;
2223 let mut values = vec![];
2224 loop {
2225 values.push(self.parse_table_column_def()?);
2226 let comma = self.consume_token(&Token::Comma);
2227 if self.consume_token(&Token::RParen) {
2228 break;
2230 } else if !comma {
2231 return self.expected("',' or ')'");
2232 }
2233 }
2234 Some(CreateFunctionReturns::Table(values))
2235 } else {
2236 Some(CreateFunctionReturns::Value(self.parse_data_type()?))
2237 }
2238 } else {
2239 None
2240 };
2241
2242 let params = self.parse_create_function_body()?;
2243 let with_options = self.parse_options_with_preceding_keyword(Keyword::WITH)?;
2244 let with_options = with_options.try_into()?;
2245 Ok(Statement::CreateFunction {
2246 or_replace,
2247 temporary,
2248 if_not_exists,
2249 name,
2250 args,
2251 returns: return_type,
2252 params,
2253 with_options,
2254 })
2255 }
2256
2257 fn parse_create_aggregate(&mut self, or_replace: bool) -> ModalResult<Statement> {
2258 impl_parse_to!(if_not_exists => [Keyword::IF, Keyword::NOT, Keyword::EXISTS], self);
2259
2260 let name = self.parse_object_name()?;
2261 self.expect_token(&Token::LParen)?;
2262 let args = self.parse_comma_separated(Parser::parse_function_arg)?;
2263 self.expect_token(&Token::RParen)?;
2264
2265 self.expect_keyword(Keyword::RETURNS)?;
2266 let returns = self.parse_data_type()?;
2267
2268 let append_only = self.parse_keywords(&[Keyword::APPEND, Keyword::ONLY]);
2269 let params = self.parse_create_function_body()?;
2270
2271 Ok(Statement::CreateAggregate {
2272 or_replace,
2273 if_not_exists,
2274 name,
2275 args,
2276 returns,
2277 append_only,
2278 params,
2279 })
2280 }
2281
2282 pub fn parse_declare(&mut self) -> ModalResult<Statement> {
2283 Ok(Statement::DeclareCursor {
2284 stmt: DeclareCursorStatement::parse_to(self)?,
2285 })
2286 }
2287
2288 pub fn parse_fetch_cursor(&mut self) -> ModalResult<Statement> {
2289 Ok(Statement::FetchCursor {
2290 stmt: FetchCursorStatement::parse_to(self)?,
2291 })
2292 }
2293
2294 pub fn parse_close_cursor(&mut self) -> ModalResult<Statement> {
2295 Ok(Statement::CloseCursor {
2296 stmt: CloseCursorStatement::parse_to(self)?,
2297 })
2298 }
2299
2300 fn parse_table_column_def(&mut self) -> ModalResult<TableColumnDef> {
2301 Ok(TableColumnDef {
2302 name: self.parse_identifier_non_reserved()?,
2303 data_type: self.parse_data_type()?,
2304 })
2305 }
2306
2307 fn parse_function_arg(&mut self) -> ModalResult<OperateFunctionArg> {
2308 let mode = if self.parse_keyword(Keyword::IN) {
2309 Some(ArgMode::In)
2310 } else if self.parse_keyword(Keyword::OUT) {
2311 Some(ArgMode::Out)
2312 } else if self.parse_keyword(Keyword::INOUT) {
2313 Some(ArgMode::InOut)
2314 } else {
2315 None
2316 };
2317
2318 let mut name = None;
2320 let mut data_type = self.parse_data_type()?;
2321 if let DataType::Custom(n) = &data_type
2322 && !matches!(self.peek_token().token, Token::Comma | Token::RParen)
2323 {
2324 name = Some(n.0[0].clone());
2326 data_type = self.parse_data_type()?;
2327 }
2328
2329 let default_expr = if self.parse_keyword(Keyword::DEFAULT) || self.consume_token(&Token::Eq)
2330 {
2331 Some(self.parse_expr()?)
2332 } else {
2333 None
2334 };
2335 Ok(OperateFunctionArg {
2336 mode,
2337 name,
2338 data_type,
2339 default_expr,
2340 })
2341 }
2342
2343 fn parse_create_function_body(&mut self) -> ModalResult<CreateFunctionBody> {
2344 let mut body = CreateFunctionBody::default();
2345 loop {
2346 fn ensure_not_set<T>(field: &Option<T>, name: &str) -> ModalResult<()> {
2347 if field.is_some() {
2348 parser_err!("{name} specified more than once");
2349 }
2350 Ok(())
2351 }
2352 if self.parse_keyword(Keyword::AS) {
2353 ensure_not_set(&body.as_, "AS")?;
2354 body.as_ = Some(self.parse_function_definition()?);
2355 } else if self.parse_keyword(Keyword::LANGUAGE) {
2356 ensure_not_set(&body.language, "LANGUAGE")?;
2357 body.language = Some(self.parse_identifier()?);
2358 } else if self.parse_keyword(Keyword::RUNTIME) {
2359 ensure_not_set(&body.runtime, "RUNTIME")?;
2360 body.runtime = Some(self.parse_identifier()?);
2361 } else if self.parse_keyword(Keyword::IMMUTABLE) {
2362 ensure_not_set(&body.behavior, "IMMUTABLE | STABLE | VOLATILE")?;
2363 body.behavior = Some(FunctionBehavior::Immutable);
2364 } else if self.parse_keyword(Keyword::STABLE) {
2365 ensure_not_set(&body.behavior, "IMMUTABLE | STABLE | VOLATILE")?;
2366 body.behavior = Some(FunctionBehavior::Stable);
2367 } else if self.parse_keyword(Keyword::VOLATILE) {
2368 ensure_not_set(&body.behavior, "IMMUTABLE | STABLE | VOLATILE")?;
2369 body.behavior = Some(FunctionBehavior::Volatile);
2370 } else if self.parse_keyword(Keyword::RETURN) {
2371 ensure_not_set(&body.return_, "RETURN")?;
2372 body.return_ = Some(self.parse_expr()?);
2373 } else if self.parse_keyword(Keyword::USING) {
2374 ensure_not_set(&body.using, "USING")?;
2375 body.using = Some(self.parse_create_function_using()?);
2376 } else {
2377 return Ok(body);
2378 }
2379 }
2380 }
2381
2382 fn parse_create_function_using(&mut self) -> ModalResult<CreateFunctionUsing> {
2383 let keyword = self.expect_one_of_keywords(&[Keyword::LINK, Keyword::BASE64])?;
2384
2385 match keyword {
2386 Keyword::LINK => {
2387 let uri = self.parse_literal_string()?;
2388 Ok(CreateFunctionUsing::Link(uri))
2389 }
2390 Keyword::BASE64 => {
2391 let base64 = self.parse_literal_string()?;
2392 Ok(CreateFunctionUsing::Base64(base64))
2393 }
2394 _ => unreachable!("{}", keyword),
2395 }
2396 }
2397
2398 fn parse_create_user(&mut self) -> ModalResult<Statement> {
2406 Ok(Statement::CreateUser(CreateUserStatement::parse_to(self)?))
2407 }
2408
2409 fn parse_create_secret(&mut self) -> ModalResult<Statement> {
2410 Ok(Statement::CreateSecret {
2411 stmt: CreateSecretStatement::parse_to(self)?,
2412 })
2413 }
2414
2415 pub fn parse_with_properties(&mut self) -> ModalResult<Vec<SqlOption>> {
2416 Ok(self
2417 .parse_options_with_preceding_keyword(Keyword::WITH)?
2418 .to_vec())
2419 }
2420
2421 pub fn parse_discard(&mut self) -> ModalResult<Statement> {
2422 self.expect_keyword(Keyword::ALL)?;
2423 Ok(Statement::Discard(DiscardType::All))
2424 }
2425
2426 pub fn parse_drop(&mut self) -> ModalResult<Statement> {
2427 if self.parse_keyword(Keyword::FUNCTION) {
2428 return self.parse_drop_function();
2429 } else if self.parse_keyword(Keyword::AGGREGATE) {
2430 return self.parse_drop_aggregate();
2431 }
2432 Ok(Statement::Drop(DropStatement::parse_to(self)?))
2433 }
2434
2435 fn parse_drop_function(&mut self) -> ModalResult<Statement> {
2440 let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]);
2441 let func_desc = self.parse_comma_separated(Parser::parse_function_desc)?;
2442 let option = match self.parse_one_of_keywords(&[Keyword::CASCADE, Keyword::RESTRICT]) {
2443 Some(Keyword::CASCADE) => Some(ReferentialAction::Cascade),
2444 Some(Keyword::RESTRICT) => Some(ReferentialAction::Restrict),
2445 _ => None,
2446 };
2447 Ok(Statement::DropFunction {
2448 if_exists,
2449 func_desc,
2450 option,
2451 })
2452 }
2453
2454 fn parse_drop_aggregate(&mut self) -> ModalResult<Statement> {
2459 let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]);
2460 let func_desc = self.parse_comma_separated(Parser::parse_function_desc)?;
2461 let option = match self.parse_one_of_keywords(&[Keyword::CASCADE, Keyword::RESTRICT]) {
2462 Some(Keyword::CASCADE) => Some(ReferentialAction::Cascade),
2463 Some(Keyword::RESTRICT) => Some(ReferentialAction::Restrict),
2464 _ => None,
2465 };
2466 Ok(Statement::DropAggregate {
2467 if_exists,
2468 func_desc,
2469 option,
2470 })
2471 }
2472
2473 fn parse_function_desc(&mut self) -> ModalResult<FunctionDesc> {
2474 let name = self.parse_object_name()?;
2475
2476 let args = if self.consume_token(&Token::LParen) {
2477 if self.consume_token(&Token::RParen) {
2478 Some(vec![])
2479 } else {
2480 let args = self.parse_comma_separated(Parser::parse_function_arg)?;
2481 self.expect_token(&Token::RParen)?;
2482 Some(args)
2483 }
2484 } else {
2485 None
2486 };
2487
2488 Ok(FunctionDesc { name, args })
2489 }
2490
2491 pub fn parse_create_index(&mut self, unique: bool) -> ModalResult<Statement> {
2492 let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]);
2493 let index_name = self.parse_object_name()?;
2494 self.expect_keyword(Keyword::ON)?;
2495 let table_name = self.parse_object_name()?;
2496 let method = if self.parse_keyword(Keyword::USING) {
2497 let method = self.parse_identifier()?;
2498 Some(method)
2499 } else {
2500 None
2501 };
2502 self.expect_token(&Token::LParen)?;
2503 let columns = self.parse_comma_separated(Parser::parse_order_by_expr)?;
2504 self.expect_token(&Token::RParen)?;
2505 let mut include = vec![];
2506 if self.parse_keyword(Keyword::INCLUDE) {
2507 self.expect_token(&Token::LParen)?;
2508 include = self.parse_comma_separated(Parser::parse_identifier_non_reserved)?;
2509 self.expect_token(&Token::RParen)?;
2510 }
2511 let mut distributed_by = vec![];
2512 if self.parse_keywords(&[Keyword::DISTRIBUTED, Keyword::BY]) {
2513 self.expect_token(&Token::LParen)?;
2514 distributed_by = self.parse_comma_separated(Parser::parse_expr)?;
2515 self.expect_token(&Token::RParen)?;
2516 }
2517 let with_properties = WithProperties(self.parse_with_properties()?);
2518
2519 Ok(Statement::CreateIndex {
2520 name: index_name,
2521 table_name,
2522 method,
2523 columns,
2524 include,
2525 distributed_by,
2526 unique,
2527 if_not_exists,
2528 with_properties,
2529 })
2530 }
2531
2532 pub fn parse_with_version_columns(&mut self) -> ModalResult<Vec<Ident>> {
2533 if self.parse_keywords(&[Keyword::WITH, Keyword::VERSION, Keyword::COLUMN]) {
2534 self.expect_token(&Token::LParen)?;
2535 let columns =
2536 self.parse_comma_separated(|parser| parser.parse_identifier_non_reserved())?;
2537 self.expect_token(&Token::RParen)?;
2538 Ok(columns)
2539 } else {
2540 Ok(Vec::new())
2541 }
2542 }
2543
2544 pub fn parse_on_conflict(&mut self) -> ModalResult<Option<OnConflict>> {
2545 if self.parse_keywords(&[Keyword::ON, Keyword::CONFLICT]) {
2546 self.parse_handle_conflict_behavior()
2547 } else {
2548 Ok(None)
2549 }
2550 }
2551
2552 pub fn parse_create_table(
2553 &mut self,
2554 or_replace: bool,
2555 temporary: bool,
2556 ) -> ModalResult<Statement> {
2557 let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]);
2558 let table_name = self.parse_object_name()?;
2559 let (columns, constraints, source_watermarks, wildcard_idx) =
2561 self.parse_columns_with_watermark()?;
2562
2563 let append_only = if self.parse_keyword(Keyword::APPEND) {
2564 self.expect_keyword(Keyword::ONLY)?;
2565 true
2566 } else {
2567 false
2568 };
2569
2570 let on_conflict = self.parse_on_conflict()?;
2571
2572 let with_version_columns = self.parse_with_version_columns()?;
2573 let include_options = self.parse_include_options()?;
2574
2575 let with_options = self.parse_with_properties()?;
2577
2578 let option = with_options
2579 .iter()
2580 .find(|&opt| opt.name.real_value() == UPSTREAM_SOURCE_KEY);
2581 let connector = option.map(|opt| opt.value.to_string());
2582 let contain_webhook =
2583 connector.is_some() && connector.as_ref().unwrap().contains(WEBHOOK_CONNECTOR);
2584
2585 let format_encode = if let Some(connector) = connector
2587 && !contain_webhook
2588 {
2589 Some(self.parse_format_encode_with_connector(&connector, false)?)
2590 } else {
2591 None };
2593 let query = if self.parse_keyword(Keyword::AS) {
2595 if !source_watermarks.is_empty() {
2596 parser_err!("Watermarks can't be defined on table created by CREATE TABLE AS");
2597 }
2598 Some(Box::new(self.parse_query()?))
2599 } else {
2600 None
2601 };
2602
2603 let cdc_table_info = if self.parse_keyword(Keyword::FROM) {
2604 let source_name = self.parse_object_name()?;
2605 self.expect_keyword(Keyword::TABLE)?;
2606 let external_table_name = self.parse_literal_string()?;
2607 Some(CdcTableInfo {
2608 source_name,
2609 external_table_name,
2610 })
2611 } else {
2612 None
2613 };
2614
2615 let webhook_info = if self.parse_keyword(Keyword::VALIDATE) {
2616 if !contain_webhook {
2617 parser_err!("VALIDATE is only supported for tables created with webhook source");
2618 }
2619
2620 let wait_for_persistence = with_options
2621 .iter()
2622 .find(|&opt| opt.name.real_value() == WEBHOOK_WAIT_FOR_PERSISTENCE)
2623 .map(|opt| opt.value.to_string().eq_ignore_ascii_case("true"))
2624 .unwrap_or(true);
2625 let secret_ref = if self.parse_keyword(Keyword::SECRET) {
2626 let secret_ref = self.parse_secret_ref()?;
2627 if secret_ref.ref_as == SecretRefAsType::File {
2628 parser_err!("Secret for SECURE_COMPARE() does not support AS FILE");
2629 };
2630 Some(secret_ref)
2631 } else {
2632 None
2633 };
2634
2635 self.expect_keyword(Keyword::AS)?;
2636 let signature_expr = self.parse_function()?;
2637
2638 let is_batched = with_options
2639 .iter()
2640 .find(|&opt| opt.name.real_value() == WEBHOOK_IS_BATCHED)
2641 .map(|opt| opt.value.to_string().eq_ignore_ascii_case("true"))
2642 .unwrap_or(false);
2643
2644 Some(WebhookSourceInfo {
2645 secret_ref,
2646 signature_expr,
2647 wait_for_persistence,
2648 is_batched,
2649 })
2650 } else {
2651 None
2652 };
2653
2654 let engine = if self.parse_keyword(Keyword::ENGINE) {
2655 self.expect_token(&Token::Eq)?;
2656 let engine_name = self.parse_object_name()?;
2657 if "iceberg".eq_ignore_ascii_case(&engine_name.real_value()) {
2658 Engine::Iceberg
2659 } else if "hummock".eq_ignore_ascii_case(&engine_name.real_value()) {
2660 Engine::Hummock
2661 } else {
2662 parser_err!("Unsupported engine: {}", engine_name);
2663 }
2664 } else {
2665 Engine::Hummock
2666 };
2667
2668 Ok(Statement::CreateTable {
2669 name: table_name,
2670 temporary,
2671 columns,
2672 wildcard_idx,
2673 constraints,
2674 with_options,
2675 or_replace,
2676 if_not_exists,
2677 format_encode,
2678 source_watermarks,
2679 append_only,
2680 on_conflict,
2681 with_version_columns,
2682 query,
2683 cdc_table_info,
2684 include_column_options: include_options,
2685 webhook_info,
2686 engine,
2687 })
2688 }
2689
2690 pub fn parse_include_options(&mut self) -> ModalResult<IncludeOption> {
2691 let mut options = vec![];
2692 while self.parse_keyword(Keyword::INCLUDE) {
2693 let column_type = self.parse_identifier()?;
2694
2695 let mut column_inner_field = None;
2696 let mut header_inner_expect_type = None;
2697 if let Token::SingleQuotedString(inner_field) = self.peek_token().token {
2698 self.next_token();
2699 column_inner_field = Some(inner_field);
2700
2701 header_inner_expect_type =
2723 opt(parser_v2::data_type.verify(|dt| !matches!(dt, DataType::Custom(_))))
2724 .parse_next(self)?;
2725 }
2726
2727 let mut column_alias = None;
2728 if self.parse_keyword(Keyword::AS) {
2729 column_alias = Some(self.parse_identifier()?);
2730 }
2731
2732 options.push(IncludeOptionItem {
2733 column_type,
2734 inner_field: column_inner_field,
2735 column_alias,
2736 header_inner_expect_type,
2737 });
2738
2739 let _ = self.consume_token(&Token::Comma);
2741 }
2742 Ok(options)
2743 }
2744
2745 pub fn parse_columns_with_watermark(&mut self) -> ModalResult<ColumnsDefTuple> {
2746 let mut columns = vec![];
2747 let mut constraints = vec![];
2748 let mut watermarks = vec![];
2749 let mut wildcard_idx = None;
2750 if !self.consume_token(&Token::LParen) || self.consume_token(&Token::RParen) {
2751 return Ok((columns, constraints, watermarks, wildcard_idx));
2752 }
2753
2754 loop {
2755 if self.consume_token(&Token::Mul) {
2756 if wildcard_idx.is_none() {
2757 wildcard_idx = Some(columns.len());
2758 } else {
2759 parser_err!("At most 1 wildcard is allowed in source definetion");
2760 }
2761 } else if let Some(constraint) = self.parse_optional_table_constraint()? {
2762 constraints.push(constraint);
2763 } else if let Some(watermark) = self.parse_optional_watermark()? {
2764 watermarks.push(watermark);
2765 if watermarks.len() > 1 {
2766 parser_err!("Only 1 watermark is allowed to be defined on source.");
2768 }
2769 } else if let Token::Word(_) = self.peek_token().token {
2770 columns.push(self.parse_column_def()?);
2771 } else {
2772 return self.expected("column name or constraint definition");
2773 }
2774 let comma = self.consume_token(&Token::Comma);
2775 if self.consume_token(&Token::RParen) {
2776 break;
2778 } else if !comma {
2779 return self.expected("',' or ')' after column definition");
2780 }
2781 }
2782
2783 Ok((columns, constraints, watermarks, wildcard_idx))
2784 }
2785
2786 fn parse_column_def(&mut self) -> ModalResult<ColumnDef> {
2787 let name = self.parse_identifier_non_reserved()?;
2788 let data_type = if let Token::Word(_) = self.peek_token().token {
2789 Some(self.parse_data_type()?)
2790 } else {
2791 None
2792 };
2793
2794 let collation = if self.parse_keyword(Keyword::COLLATE) {
2795 Some(self.parse_object_name()?)
2796 } else {
2797 None
2798 };
2799 let mut options = vec![];
2800 loop {
2801 if self.parse_keyword(Keyword::CONSTRAINT) {
2802 let name = Some(self.parse_identifier_non_reserved()?);
2803 if let Some(option) = self.parse_optional_column_option()? {
2804 options.push(ColumnOptionDef { name, option });
2805 } else {
2806 return self.expected("constraint details after CONSTRAINT <name>");
2807 }
2808 } else if let Some(option) = self.parse_optional_column_option()? {
2809 options.push(ColumnOptionDef { name: None, option });
2810 } else {
2811 break;
2812 };
2813 }
2814 Ok(ColumnDef {
2815 name,
2816 data_type,
2817 collation,
2818 options,
2819 })
2820 }
2821
2822 pub fn parse_optional_column_option(&mut self) -> ModalResult<Option<ColumnOption>> {
2823 if self.parse_keywords(&[Keyword::NOT, Keyword::NULL]) {
2824 Ok(Some(ColumnOption::NotNull))
2825 } else if self.parse_keyword(Keyword::NULL) {
2826 Ok(Some(ColumnOption::Null))
2827 } else if self.parse_keyword(Keyword::DEFAULT) {
2828 if self.parse_keyword(Keyword::INTERNAL) {
2829 Ok(Some(ColumnOption::DefaultValueInternal {
2830 persisted: Default::default(),
2832 expr: None,
2833 }))
2834 } else {
2835 Ok(Some(ColumnOption::DefaultValue(self.parse_expr()?)))
2836 }
2837 } else if self.parse_keywords(&[Keyword::PRIMARY, Keyword::KEY]) {
2838 Ok(Some(ColumnOption::Unique { is_primary: true }))
2839 } else if self.parse_keyword(Keyword::UNIQUE) {
2840 Ok(Some(ColumnOption::Unique { is_primary: false }))
2841 } else if self.parse_keyword(Keyword::REFERENCES) {
2842 let foreign_table = self.parse_object_name()?;
2843 let referred_columns = self.parse_parenthesized_column_list(Optional)?;
2846 let mut on_delete = None;
2847 let mut on_update = None;
2848 loop {
2849 if on_delete.is_none() && self.parse_keywords(&[Keyword::ON, Keyword::DELETE]) {
2850 on_delete = Some(self.parse_referential_action()?);
2851 } else if on_update.is_none()
2852 && self.parse_keywords(&[Keyword::ON, Keyword::UPDATE])
2853 {
2854 on_update = Some(self.parse_referential_action()?);
2855 } else {
2856 break;
2857 }
2858 }
2859 Ok(Some(ColumnOption::ForeignKey {
2860 foreign_table,
2861 referred_columns,
2862 on_delete,
2863 on_update,
2864 }))
2865 } else if self.parse_keyword(Keyword::CHECK) {
2866 self.expect_token(&Token::LParen)?;
2867 let expr = self.parse_expr()?;
2868 self.expect_token(&Token::RParen)?;
2869 Ok(Some(ColumnOption::Check(expr)))
2870 } else if self.parse_keyword(Keyword::AS) {
2871 Ok(Some(ColumnOption::GeneratedColumns(self.parse_expr()?)))
2872 } else {
2873 Ok(None)
2874 }
2875 }
2876
2877 pub fn parse_handle_conflict_behavior(&mut self) -> ModalResult<Option<OnConflict>> {
2878 if self.parse_keyword(Keyword::OVERWRITE) {
2879 Ok(Some(OnConflict::UpdateFull))
2881 } else if self.parse_keyword(Keyword::IGNORE) {
2882 Ok(Some(OnConflict::Nothing))
2884 } else if self.parse_keywords(&[
2885 Keyword::DO,
2886 Keyword::UPDATE,
2887 Keyword::IF,
2888 Keyword::NOT,
2889 Keyword::NULL,
2890 ]) {
2891 Ok(Some(OnConflict::UpdateIfNotNull))
2892 } else if self.parse_keywords(&[Keyword::DO, Keyword::UPDATE, Keyword::FULL]) {
2893 Ok(Some(OnConflict::UpdateFull))
2894 } else if self.parse_keywords(&[Keyword::DO, Keyword::NOTHING]) {
2895 Ok(Some(OnConflict::Nothing))
2896 } else {
2897 Ok(None)
2898 }
2899 }
2900
2901 pub fn parse_referential_action(&mut self) -> ModalResult<ReferentialAction> {
2902 if self.parse_keyword(Keyword::RESTRICT) {
2903 Ok(ReferentialAction::Restrict)
2904 } else if self.parse_keyword(Keyword::CASCADE) {
2905 Ok(ReferentialAction::Cascade)
2906 } else if self.parse_keywords(&[Keyword::SET, Keyword::NULL]) {
2907 Ok(ReferentialAction::SetNull)
2908 } else if self.parse_keywords(&[Keyword::NO, Keyword::ACTION]) {
2909 Ok(ReferentialAction::NoAction)
2910 } else if self.parse_keywords(&[Keyword::SET, Keyword::DEFAULT]) {
2911 Ok(ReferentialAction::SetDefault)
2912 } else {
2913 self.expected("one of RESTRICT, CASCADE, SET NULL, NO ACTION or SET DEFAULT")
2914 }
2915 }
2916
2917 pub fn parse_optional_watermark(&mut self) -> ModalResult<Option<SourceWatermark>> {
2918 if self.parse_keyword(Keyword::WATERMARK) {
2919 self.expect_keyword(Keyword::FOR)?;
2920 let column = self.parse_identifier_non_reserved()?;
2921 self.expect_keyword(Keyword::AS)?;
2922 let expr = self.parse_expr()?;
2923 Ok(Some(SourceWatermark { column, expr }))
2924 } else {
2925 Ok(None)
2926 }
2927 }
2928
2929 pub fn parse_optional_table_constraint(&mut self) -> ModalResult<Option<TableConstraint>> {
2930 let name = if self.parse_keyword(Keyword::CONSTRAINT) {
2931 Some(self.parse_identifier_non_reserved()?)
2932 } else {
2933 None
2934 };
2935 let checkpoint = *self;
2936 let token = self.next_token();
2937 match token.token {
2938 Token::Word(w) if w.keyword == Keyword::PRIMARY || w.keyword == Keyword::UNIQUE => {
2939 let is_primary = w.keyword == Keyword::PRIMARY;
2940 if is_primary {
2941 self.expect_keyword(Keyword::KEY)?;
2942 }
2943 let columns = self.parse_parenthesized_column_list(Mandatory)?;
2944 Ok(Some(TableConstraint::Unique {
2945 name,
2946 columns,
2947 is_primary,
2948 }))
2949 }
2950 Token::Word(w) if w.keyword == Keyword::FOREIGN => {
2951 self.expect_keyword(Keyword::KEY)?;
2952 let columns = self.parse_parenthesized_column_list(Mandatory)?;
2953 self.expect_keyword(Keyword::REFERENCES)?;
2954 let foreign_table = self.parse_object_name()?;
2955 let referred_columns = self.parse_parenthesized_column_list(Mandatory)?;
2956 let mut on_delete = None;
2957 let mut on_update = None;
2958 loop {
2959 if on_delete.is_none() && self.parse_keywords(&[Keyword::ON, Keyword::DELETE]) {
2960 on_delete = Some(self.parse_referential_action()?);
2961 } else if on_update.is_none()
2962 && self.parse_keywords(&[Keyword::ON, Keyword::UPDATE])
2963 {
2964 on_update = Some(self.parse_referential_action()?);
2965 } else {
2966 break;
2967 }
2968 }
2969 Ok(Some(TableConstraint::ForeignKey {
2970 name,
2971 columns,
2972 foreign_table,
2973 referred_columns,
2974 on_delete,
2975 on_update,
2976 }))
2977 }
2978 Token::Word(w) if w.keyword == Keyword::CHECK => {
2979 self.expect_token(&Token::LParen)?;
2980 let expr = Box::new(self.parse_expr()?);
2981 self.expect_token(&Token::RParen)?;
2982 Ok(Some(TableConstraint::Check { name, expr }))
2983 }
2984 _ => {
2985 *self = checkpoint;
2986 if name.is_some() {
2987 self.expected("PRIMARY, UNIQUE, FOREIGN, or CHECK")
2988 } else {
2989 Ok(None)
2990 }
2991 }
2992 }
2993 }
2994
2995 pub fn parse_options_with_preceding_keyword(
2996 &mut self,
2997 keyword: Keyword,
2998 ) -> ModalResult<Vec<SqlOption>> {
2999 if self.parse_keyword(keyword) {
3000 self.expect_token(&Token::LParen)?;
3001 self.parse_options_inner()
3002 } else {
3003 Ok(vec![])
3004 }
3005 }
3006
3007 pub fn parse_options(&mut self) -> ModalResult<Vec<SqlOption>> {
3008 if self.peek_token() == Token::LParen {
3009 self.next_token();
3010 self.parse_options_inner()
3011 } else {
3012 Ok(vec![])
3013 }
3014 }
3015
3016 pub fn parse_options_inner(&mut self) -> ModalResult<Vec<SqlOption>> {
3018 let mut values = vec![];
3019 loop {
3020 values.push(Parser::parse_sql_option(self)?);
3021 let comma = self.consume_token(&Token::Comma);
3022 if self.consume_token(&Token::RParen) {
3023 break;
3025 } else if !comma {
3026 return self.expected("',' or ')' after option definition");
3027 }
3028 }
3029 Ok(values)
3030 }
3031
3032 pub fn parse_sql_option(&mut self) -> ModalResult<SqlOption> {
3033 const CONNECTION_REF_KEY: &str = "connection";
3034 const BACKFILL_ORDER: &str = "backfill_order";
3035
3036 let name = self.parse_object_name()?;
3037 self.expect_token(&Token::Eq)?;
3038 let value = {
3039 if name.real_value().eq_ignore_ascii_case(CONNECTION_REF_KEY) {
3040 let connection_name = self.parse_object_name()?;
3041 let connection_name = match connection_name.0.as_slice() {
3043 [ident] if ident.real_value() == CONNECTION_REF_KEY => {
3044 self.parse_object_name()?
3045 }
3046 _ => connection_name,
3047 };
3048 SqlOptionValue::ConnectionRef(ConnectionRefValue { connection_name })
3049 } else if name.real_value().eq_ignore_ascii_case(BACKFILL_ORDER) {
3050 let order = self.parse_backfill_order_strategy()?;
3051 SqlOptionValue::BackfillOrder(order)
3052 } else {
3053 self.parse_value_and_obj_ref::<false>()?
3054 }
3055 };
3056 Ok(SqlOption { name, value })
3057 }
3058
3059 pub fn parse_config_param(&mut self) -> ModalResult<ConfigParam> {
3062 let param = self.parse_identifier()?;
3063 if !self.consume_token(&Token::Eq) && !self.parse_keyword(Keyword::TO) {
3064 return self.expected("'=' or 'TO' after config parameter");
3065 }
3066 let value = self.parse_set_variable()?;
3067 Ok(ConfigParam { param, value })
3068 }
3069
3070 pub fn parse_since(&mut self) -> ModalResult<Since> {
3071 if self.parse_keyword(Keyword::SINCE) {
3072 let checkpoint = *self;
3073 let token = self.next_token();
3074 match token.token {
3075 Token::Word(w) => {
3076 let ident = w.to_ident()?;
3077 if ident.real_value() == "proctime" || ident.real_value() == "now" {
3079 self.expect_token(&Token::LParen)?;
3080 self.expect_token(&Token::RParen)?;
3081 Ok(Since::ProcessTime)
3082 } else if ident.real_value() == "begin" {
3083 self.expect_token(&Token::LParen)?;
3084 self.expect_token(&Token::RParen)?;
3085 Ok(Since::Begin)
3086 } else {
3087 parser_err!(
3088 "Expected proctime(), begin() or now(), found: {}",
3089 ident.real_value()
3090 )
3091 }
3092 }
3093 Token::Number(s) => {
3094 let num = s
3095 .parse::<u64>()
3096 .map_err(|e| StrError(format!("Could not parse '{}' as u64: {}", s, e)))?;
3097 Ok(Since::TimestampMsNum(num))
3098 }
3099 _ => self.expected_at(checkpoint, "proctime(), begin() , now(), Number"),
3100 }
3101 } else if self.parse_word("FULL") {
3102 Ok(Since::Full)
3103 } else {
3104 Ok(Since::ProcessTime)
3105 }
3106 }
3107
3108 pub fn parse_emit_mode(&mut self) -> ModalResult<Option<EmitMode>> {
3109 if self.parse_keyword(Keyword::EMIT) {
3110 match self.parse_one_of_keywords(&[Keyword::IMMEDIATELY, Keyword::ON]) {
3111 Some(Keyword::IMMEDIATELY) => Ok(Some(EmitMode::Immediately)),
3112 Some(Keyword::ON) => {
3113 self.expect_keywords(&[Keyword::WINDOW, Keyword::CLOSE])?;
3114 Ok(Some(EmitMode::OnWindowClose))
3115 }
3116 Some(_) => unreachable!(),
3117 None => self.expected("IMMEDIATELY or ON WINDOW CLOSE after EMIT"),
3118 }
3119 } else {
3120 Ok(None)
3121 }
3122 }
3123
3124 pub fn parse_alter(&mut self) -> ModalResult<Statement> {
3125 if self.parse_keyword(Keyword::DATABASE) {
3126 self.parse_alter_database()
3127 } else if self.parse_keyword(Keyword::SCHEMA) {
3128 self.parse_alter_schema()
3129 } else if self.parse_keyword(Keyword::TABLE) {
3130 self.parse_alter_table()
3131 } else if self.parse_keyword(Keyword::INDEX) {
3132 self.parse_alter_index()
3133 } else if self.parse_keyword(Keyword::VIEW) {
3134 self.parse_alter_view(false)
3135 } else if self.parse_keywords(&[Keyword::MATERIALIZED, Keyword::VIEW]) {
3136 self.parse_alter_view(true)
3137 } else if self.parse_keyword(Keyword::SINK) {
3138 self.parse_alter_sink()
3139 } else if self.parse_keyword(Keyword::SOURCE) {
3140 self.parse_alter_source()
3141 } else if self.parse_keyword(Keyword::FUNCTION) {
3142 self.parse_alter_function()
3143 } else if self.parse_keyword(Keyword::CONNECTION) {
3144 self.parse_alter_connection()
3145 } else if self.parse_keyword(Keyword::USER) {
3146 self.parse_alter_user()
3147 } else if self.parse_keyword(Keyword::SYSTEM) {
3148 self.parse_alter_system()
3149 } else if self.parse_keyword(Keyword::SUBSCRIPTION) {
3150 self.parse_alter_subscription()
3151 } else if self.parse_keyword(Keyword::SECRET) {
3152 self.parse_alter_secret()
3153 } else if self.parse_word("FRAGMENT") {
3154 self.parse_alter_fragment()
3155 } else if self.parse_keywords(&[Keyword::DEFAULT, Keyword::PRIVILEGES]) {
3156 self.parse_alter_default_privileges()
3157 } else {
3158 self.expected(
3159 "DATABASE, FRAGMENT, SCHEMA, TABLE, INDEX, MATERIALIZED, VIEW, SINK, SUBSCRIPTION, SOURCE, FUNCTION, USER, SECRET or SYSTEM after ALTER"
3160 )
3161 }
3162 }
3163
3164 pub fn parse_alter_database(&mut self) -> ModalResult<Statement> {
3165 let database_name = self.parse_object_name()?;
3166 let operation = if self.parse_keywords(&[Keyword::OWNER, Keyword::TO]) {
3167 let owner_name: Ident = self.parse_identifier()?;
3168 AlterDatabaseOperation::ChangeOwner {
3169 new_owner_name: owner_name,
3170 }
3171 } else if self.parse_keyword(Keyword::RENAME) {
3172 if self.parse_keyword(Keyword::TO) {
3173 let database_name = self.parse_object_name()?;
3174 AlterDatabaseOperation::RenameDatabase { database_name }
3175 } else {
3176 return self.expected("TO after RENAME");
3177 }
3178 } else if self.parse_keyword(Keyword::SET) {
3179 AlterDatabaseOperation::SetParam(self.parse_config_param()?)
3181 } else {
3182 return self.expected("RENAME, OWNER TO, OR SET after ALTER DATABASE");
3183 };
3184
3185 Ok(Statement::AlterDatabase {
3186 name: database_name,
3187 operation,
3188 })
3189 }
3190
3191 pub fn parse_alter_schema(&mut self) -> ModalResult<Statement> {
3192 let schema_name = self.parse_object_name()?;
3193 let operation = if self.parse_keywords(&[Keyword::OWNER, Keyword::TO]) {
3194 let owner_name: Ident = self.parse_identifier()?;
3195 AlterSchemaOperation::ChangeOwner {
3196 new_owner_name: owner_name,
3197 }
3198 } else if self.parse_keyword(Keyword::RENAME) {
3199 self.expect_keyword(Keyword::TO)?;
3200 let schema_name = self.parse_object_name()?;
3201 AlterSchemaOperation::RenameSchema { schema_name }
3202 } else if self.parse_keywords(&[Keyword::SWAP, Keyword::WITH]) {
3203 let target_schema = self.parse_object_name()?;
3204 AlterSchemaOperation::SwapRenameSchema { target_schema }
3205 } else {
3206 return self.expected("RENAME, OWNER TO, OR SWAP WITH after ALTER SCHEMA");
3207 };
3208
3209 Ok(Statement::AlterSchema {
3210 name: schema_name,
3211 operation,
3212 })
3213 }
3214
3215 pub fn parse_alter_user(&mut self) -> ModalResult<Statement> {
3216 Ok(Statement::AlterUser(AlterUserStatement::parse_to(self)?))
3217 }
3218
3219 pub fn parse_alter_table(&mut self) -> ModalResult<Statement> {
3220 let _ = self.parse_keyword(Keyword::ONLY);
3221 let table_name = self.parse_object_name()?;
3222 let operation = if self.parse_keyword(Keyword::ADD) {
3223 if let Some(constraint) = self.parse_optional_table_constraint()? {
3224 AlterTableOperation::AddConstraint(constraint)
3225 } else {
3226 let _ = self.parse_keyword(Keyword::COLUMN);
3227 let _if_not_exists =
3228 self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]);
3229 let column_def = self.parse_column_def()?;
3230 AlterTableOperation::AddColumn { column_def }
3231 }
3232 } else if self.parse_keywords(&[Keyword::DROP, Keyword::CONNECTOR]) {
3233 AlterTableOperation::DropConnector
3234 } else if self.parse_keyword(Keyword::RENAME) {
3235 if self.parse_keyword(Keyword::CONSTRAINT) {
3236 let old_name = self.parse_identifier_non_reserved()?;
3237 self.expect_keyword(Keyword::TO)?;
3238 let new_name = self.parse_identifier_non_reserved()?;
3239 AlterTableOperation::RenameConstraint { old_name, new_name }
3240 } else if self.parse_keyword(Keyword::TO) {
3241 let table_name = self.parse_object_name()?;
3242 AlterTableOperation::RenameTable { table_name }
3243 } else {
3244 let _ = self.parse_keyword(Keyword::COLUMN);
3245 let old_column_name = self.parse_identifier_non_reserved()?;
3246 self.expect_keyword(Keyword::TO)?;
3247 let new_column_name = self.parse_identifier_non_reserved()?;
3248 AlterTableOperation::RenameColumn {
3249 old_column_name,
3250 new_column_name,
3251 }
3252 }
3253 } else if self.parse_keywords(&[Keyword::OWNER, Keyword::TO]) {
3254 let owner_name: Ident = self.parse_identifier()?;
3255 AlterTableOperation::ChangeOwner {
3256 new_owner_name: owner_name,
3257 }
3258 } else if self.parse_keyword(Keyword::SET) {
3259 if self.parse_keyword(Keyword::SCHEMA) {
3260 let schema_name = self.parse_object_name()?;
3261 AlterTableOperation::SetSchema {
3262 new_schema_name: schema_name,
3263 }
3264 } else if self.parse_keyword(Keyword::PARALLELISM) {
3265 if self.expect_keyword(Keyword::TO).is_err()
3266 && self.expect_token(&Token::Eq).is_err()
3267 {
3268 return self.expected("TO or = after ALTER TABLE SET PARALLELISM");
3269 }
3270
3271 let value = self.parse_set_variable()?;
3272
3273 let deferred = self.parse_keyword(Keyword::DEFERRED);
3274
3275 AlterTableOperation::SetParallelism {
3276 parallelism: value,
3277 deferred,
3278 }
3279 } else if let Some(rate_limit) = self.parse_alter_source_rate_limit(true)? {
3280 AlterTableOperation::SetSourceRateLimit { rate_limit }
3281 } else if let Some(rate_limit) = self.parse_alter_backfill_rate_limit()? {
3282 AlterTableOperation::SetBackfillRateLimit { rate_limit }
3283 } else if let Some(rate_limit) = self.parse_alter_dml_rate_limit()? {
3284 AlterTableOperation::SetDmlRateLimit { rate_limit }
3285 } else {
3286 return self
3287 .expected("SCHEMA/PARALLELISM/SOURCE_RATE_LIMIT/DML_RATE_LIMIT after SET");
3288 }
3289 } else if self.parse_keyword(Keyword::DROP) {
3290 let _ = self.parse_keyword(Keyword::COLUMN);
3291 let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]);
3292 let column_name = self.parse_identifier_non_reserved()?;
3293 let cascade = self.parse_keyword(Keyword::CASCADE);
3294 AlterTableOperation::DropColumn {
3295 column_name,
3296 if_exists,
3297 cascade,
3298 }
3299 } else if self.parse_keyword(Keyword::ALTER) {
3300 let _ = self.parse_keyword(Keyword::COLUMN);
3301 let column_name = self.parse_identifier_non_reserved()?;
3302
3303 let op = if self.parse_keywords(&[Keyword::SET, Keyword::NOT, Keyword::NULL]) {
3304 AlterColumnOperation::SetNotNull {}
3305 } else if self.parse_keywords(&[Keyword::DROP, Keyword::NOT, Keyword::NULL]) {
3306 AlterColumnOperation::DropNotNull {}
3307 } else if self.parse_keywords(&[Keyword::SET, Keyword::DEFAULT]) {
3308 AlterColumnOperation::SetDefault {
3309 value: self.parse_expr()?,
3310 }
3311 } else if self.parse_keywords(&[Keyword::DROP, Keyword::DEFAULT]) {
3312 AlterColumnOperation::DropDefault {}
3313 } else if self.parse_keywords(&[Keyword::SET, Keyword::DATA, Keyword::TYPE])
3314 || (self.parse_keyword(Keyword::TYPE))
3315 {
3316 let data_type = self.parse_data_type()?;
3317 let using = if self.parse_keyword(Keyword::USING) {
3318 Some(self.parse_expr()?)
3319 } else {
3320 None
3321 };
3322 AlterColumnOperation::SetDataType { data_type, using }
3323 } else {
3324 return self
3325 .expected("SET/DROP NOT NULL, SET DEFAULT, SET DATA TYPE after ALTER COLUMN");
3326 };
3327 AlterTableOperation::AlterColumn { column_name, op }
3328 } else if self.parse_keywords(&[Keyword::REFRESH, Keyword::SCHEMA]) {
3329 AlterTableOperation::RefreshSchema
3330 } else if self.parse_keywords(&[Keyword::SWAP, Keyword::WITH]) {
3331 let target_table = self.parse_object_name()?;
3332 AlterTableOperation::SwapRenameTable { target_table }
3333 } else if self.parse_keyword(Keyword::CONNECTOR) {
3334 let with_options = self.parse_with_properties()?;
3335 AlterTableOperation::AlterConnectorProps {
3336 alter_props: with_options,
3337 }
3338 } else {
3339 return self.expected(
3340 "ADD or RENAME or OWNER TO or SET or DROP or SWAP or CONNECTOR after ALTER TABLE",
3341 );
3342 };
3343 Ok(Statement::AlterTable {
3344 name: table_name,
3345 operation,
3346 })
3347 }
3348
3349 pub fn parse_alter_backfill_rate_limit(&mut self) -> ModalResult<Option<i32>> {
3352 if !self.parse_word("BACKFILL_RATE_LIMIT") {
3353 return Ok(None);
3354 }
3355 if self.expect_keyword(Keyword::TO).is_err() && self.expect_token(&Token::Eq).is_err() {
3356 return self.expected("TO or = after ALTER TABLE SET BACKFILL_RATE_LIMIT");
3357 }
3358 let rate_limit = if self.parse_keyword(Keyword::DEFAULT) {
3359 -1
3360 } else {
3361 let s = self.parse_number_value()?;
3362 if let Ok(n) = s.parse::<i32>() {
3363 n
3364 } else {
3365 return self.expected("number or DEFAULT");
3366 }
3367 };
3368 Ok(Some(rate_limit))
3369 }
3370
3371 pub fn parse_alter_dml_rate_limit(&mut self) -> ModalResult<Option<i32>> {
3374 if !self.parse_word("DML_RATE_LIMIT") {
3375 return Ok(None);
3376 }
3377 if self.expect_keyword(Keyword::TO).is_err() && self.expect_token(&Token::Eq).is_err() {
3378 return self.expected("TO or = after ALTER TABLE SET DML_RATE_LIMIT");
3379 }
3380 let rate_limit = if self.parse_keyword(Keyword::DEFAULT) {
3381 -1
3382 } else {
3383 let s = self.parse_number_value()?;
3384 if let Ok(n) = s.parse::<i32>() {
3385 n
3386 } else {
3387 return self.expected("number or DEFAULT");
3388 }
3389 };
3390 Ok(Some(rate_limit))
3391 }
3392
3393 pub fn parse_alter_source_rate_limit(&mut self, is_table: bool) -> ModalResult<Option<i32>> {
3396 if !self.parse_word("SOURCE_RATE_LIMIT") {
3397 return Ok(None);
3398 }
3399 if self.expect_keyword(Keyword::TO).is_err() && self.expect_token(&Token::Eq).is_err() {
3400 let ddl = if is_table { "TABLE" } else { "SOURCE" };
3401 return self.expected(&format!("TO or = after ALTER {ddl} SET SOURCE_RATE_LIMIT"));
3402 }
3403 let rate_limit = if self.parse_keyword(Keyword::DEFAULT) {
3404 -1
3405 } else {
3406 let s = self.parse_number_value()?;
3407 if let Ok(n) = s.parse::<i32>() {
3408 n
3409 } else {
3410 return self.expected("number or DEFAULT");
3411 }
3412 };
3413 Ok(Some(rate_limit))
3414 }
3415
3416 pub fn parse_alter_index(&mut self) -> ModalResult<Statement> {
3417 let index_name = self.parse_object_name()?;
3418 let operation = if self.parse_keyword(Keyword::RENAME) {
3419 if self.parse_keyword(Keyword::TO) {
3420 let index_name = self.parse_object_name()?;
3421 AlterIndexOperation::RenameIndex { index_name }
3422 } else {
3423 return self.expected("TO after RENAME");
3424 }
3425 } else if self.parse_keyword(Keyword::SET) {
3426 if self.parse_keyword(Keyword::PARALLELISM) {
3427 if self.expect_keyword(Keyword::TO).is_err()
3428 && self.expect_token(&Token::Eq).is_err()
3429 {
3430 return self.expected("TO or = after ALTER TABLE SET PARALLELISM");
3431 }
3432
3433 let value = self.parse_set_variable()?;
3434
3435 let deferred = self.parse_keyword(Keyword::DEFERRED);
3436
3437 AlterIndexOperation::SetParallelism {
3438 parallelism: value,
3439 deferred,
3440 }
3441 } else {
3442 return self.expected("PARALLELISM after SET");
3443 }
3444 } else {
3445 return self.expected("RENAME after ALTER INDEX");
3446 };
3447
3448 Ok(Statement::AlterIndex {
3449 name: index_name,
3450 operation,
3451 })
3452 }
3453
3454 pub fn parse_alter_view(&mut self, materialized: bool) -> ModalResult<Statement> {
3455 let view_name = self.parse_object_name()?;
3456 let operation = if self.parse_keyword(Keyword::AS) {
3457 let query = Box::new(self.parse_query()?);
3458 AlterViewOperation::AsQuery { query }
3459 } else if self.parse_keyword(Keyword::RENAME) {
3460 if self.parse_keyword(Keyword::TO) {
3461 let view_name = self.parse_object_name()?;
3462 AlterViewOperation::RenameView { view_name }
3463 } else {
3464 return self.expected("TO after RENAME");
3465 }
3466 } else if self.parse_keywords(&[Keyword::OWNER, Keyword::TO]) {
3467 let owner_name: Ident = self.parse_identifier()?;
3468 AlterViewOperation::ChangeOwner {
3469 new_owner_name: owner_name,
3470 }
3471 } else if self.parse_keywords(&[Keyword::SWAP, Keyword::WITH]) {
3472 let target_view = self.parse_object_name()?;
3473 AlterViewOperation::SwapRenameView { target_view }
3474 } else if self.parse_keyword(Keyword::SET) {
3475 if self.parse_keyword(Keyword::SCHEMA) {
3476 let schema_name = self.parse_object_name()?;
3477 AlterViewOperation::SetSchema {
3478 new_schema_name: schema_name,
3479 }
3480 } else if self.parse_word("STREAMING_ENABLE_UNALIGNED_JOIN") {
3481 if self.expect_keyword(Keyword::TO).is_err()
3482 && self.expect_token(&Token::Eq).is_err()
3483 {
3484 return self
3485 .expected("TO or = after ALTER TABLE SET STREAMING_ENABLE_UNALIGNED_JOIN");
3486 }
3487 let value = self.parse_boolean()?;
3488 AlterViewOperation::SetStreamingEnableUnalignedJoin { enable: value }
3489 } else if self.parse_keyword(Keyword::PARALLELISM) && materialized {
3490 if self.expect_keyword(Keyword::TO).is_err()
3491 && self.expect_token(&Token::Eq).is_err()
3492 {
3493 return self.expected("TO or = after ALTER TABLE SET PARALLELISM");
3494 }
3495
3496 let value = self.parse_set_variable()?;
3497
3498 let deferred = self.parse_keyword(Keyword::DEFERRED);
3499
3500 AlterViewOperation::SetParallelism {
3501 parallelism: value,
3502 deferred,
3503 }
3504 } else if self.parse_keyword(Keyword::RESOURCE_GROUP) && materialized {
3505 if self.expect_keyword(Keyword::TO).is_err()
3506 && self.expect_token(&Token::Eq).is_err()
3507 {
3508 return self
3509 .expected("TO or = after ALTER MATERIALIZED VIEW SET RESOURCE_GROUP");
3510 }
3511 let value = self.parse_set_variable()?;
3512 let deferred = self.parse_keyword(Keyword::DEFERRED);
3513
3514 AlterViewOperation::SetResourceGroup {
3515 resource_group: Some(value),
3516 deferred,
3517 }
3518 } else if materialized
3519 && let Some(rate_limit) = self.parse_alter_backfill_rate_limit()?
3520 {
3521 AlterViewOperation::SetBackfillRateLimit { rate_limit }
3522 } else {
3523 return self.expected("SCHEMA/PARALLELISM/BACKFILL_RATE_LIMIT after SET");
3524 }
3525 } else if self.parse_keyword(Keyword::RESET) {
3526 if self.parse_keyword(Keyword::RESOURCE_GROUP) && materialized {
3527 let deferred = self.parse_keyword(Keyword::DEFERRED);
3528
3529 AlterViewOperation::SetResourceGroup {
3530 resource_group: None,
3531 deferred,
3532 }
3533 } else {
3534 return self.expected("RESOURCE_GROUP after RESET");
3535 }
3536 } else {
3537 return self.expected(&format!(
3538 "AS, RENAME, OWNER TO, SET, or SWAP after ALTER {}VIEW",
3539 if materialized { "MATERIALIZED " } else { "" }
3540 ));
3541 };
3542
3543 Ok(Statement::AlterView {
3544 materialized,
3545 name: view_name,
3546 operation,
3547 })
3548 }
3549
3550 pub fn parse_alter_sink_rate_limit(&mut self) -> ModalResult<Option<i32>> {
3553 if !self.parse_word("SINK_RATE_LIMIT") {
3554 return Ok(None);
3555 }
3556 if self.expect_keyword(Keyword::TO).is_err() && self.expect_token(&Token::Eq).is_err() {
3557 return self.expected("TO or = after ALTER SINK SET SINK_RATE_LIMIT");
3558 }
3559 let rate_limit = if self.parse_keyword(Keyword::DEFAULT) {
3560 -1
3561 } else {
3562 let s = self.parse_number_value()?;
3563 if let Ok(n) = s.parse::<i32>() {
3564 n
3565 } else {
3566 return self.expected("number or DEFAULT");
3567 }
3568 };
3569 Ok(Some(rate_limit))
3570 }
3571
3572 pub fn parse_alter_sink(&mut self) -> ModalResult<Statement> {
3573 let sink_name = self.parse_object_name()?;
3574 let operation = if self.parse_keyword(Keyword::RENAME) {
3575 if self.parse_keyword(Keyword::TO) {
3576 let sink_name = self.parse_object_name()?;
3577 AlterSinkOperation::RenameSink { sink_name }
3578 } else {
3579 return self.expected("TO after RENAME");
3580 }
3581 } else if self.parse_keywords(&[Keyword::OWNER, Keyword::TO]) {
3582 let owner_name: Ident = self.parse_identifier()?;
3583 AlterSinkOperation::ChangeOwner {
3584 new_owner_name: owner_name,
3585 }
3586 } else if self.parse_keyword(Keyword::SET) {
3587 if self.parse_keyword(Keyword::SCHEMA) {
3588 let schema_name = self.parse_object_name()?;
3589 AlterSinkOperation::SetSchema {
3590 new_schema_name: schema_name,
3591 }
3592 } else if self.parse_word("STREAMING_ENABLE_UNALIGNED_JOIN") {
3593 self.expect_keyword(Keyword::TO)?;
3594 let value = self.parse_boolean()?;
3595 AlterSinkOperation::SetStreamingEnableUnalignedJoin { enable: value }
3596 } else if self.parse_keyword(Keyword::PARALLELISM) {
3597 if self.expect_keyword(Keyword::TO).is_err()
3598 && self.expect_token(&Token::Eq).is_err()
3599 {
3600 return self.expected("TO or = after ALTER TABLE SET PARALLELISM");
3601 }
3602
3603 let value = self.parse_set_variable()?;
3604 let deferred = self.parse_keyword(Keyword::DEFERRED);
3605
3606 AlterSinkOperation::SetParallelism {
3607 parallelism: value,
3608 deferred,
3609 }
3610 } else if let Some(rate_limit) = self.parse_alter_sink_rate_limit()? {
3611 AlterSinkOperation::SetSinkRateLimit { rate_limit }
3612 } else {
3613 return self.expected("SCHEMA/PARALLELISM after SET");
3614 }
3615 } else if self.parse_keywords(&[Keyword::SWAP, Keyword::WITH]) {
3616 let target_sink = self.parse_object_name()?;
3617 AlterSinkOperation::SwapRenameSink { target_sink }
3618 } else if self.parse_keyword(Keyword::CONNECTOR) {
3619 let changed_props = self.parse_with_properties()?;
3620 AlterSinkOperation::AlterConnectorProps {
3621 alter_props: changed_props,
3622 }
3623 } else {
3624 return self.expected("RENAME or OWNER TO or SET or CONNECTOR WITH after ALTER SINK");
3625 };
3626
3627 Ok(Statement::AlterSink {
3628 name: sink_name,
3629 operation,
3630 })
3631 }
3632
3633 pub fn parse_alter_subscription(&mut self) -> ModalResult<Statement> {
3634 let subscription_name = self.parse_object_name()?;
3635 let operation = if self.parse_keyword(Keyword::RENAME) {
3636 if self.parse_keyword(Keyword::TO) {
3637 let subscription_name = self.parse_object_name()?;
3638 AlterSubscriptionOperation::RenameSubscription { subscription_name }
3639 } else {
3640 return self.expected("TO after RENAME");
3641 }
3642 } else if self.parse_keywords(&[Keyword::OWNER, Keyword::TO]) {
3643 let owner_name: Ident = self.parse_identifier()?;
3644 AlterSubscriptionOperation::ChangeOwner {
3645 new_owner_name: owner_name,
3646 }
3647 } else if self.parse_keyword(Keyword::SET) {
3648 if self.parse_keyword(Keyword::SCHEMA) {
3649 let schema_name = self.parse_object_name()?;
3650 AlterSubscriptionOperation::SetSchema {
3651 new_schema_name: schema_name,
3652 }
3653 } else {
3654 return self.expected("SCHEMA after SET");
3655 }
3656 } else if self.parse_keywords(&[Keyword::SWAP, Keyword::WITH]) {
3657 let target_subscription = self.parse_object_name()?;
3658 AlterSubscriptionOperation::SwapRenameSubscription {
3659 target_subscription,
3660 }
3661 } else {
3662 return self.expected("RENAME or OWNER TO or SET or SWAP after ALTER SUBSCRIPTION");
3663 };
3664
3665 Ok(Statement::AlterSubscription {
3666 name: subscription_name,
3667 operation,
3668 })
3669 }
3670
3671 pub fn parse_alter_source(&mut self) -> ModalResult<Statement> {
3672 let source_name = self.parse_object_name()?;
3673 let operation = if self.parse_keyword(Keyword::RENAME) {
3674 if self.parse_keyword(Keyword::TO) {
3675 let source_name = self.parse_object_name()?;
3676 AlterSourceOperation::RenameSource { source_name }
3677 } else {
3678 return self.expected("TO after RENAME");
3679 }
3680 } else if self.parse_keyword(Keyword::ADD) {
3681 let _ = self.parse_keyword(Keyword::COLUMN);
3682 let _if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]);
3683 let column_def = self.parse_column_def()?;
3684 AlterSourceOperation::AddColumn { column_def }
3685 } else if self.parse_keywords(&[Keyword::OWNER, Keyword::TO]) {
3686 let owner_name: Ident = self.parse_identifier()?;
3687 AlterSourceOperation::ChangeOwner {
3688 new_owner_name: owner_name,
3689 }
3690 } else if self.parse_keyword(Keyword::SET) {
3691 if self.parse_keyword(Keyword::SCHEMA) {
3692 let schema_name = self.parse_object_name()?;
3693 AlterSourceOperation::SetSchema {
3694 new_schema_name: schema_name,
3695 }
3696 } else if let Some(rate_limit) = self.parse_alter_source_rate_limit(false)? {
3697 AlterSourceOperation::SetSourceRateLimit { rate_limit }
3698 } else if self.parse_keyword(Keyword::PARALLELISM) {
3699 if self.expect_keyword(Keyword::TO).is_err()
3700 && self.expect_token(&Token::Eq).is_err()
3701 {
3702 return self.expected("TO or = after ALTER SOURCE SET PARALLELISM");
3703 }
3704
3705 let value = self.parse_set_variable()?;
3706 let deferred = self.parse_keyword(Keyword::DEFERRED);
3707
3708 AlterSourceOperation::SetParallelism {
3709 parallelism: value,
3710 deferred,
3711 }
3712 } else {
3713 return self.expected("SCHEMA, SOURCE_RATE_LIMIT or PARALLELISM after SET");
3714 }
3715 } else if self.peek_nth_any_of_keywords(0, &[Keyword::FORMAT]) {
3716 let format_encode = self.parse_schema()?.unwrap();
3717 if format_encode.key_encode.is_some() {
3718 parser_err!("key encode clause is not supported in source schema");
3719 }
3720 AlterSourceOperation::FormatEncode { format_encode }
3721 } else if self.parse_keywords(&[Keyword::REFRESH, Keyword::SCHEMA]) {
3722 AlterSourceOperation::RefreshSchema
3723 } else if self.parse_keywords(&[Keyword::SWAP, Keyword::WITH]) {
3724 let target_source = self.parse_object_name()?;
3725 AlterSourceOperation::SwapRenameSource { target_source }
3726 } else if self.parse_keyword(Keyword::CONNECTOR) {
3727 let with_options = self.parse_with_properties()?;
3728 AlterSourceOperation::AlterConnectorProps {
3729 alter_props: with_options,
3730 }
3731 } else {
3732 return self
3733 .expected("RENAME, ADD COLUMN, OWNER TO, CONNECTOR or SET after ALTER SOURCE");
3734 };
3735
3736 Ok(Statement::AlterSource {
3737 name: source_name,
3738 operation,
3739 })
3740 }
3741
3742 pub fn parse_alter_function(&mut self) -> ModalResult<Statement> {
3743 let FunctionDesc { name, args } = self.parse_function_desc()?;
3744
3745 let operation = if self.parse_keyword(Keyword::SET) {
3746 if self.parse_keyword(Keyword::SCHEMA) {
3747 let schema_name = self.parse_object_name()?;
3748 AlterFunctionOperation::SetSchema {
3749 new_schema_name: schema_name,
3750 }
3751 } else {
3752 return self.expected("SCHEMA after SET");
3753 }
3754 } else {
3755 return self.expected("SET after ALTER FUNCTION");
3756 };
3757
3758 Ok(Statement::AlterFunction {
3759 name,
3760 args,
3761 operation,
3762 })
3763 }
3764
3765 pub fn parse_alter_connection(&mut self) -> ModalResult<Statement> {
3766 let connection_name = self.parse_object_name()?;
3767 let operation = if self.parse_keyword(Keyword::SET) {
3768 if self.parse_keyword(Keyword::SCHEMA) {
3769 let schema_name = self.parse_object_name()?;
3770 AlterConnectionOperation::SetSchema {
3771 new_schema_name: schema_name,
3772 }
3773 } else {
3774 return self.expected("SCHEMA after SET");
3775 }
3776 } else if self.parse_keywords(&[Keyword::OWNER, Keyword::TO]) {
3777 let owner_name: Ident = self.parse_identifier()?;
3778 AlterConnectionOperation::ChangeOwner {
3779 new_owner_name: owner_name,
3780 }
3781 } else {
3782 return self.expected("SET, or OWNER TO after ALTER CONNECTION");
3783 };
3784
3785 Ok(Statement::AlterConnection {
3786 name: connection_name,
3787 operation,
3788 })
3789 }
3790
3791 pub fn parse_alter_system(&mut self) -> ModalResult<Statement> {
3792 self.expect_keyword(Keyword::SET)?;
3793 let param = self.parse_identifier()?;
3794 if self.expect_keyword(Keyword::TO).is_err() && self.expect_token(&Token::Eq).is_err() {
3795 return self.expected("TO or = after ALTER SYSTEM SET");
3796 }
3797 let value = self.parse_set_variable()?;
3798 Ok(Statement::AlterSystem { param, value })
3799 }
3800
3801 pub fn parse_alter_secret(&mut self) -> ModalResult<Statement> {
3802 let secret_name = self.parse_object_name()?;
3803 let with_options = self.parse_with_properties()?;
3804 self.expect_keyword(Keyword::AS)?;
3805 let new_credential = self.ensure_parse_value()?;
3806 let operation = AlterSecretOperation::ChangeCredential { new_credential };
3807 Ok(Statement::AlterSecret {
3808 name: secret_name,
3809 with_options,
3810 operation,
3811 })
3812 }
3813
3814 pub fn parse_alter_fragment(&mut self) -> ModalResult<Statement> {
3815 let fragment_id = self.parse_literal_u32()?;
3816 if !self.parse_keyword(Keyword::SET) {
3817 return self.expected("SET after ALTER FRAGMENT");
3818 }
3819 let rate_limit = self.parse_alter_fragment_rate_limit()?;
3820 let operation = AlterFragmentOperation::AlterBackfillRateLimit { rate_limit };
3821 Ok(Statement::AlterFragment {
3822 fragment_id,
3823 operation,
3824 })
3825 }
3826
3827 fn parse_alter_fragment_rate_limit(&mut self) -> ModalResult<i32> {
3828 if !self.parse_word("RATE_LIMIT") {
3829 return self.expected("expected RATE_LIMIT after SET");
3830 }
3831 if self.expect_keyword(Keyword::TO).is_err() && self.expect_token(&Token::Eq).is_err() {
3832 return self.expected("TO or = after RATE_LIMIT");
3833 }
3834 let rate_limit = if self.parse_keyword(Keyword::DEFAULT) {
3835 -1
3836 } else {
3837 let s = self.parse_number_value()?;
3838 if let Ok(n) = s.parse::<i32>() {
3839 n
3840 } else {
3841 return self.expected("number or DEFAULT");
3842 }
3843 };
3844 Ok(rate_limit)
3845 }
3846
3847 pub fn parse_copy(&mut self) -> ModalResult<Statement> {
3849 let entity = if self.consume_token(&Token::LParen) {
3850 let query = self.parse_query()?;
3851 self.expect_token(&Token::RParen)?;
3852 CopyEntity::Query(query.into())
3853 } else {
3854 let table_name = self.parse_object_name()?;
3855 let columns = self.parse_parenthesized_column_list(Optional)?;
3856 CopyEntity::Table {
3857 table_name,
3858 columns,
3859 }
3860 };
3861
3862 let target = if self.parse_keywords(&[Keyword::FROM, Keyword::STDIN]) {
3863 self.expect_token(&Token::SemiColon)?;
3864 let values = self.parse_tsv();
3865 CopyTarget::Stdin { values }
3866 } else if self.parse_keywords(&[Keyword::TO, Keyword::STDOUT]) {
3867 CopyTarget::Stdout
3868 } else {
3869 return self.expected("FROM STDIN or TO STDOUT");
3870 };
3871
3872 Ok(Statement::Copy { entity, target })
3873 }
3874
3875 fn parse_tsv(&mut self) -> Vec<Option<String>> {
3878 self.parse_tab_value()
3879 }
3880
3881 fn parse_tab_value(&mut self) -> Vec<Option<String>> {
3882 let mut values = vec![];
3883 let mut content = String::from("");
3884 while let Some(t) = self.next_token_no_skip() {
3885 match t.token {
3886 Token::Whitespace(Whitespace::Tab) => {
3887 values.push(Some(content.clone()));
3888 content.clear();
3889 }
3890 Token::Whitespace(Whitespace::Newline) => {
3891 values.push(Some(content.clone()));
3892 content.clear();
3893 }
3894 Token::Backslash => {
3895 if self.consume_token(&Token::Period) {
3896 return values;
3897 }
3898 if let Token::Word(w) = self.next_token().token
3899 && w.value == "N"
3900 {
3901 values.push(None);
3902 }
3903 }
3904 _ => {
3905 content.push_str(&t.to_string());
3906 }
3907 }
3908 }
3909 values
3910 }
3911
3912 pub fn ensure_parse_value(&mut self) -> ModalResult<Value> {
3913 match self.parse_value_and_obj_ref::<true>()? {
3914 SqlOptionValue::Value(value) => Ok(value),
3915 SqlOptionValue::SecretRef(_)
3916 | SqlOptionValue::ConnectionRef(_)
3917 | SqlOptionValue::BackfillOrder(_) => unreachable!(),
3918 }
3919 }
3920
3921 pub fn parse_value_and_obj_ref<const FORBID_OBJ_REF: bool>(
3923 &mut self,
3924 ) -> ModalResult<SqlOptionValue> {
3925 let checkpoint = *self;
3926 let token = self.next_token();
3927 match token.token {
3928 Token::Word(w) => match w.keyword {
3929 Keyword::TRUE => Ok(Value::Boolean(true).into()),
3930 Keyword::FALSE => Ok(Value::Boolean(false).into()),
3931 Keyword::NULL => Ok(Value::Null.into()),
3932 Keyword::NoKeyword if w.quote_style.is_some() => match w.quote_style {
3933 Some('"') => Ok(Value::DoubleQuotedString(w.value).into()),
3934 Some('\'') => Ok(Value::SingleQuotedString(w.value).into()),
3935 _ => self.expected_at(checkpoint, "A value")?,
3936 },
3937 Keyword::SECRET => {
3938 if FORBID_OBJ_REF {
3939 return self.expected_at(
3940 checkpoint,
3941 "a concrete value rather than a secret reference",
3942 );
3943 }
3944 let secret = self.parse_secret_ref()?;
3945 Ok(SqlOptionValue::SecretRef(secret))
3946 }
3947 _ => self.expected_at(checkpoint, "a concrete value"),
3948 },
3949 Token::Number(ref n) => Ok(Value::Number(n.clone()).into()),
3950 Token::SingleQuotedString(ref s) => Ok(Value::SingleQuotedString(s.clone()).into()),
3951 Token::DollarQuotedString(ref s) => Ok(Value::DollarQuotedString(s.clone()).into()),
3952 Token::CstyleEscapesString(ref s) => Ok(Value::CstyleEscapedString(s.clone()).into()),
3953 Token::NationalStringLiteral(ref s) => {
3954 Ok(Value::NationalStringLiteral(s.clone()).into())
3955 }
3956 Token::HexStringLiteral(ref s) => Ok(Value::HexStringLiteral(s.clone()).into()),
3957 _ => self.expected_at(checkpoint, "a value"),
3958 }
3959 }
3960
3961 fn parse_secret_ref(&mut self) -> ModalResult<SecretRefValue> {
3962 let secret_name = self.parse_object_name()?;
3963 let ref_as = if self.parse_keywords(&[Keyword::AS, Keyword::FILE]) {
3964 SecretRefAsType::File
3965 } else {
3966 SecretRefAsType::Text
3967 };
3968 Ok(SecretRefValue {
3969 secret_name,
3970 ref_as,
3971 })
3972 }
3973
3974 fn parse_set_variable(&mut self) -> ModalResult<SetVariableValue> {
3975 alt((
3976 Keyword::DEFAULT.value(SetVariableValue::Default),
3977 separated(
3978 1..,
3979 alt((
3980 Self::ensure_parse_value.map(SetVariableValueSingle::Literal),
3981 |parser: &mut Self| {
3982 let checkpoint = *parser;
3983 let ident = parser.parse_identifier()?;
3984 if ident.value == "default" {
3985 *parser = checkpoint;
3986 return parser.expected("parameter list value").map_err(|e| e.cut());
3987 }
3988 Ok(SetVariableValueSingle::Ident(ident))
3989 },
3990 fail.expect("parameter value"),
3991 )),
3992 Token::Comma,
3993 )
3994 .map(|list: Vec<SetVariableValueSingle>| {
3995 if list.len() == 1 {
3996 SetVariableValue::Single(list[0].clone())
3997 } else {
3998 SetVariableValue::List(list)
3999 }
4000 }),
4001 ))
4002 .parse_next(self)
4003 }
4004
4005 fn parse_backfill_order_strategy(&mut self) -> ModalResult<BackfillOrderStrategy> {
4006 alt((
4007 Keyword::DEFAULT.value(BackfillOrderStrategy::Default),
4008 Keyword::NONE.value(BackfillOrderStrategy::None),
4009 Keyword::AUTO.value(BackfillOrderStrategy::Auto),
4010 Self::parse_fixed_backfill_order.map(BackfillOrderStrategy::Fixed),
4011 fail.expect("backfill order strategy"),
4012 ))
4013 .parse_next(self)
4014 }
4015
4016 fn parse_fixed_backfill_order(&mut self) -> ModalResult<Vec<(ObjectName, ObjectName)>> {
4017 self.expect_word("FIXED")?;
4018 self.expect_token(&Token::LParen)?;
4019 let edges = separated(
4020 0..,
4021 separated_pair(
4022 Self::parse_object_name,
4023 Token::Op("->".to_owned()),
4024 Self::parse_object_name,
4025 ),
4026 Token::Comma,
4027 )
4028 .parse_next(self)?;
4029 self.expect_token(&Token::RParen)?;
4030 Ok(edges)
4031 }
4032
4033 pub fn parse_number_value(&mut self) -> ModalResult<String> {
4034 let checkpoint = *self;
4035 match self.ensure_parse_value()? {
4036 Value::Number(v) => Ok(v),
4037 _ => self.expected_at(checkpoint, "literal number"),
4038 }
4039 }
4040
4041 pub fn parse_literal_u32(&mut self) -> ModalResult<u32> {
4042 literal_u32(self)
4043 }
4044
4045 pub fn parse_literal_u64(&mut self) -> ModalResult<u64> {
4046 literal_u64(self)
4047 }
4048
4049 pub fn parse_function_definition(&mut self) -> ModalResult<FunctionDefinition> {
4050 alt((
4051 single_quoted_string.map(FunctionDefinition::SingleQuotedDef),
4052 dollar_quoted_string.map(FunctionDefinition::DoubleDollarDef),
4053 Self::parse_identifier.map(|i| FunctionDefinition::Identifier(i.value)),
4054 fail.expect("function definition"),
4055 ))
4056 .parse_next(self)
4057 }
4058
4059 pub fn parse_literal_string(&mut self) -> ModalResult<String> {
4061 let checkpoint = *self;
4062 let token = self.next_token();
4063 match token.token {
4064 Token::SingleQuotedString(s) => Ok(s),
4065 _ => self.expected_at(checkpoint, "literal string"),
4066 }
4067 }
4068
4069 pub fn parse_data_type(&mut self) -> ModalResult<DataType> {
4071 parser_v2::data_type(self)
4072 }
4073
4074 pub fn parse_optional_alias(
4078 &mut self,
4079 reserved_kwds: &[Keyword],
4080 ) -> ModalResult<Option<Ident>> {
4081 let after_as = self.parse_keyword(Keyword::AS);
4082 let checkpoint = *self;
4083 let token = self.next_token();
4084 match token.token {
4085 Token::Word(w) if after_as || (!reserved_kwds.contains(&w.keyword)) => {
4091 Ok(Some(w.to_ident()?))
4092 }
4093 _ => {
4094 *self = checkpoint;
4095 if after_as {
4096 return self.expected("an identifier after AS");
4097 }
4098 Ok(None) }
4100 }
4101 }
4102
4103 pub fn parse_optional_table_alias(
4108 &mut self,
4109 reserved_kwds: &[Keyword],
4110 ) -> ModalResult<Option<TableAlias>> {
4111 match self.parse_optional_alias(reserved_kwds)? {
4112 Some(name) => {
4113 let columns = self.parse_parenthesized_column_list(Optional)?;
4114 Ok(Some(TableAlias { name, columns }))
4115 }
4116 None => Ok(None),
4117 }
4118 }
4119
4120 pub fn parse_as_of(&mut self) -> ModalResult<AsOf> {
4122 Keyword::FOR.parse_next(self)?;
4123 alt((
4124 preceded(
4125 (Keyword::SYSTEM_TIME, Keyword::AS, Keyword::OF),
4126 cut_err(
4127 alt((
4128 preceded(
4129 (
4130 Self::parse_identifier.verify(|ident| ident.real_value() == "now"),
4131 cut_err(Token::LParen),
4132 cut_err(Token::RParen),
4133 Token::Minus,
4134 ),
4135 Self::parse_literal_interval.try_map(|e| match e {
4136 Expr::Value(v) => match v {
4137 Value::Interval {
4138 value,
4139 leading_field,
4140 ..
4141 } => {
4142 let Some(leading_field) = leading_field else {
4143 return Err(StrError("expect duration unit".into()));
4144 };
4145 Ok(AsOf::ProcessTimeWithInterval((value, leading_field)))
4146 }
4147 _ => Err(StrError("expect Value::Interval".into())),
4148 },
4149 _ => Err(StrError("expect Expr::Value".into())),
4150 }),
4151 ),
4152 (
4153 Self::parse_identifier.verify(|ident| ident.real_value() == "now"),
4154 cut_err(Token::LParen),
4155 cut_err(Token::RParen),
4156 )
4157 .value(AsOf::ProcessTimeWithInterval((
4158 "0".to_owned(),
4159 DateTimeField::Second,
4160 ))),
4161 (
4162 Self::parse_identifier.verify(|ident| ident.real_value() == "proctime"),
4163 cut_err(Token::LParen),
4164 cut_err(Token::RParen),
4165 )
4166 .value(AsOf::ProcessTime),
4167 literal_i64.map(AsOf::TimestampNum),
4168 single_quoted_string.map(AsOf::TimestampString),
4169 ))
4170 .expect("proctime(), now(), number or string"),
4171 ),
4172 ),
4173 preceded(
4174 (Keyword::SYSTEM_VERSION, Keyword::AS, Keyword::OF),
4175 cut_err(
4176 alt((
4177 literal_i64.map(AsOf::VersionNum),
4178 single_quoted_string.map(AsOf::VersionString),
4179 ))
4180 .expect("number or string"),
4181 ),
4182 ),
4183 ))
4184 .parse_next(self)
4185 }
4186
4187 pub fn parse_object_name(&mut self) -> ModalResult<ObjectName> {
4190 let mut idents = vec![];
4191 loop {
4192 idents.push(self.parse_identifier()?);
4193 if !self.consume_token(&Token::Period) {
4194 break;
4195 }
4196 }
4197 Ok(ObjectName(idents))
4198 }
4199
4200 pub fn parse_identifiers_non_keywords(&mut self) -> ModalResult<Vec<Ident>> {
4202 let mut idents = vec![];
4203 loop {
4204 match self.peek_token().token {
4205 Token::Word(w) => {
4206 if w.keyword != Keyword::NoKeyword {
4207 break;
4208 }
4209
4210 idents.push(w.to_ident()?);
4211 }
4212 Token::EOF | Token::Eq => break,
4213 _ => {}
4214 }
4215
4216 self.next_token();
4217 }
4218
4219 Ok(idents)
4220 }
4221
4222 pub fn parse_identifiers(&mut self) -> ModalResult<Vec<Ident>> {
4224 let mut idents = vec![];
4225 loop {
4226 let token = self.next_token();
4227 match token.token {
4228 Token::Word(w) => {
4229 idents.push(w.to_ident()?);
4230 }
4231 Token::EOF => break,
4232 _ => {}
4233 }
4234 }
4235
4236 Ok(idents)
4237 }
4238
4239 pub fn parse_identifier(&mut self) -> ModalResult<Ident> {
4241 let checkpoint = *self;
4242 let token = self.next_token();
4243 match token.token {
4244 Token::Word(w) => Ok(w.to_ident()?),
4245 _ => self.expected_at(checkpoint, "identifier"),
4246 }
4247 }
4248
4249 pub fn parse_identifier_non_reserved(&mut self) -> ModalResult<Ident> {
4251 let checkpoint = *self;
4252 let token = self.next_token();
4253 match token.token {
4254 Token::Word(w) => {
4255 match keywords::RESERVED_FOR_COLUMN_OR_TABLE_NAME.contains(&w.keyword) {
4256 true => parser_err!("syntax error at or near {w}"),
4257 false => Ok(w.to_ident()?),
4258 }
4259 }
4260 _ => self.expected_at(checkpoint, "identifier"),
4261 }
4262 }
4263
4264 pub fn parse_parenthesized_column_list(
4266 &mut self,
4267 optional: IsOptional,
4268 ) -> ModalResult<Vec<Ident>> {
4269 if self.consume_token(&Token::LParen) {
4270 let cols = self.parse_comma_separated(Parser::parse_identifier_non_reserved)?;
4271 self.expect_token(&Token::RParen)?;
4272 Ok(cols)
4273 } else if optional == Optional {
4274 Ok(vec![])
4275 } else {
4276 self.expected("a list of columns in parentheses")
4277 }
4278 }
4279
4280 pub fn parse_returning(&mut self, optional: IsOptional) -> ModalResult<Vec<SelectItem>> {
4281 if self.parse_keyword(Keyword::RETURNING) {
4282 let cols = self.parse_comma_separated(Parser::parse_select_item)?;
4283 Ok(cols)
4284 } else if optional == Optional {
4285 Ok(vec![])
4286 } else {
4287 self.expected("a list of columns or * after returning")
4288 }
4289 }
4290
4291 pub fn parse_row_expr(&mut self) -> ModalResult<Expr> {
4292 Ok(Expr::Row(self.parse_token_wrapped_exprs(
4293 &Token::LParen,
4294 &Token::RParen,
4295 )?))
4296 }
4297
4298 pub fn parse_token_wrapped_exprs(
4300 &mut self,
4301 left: &Token,
4302 right: &Token,
4303 ) -> ModalResult<Vec<Expr>> {
4304 if self.consume_token(left) {
4305 let exprs = if self.consume_token(right) {
4306 vec![]
4307 } else {
4308 let exprs = self.parse_comma_separated(Parser::parse_expr)?;
4309 self.expect_token(right)?;
4310 exprs
4311 };
4312 Ok(exprs)
4313 } else {
4314 self.expected(left.to_string().as_str())
4315 }
4316 }
4317
4318 pub fn parse_optional_precision(&mut self) -> ModalResult<Option<u64>> {
4319 if self.consume_token(&Token::LParen) {
4320 let n = self.parse_literal_u64()?;
4321 self.expect_token(&Token::RParen)?;
4322 Ok(Some(n))
4323 } else {
4324 Ok(None)
4325 }
4326 }
4327
4328 pub fn parse_optional_precision_scale(&mut self) -> ModalResult<(Option<u64>, Option<u64>)> {
4329 if self.consume_token(&Token::LParen) {
4330 let n = self.parse_literal_u64()?;
4331 let scale = if self.consume_token(&Token::Comma) {
4332 Some(self.parse_literal_u64()?)
4333 } else {
4334 None
4335 };
4336 self.expect_token(&Token::RParen)?;
4337 Ok((Some(n), scale))
4338 } else {
4339 Ok((None, None))
4340 }
4341 }
4342
4343 pub fn parse_delete(&mut self) -> ModalResult<Statement> {
4344 self.expect_keyword(Keyword::FROM)?;
4345 let table_name = self.parse_object_name()?;
4346 let selection = if self.parse_keyword(Keyword::WHERE) {
4347 Some(self.parse_expr()?)
4348 } else {
4349 None
4350 };
4351 let returning = self.parse_returning(Optional)?;
4352
4353 Ok(Statement::Delete {
4354 table_name,
4355 selection,
4356 returning,
4357 })
4358 }
4359
4360 pub fn parse_boolean(&mut self) -> ModalResult<bool> {
4361 if let Some(keyword) = self.parse_one_of_keywords(&[Keyword::TRUE, Keyword::FALSE]) {
4362 match keyword {
4363 Keyword::TRUE => Ok(true),
4364 Keyword::FALSE => Ok(false),
4365 _ => unreachable!(),
4366 }
4367 } else {
4368 self.expected("TRUE or FALSE")
4369 }
4370 }
4371
4372 pub fn parse_optional_boolean(&mut self, default: bool) -> bool {
4373 self.parse_boolean().unwrap_or(default)
4374 }
4375
4376 fn parse_explain_options(&mut self) -> ModalResult<(ExplainOptions, Option<u64>)> {
4377 let mut options = ExplainOptions::default();
4378 let mut analyze_duration = None;
4379
4380 const BACKFILL: &str = "backfill";
4381 const VERBOSE: &str = "verbose";
4382 const TRACE: &str = "trace";
4383 const TYPE: &str = "type";
4384 const LOGICAL: &str = "logical";
4385 const PHYSICAL: &str = "physical";
4386 const DISTSQL: &str = "distsql";
4387 const FORMAT: &str = "format";
4388 const DURATION_SECS: &str = "duration_secs";
4389
4390 let explain_options_identifiers = [
4391 BACKFILL,
4392 VERBOSE,
4393 TRACE,
4394 TYPE,
4395 LOGICAL,
4396 PHYSICAL,
4397 DISTSQL,
4398 FORMAT,
4399 DURATION_SECS,
4400 ];
4401
4402 let parse_explain_option = |parser: &mut Parser<'_>| -> ModalResult<()> {
4403 match parser.parse_identifier()?.real_value().as_str() {
4404 VERBOSE => options.verbose = parser.parse_optional_boolean(true),
4405 TRACE => options.trace = parser.parse_optional_boolean(true),
4406 BACKFILL => options.backfill = parser.parse_optional_boolean(true),
4407 TYPE => {
4408 let explain_type = parser.parse_identifier()?.real_value();
4409 match explain_type.as_str() {
4410 LOGICAL => options.explain_type = ExplainType::Logical,
4411 PHYSICAL => options.explain_type = ExplainType::Physical,
4412 DISTSQL => options.explain_type = ExplainType::DistSql,
4413 unexpected => {
4414 parser_err!("unexpected explain type: [{unexpected}]")
4415 }
4416 }
4417 }
4418 LOGICAL => options.explain_type = ExplainType::Logical,
4419 PHYSICAL => options.explain_type = ExplainType::Physical,
4420 DISTSQL => options.explain_type = ExplainType::DistSql,
4421 FORMAT => {
4422 options.explain_format = {
4423 let format = parser.parse_identifier()?.real_value();
4424 match format.as_str() {
4425 "text" => ExplainFormat::Text,
4426 "json" => ExplainFormat::Json,
4427 "xml" => ExplainFormat::Xml,
4428 "yaml" => ExplainFormat::Yaml,
4429 "dot" => ExplainFormat::Dot,
4430 unexpected => {
4431 parser_err!("unexpected explain format [{unexpected}]")
4432 }
4433 }
4434 }
4435 }
4436 DURATION_SECS => {
4437 analyze_duration = Some(parser.parse_literal_u64()?);
4438 }
4439 unexpected => {
4440 parser_err!("unexpected explain options: [{unexpected}]")
4441 }
4442 };
4443 Ok(())
4444 };
4445
4446 if self.peek_token() == Token::LParen
4449 && let Token::Word(word) = self.peek_nth_token(1).token
4450 && let Ok(ident) = word.to_ident()
4451 && explain_options_identifiers.contains(&ident.real_value().as_str())
4452 {
4453 assert!(self.consume_token(&Token::LParen));
4454 self.parse_comma_separated(parse_explain_option)?;
4455 self.expect_token(&Token::RParen)?;
4456 }
4457
4458 Ok((options, analyze_duration))
4459 }
4460
4461 pub fn parse_explain(&mut self) -> ModalResult<Statement> {
4462 let analyze = self.parse_keyword(Keyword::ANALYZE);
4463 let (options, analyze_duration) = self.parse_explain_options()?;
4464
4465 if analyze {
4466 fn parse_analyze_target(parser: &mut Parser<'_>) -> ModalResult<Option<AnalyzeTarget>> {
4467 if parser.parse_keyword(Keyword::TABLE) {
4468 let table_name = parser.parse_object_name()?;
4469 Ok(Some(AnalyzeTarget::Table(table_name)))
4470 } else if parser.parse_keyword(Keyword::INDEX) {
4471 let index_name = parser.parse_object_name()?;
4472 Ok(Some(AnalyzeTarget::Index(index_name)))
4473 } else if parser.parse_keywords(&[Keyword::MATERIALIZED, Keyword::VIEW]) {
4474 let view_name = parser.parse_object_name()?;
4475 Ok(Some(AnalyzeTarget::MaterializedView(view_name)))
4476 } else if parser.parse_keyword(Keyword::INDEX) {
4477 let index_name = parser.parse_object_name()?;
4478 Ok(Some(AnalyzeTarget::Index(index_name)))
4479 } else if parser.parse_keyword(Keyword::SINK) {
4480 let sink_name = parser.parse_object_name()?;
4481 Ok(Some(AnalyzeTarget::Sink(sink_name)))
4482 } else if parser.parse_word("ID") {
4483 let job_id = parser.parse_literal_u32()?;
4484 Ok(Some(AnalyzeTarget::Id(job_id)))
4485 } else {
4486 Ok(None)
4487 }
4488 }
4489 if let Some(target) = parse_analyze_target(self)? {
4490 let statement = Statement::ExplainAnalyzeStreamJob {
4491 target,
4492 duration_secs: analyze_duration,
4493 };
4494 return Ok(statement);
4495 }
4496 }
4497
4498 let statement = match self.parse_statement() {
4499 Ok(statement) => statement,
4500 error @ Err(_) => {
4501 return if analyze {
4502 self.expected_at(
4503 *self,
4504 "SINK, TABLE, MATERIALIZED VIEW, INDEX or a statement after ANALYZE",
4505 )
4506 } else {
4507 error
4508 };
4509 }
4510 };
4511 Ok(Statement::Explain {
4512 analyze,
4513 statement: Box::new(statement),
4514 options,
4515 })
4516 }
4517
4518 pub fn parse_describe(&mut self) -> ModalResult<Statement> {
4519 let kind = match self.parse_one_of_keywords(&[Keyword::FRAGMENT, Keyword::FRAGMENTS]) {
4520 Some(Keyword::FRAGMENT) => {
4521 let fragment_id = self.parse_literal_u32()?;
4522 return Ok(Statement::DescribeFragment { fragment_id });
4523 }
4524 Some(Keyword::FRAGMENTS) => DescribeKind::Fragments,
4525 None => DescribeKind::Plain,
4526 Some(_) => unreachable!(),
4527 };
4528 let name = self.parse_object_name()?;
4529 Ok(Statement::Describe { name, kind })
4530 }
4531
4532 pub fn parse_query(&mut self) -> ModalResult<Query> {
4537 let with = if self.parse_keyword(Keyword::WITH) {
4538 Some(With {
4539 recursive: self.parse_keyword(Keyword::RECURSIVE),
4540 cte_tables: self.parse_comma_separated(Parser::parse_cte)?,
4541 })
4542 } else {
4543 None
4544 };
4545
4546 let body = self.parse_query_body(0)?;
4547
4548 let order_by = if self.parse_keywords(&[Keyword::ORDER, Keyword::BY]) {
4549 self.parse_comma_separated(Parser::parse_order_by_expr)?
4550 } else {
4551 vec![]
4552 };
4553
4554 let mut limit = None;
4555 let mut offset = None;
4556 for _x in 0..2 {
4557 if limit.is_none() && self.parse_keyword(Keyword::LIMIT) {
4558 limit = self.parse_limit()?
4559 }
4560
4561 if offset.is_none() && self.parse_keyword(Keyword::OFFSET) {
4562 offset = Some(self.parse_offset()?)
4563 }
4564 }
4565
4566 let fetch = if self.parse_keyword(Keyword::FETCH) {
4567 if limit.is_some() {
4568 parser_err!("Cannot specify both LIMIT and FETCH");
4569 }
4570 let fetch = self.parse_fetch()?;
4571 if fetch.with_ties && order_by.is_empty() {
4572 parser_err!("WITH TIES cannot be specified without ORDER BY clause");
4573 }
4574 Some(fetch)
4575 } else {
4576 None
4577 };
4578
4579 Ok(Query {
4580 with,
4581 body,
4582 order_by,
4583 limit,
4584 offset,
4585 fetch,
4586 })
4587 }
4588
4589 fn parse_cte(&mut self) -> ModalResult<Cte> {
4591 let name = self.parse_identifier_non_reserved()?;
4592 let cte = if self.parse_keyword(Keyword::AS) {
4593 let cte_inner = self.parse_cte_inner()?;
4594 let alias = TableAlias {
4595 name,
4596 columns: vec![],
4597 };
4598 Cte { alias, cte_inner }
4599 } else {
4600 let columns = self.parse_parenthesized_column_list(Optional)?;
4601 self.expect_keyword(Keyword::AS)?;
4602 let cte_inner = self.parse_cte_inner()?;
4603 let alias = TableAlias { name, columns };
4604 Cte { alias, cte_inner }
4605 };
4606 Ok(cte)
4607 }
4608
4609 fn parse_cte_inner(&mut self) -> ModalResult<CteInner> {
4610 match self.expect_token(&Token::LParen) {
4611 Ok(()) => {
4612 let query = self.parse_query()?;
4613 self.expect_token(&Token::RParen)?;
4614 Ok(CteInner::Query(Box::new(query)))
4615 }
4616 _ => {
4617 let changelog = self.parse_identifier_non_reserved()?;
4618 if changelog.to_string().to_lowercase() != "changelog" {
4619 parser_err!("Expected 'changelog' but found '{}'", changelog);
4620 }
4621 self.expect_keyword(Keyword::FROM)?;
4622 Ok(CteInner::ChangeLog(self.parse_object_name()?))
4623 }
4624 }
4625 }
4626
4627 fn parse_query_body(&mut self, precedence: u8) -> ModalResult<SetExpr> {
4636 let mut expr = if self.parse_keyword(Keyword::SELECT) {
4639 SetExpr::Select(Box::new(self.parse_select()?))
4640 } else if self.consume_token(&Token::LParen) {
4641 let subquery = self.parse_query()?;
4643 self.expect_token(&Token::RParen)?;
4644 SetExpr::Query(Box::new(subquery))
4645 } else if self.parse_keyword(Keyword::VALUES) {
4646 SetExpr::Values(self.parse_values()?)
4647 } else {
4648 return self.expected("SELECT, VALUES, or a subquery in the query body");
4649 };
4650
4651 loop {
4652 let op = self.parse_set_operator(&self.peek_token().token);
4654 let next_precedence = match op {
4655 Some(SetOperator::Union) | Some(SetOperator::Except) => 10,
4657 Some(SetOperator::Intersect) => 20,
4659 None => break,
4661 };
4662 if precedence >= next_precedence {
4663 break;
4664 }
4665 self.next_token(); let all = self.parse_keyword(Keyword::ALL);
4668 let corresponding = self.parse_corresponding()?;
4669
4670 expr = SetExpr::SetOperation {
4671 left: Box::new(expr),
4672 op: op.unwrap(),
4673 corresponding,
4674 all,
4675 right: Box::new(self.parse_query_body(next_precedence)?),
4676 };
4677 }
4678
4679 Ok(expr)
4680 }
4681
4682 fn parse_set_operator(&mut self, token: &Token) -> Option<SetOperator> {
4683 match token {
4684 Token::Word(w) if w.keyword == Keyword::UNION => Some(SetOperator::Union),
4685 Token::Word(w) if w.keyword == Keyword::EXCEPT => Some(SetOperator::Except),
4686 Token::Word(w) if w.keyword == Keyword::INTERSECT => Some(SetOperator::Intersect),
4687 _ => None,
4688 }
4689 }
4690
4691 fn parse_corresponding(&mut self) -> ModalResult<Corresponding> {
4692 let corresponding = if self.parse_keyword(Keyword::CORRESPONDING) {
4693 let column_list = if self.parse_keyword(Keyword::BY) {
4694 Some(self.parse_parenthesized_column_list(IsOptional::Mandatory)?)
4695 } else {
4696 None
4697 };
4698 Corresponding::with_column_list(column_list)
4699 } else {
4700 Corresponding::none()
4701 };
4702 Ok(corresponding)
4703 }
4704
4705 pub fn parse_select(&mut self) -> ModalResult<Select> {
4708 let distinct = self.parse_all_or_distinct_on()?;
4709
4710 let projection = self.parse_comma_separated(Parser::parse_select_item)?;
4711
4712 let from = if self.parse_keyword(Keyword::FROM) {
4718 self.parse_comma_separated(Parser::parse_table_and_joins)?
4719 } else {
4720 vec![]
4721 };
4722 let mut lateral_views = vec![];
4723 loop {
4724 if self.parse_keywords(&[Keyword::LATERAL, Keyword::VIEW]) {
4725 let outer = self.parse_keyword(Keyword::OUTER);
4726 let lateral_view = self.parse_expr()?;
4727 let lateral_view_name = self.parse_object_name()?;
4728 let lateral_col_alias = self
4729 .parse_comma_separated(|parser| {
4730 parser.parse_optional_alias(&[
4731 Keyword::WHERE,
4732 Keyword::GROUP,
4733 Keyword::CLUSTER,
4734 Keyword::HAVING,
4735 Keyword::LATERAL,
4736 ]) })?
4738 .into_iter()
4739 .flatten()
4740 .collect();
4741
4742 lateral_views.push(LateralView {
4743 lateral_view,
4744 lateral_view_name,
4745 lateral_col_alias,
4746 outer,
4747 });
4748 } else {
4749 break;
4750 }
4751 }
4752
4753 let selection = if self.parse_keyword(Keyword::WHERE) {
4754 Some(self.parse_expr()?)
4755 } else {
4756 None
4757 };
4758
4759 let group_by = if self.parse_keywords(&[Keyword::GROUP, Keyword::BY]) {
4760 self.parse_comma_separated(Parser::parse_group_by_expr)?
4761 } else {
4762 vec![]
4763 };
4764
4765 let having = if self.parse_keyword(Keyword::HAVING) {
4766 Some(self.parse_expr()?)
4767 } else {
4768 None
4769 };
4770
4771 let window = if self.parse_keyword(Keyword::WINDOW) {
4772 self.parse_comma_separated(Parser::parse_named_window)?
4773 } else {
4774 vec![]
4775 };
4776
4777 Ok(Select {
4778 distinct,
4779 projection,
4780 from,
4781 lateral_views,
4782 selection,
4783 group_by,
4784 having,
4785 window,
4786 })
4787 }
4788
4789 pub fn parse_set(&mut self) -> ModalResult<Statement> {
4790 let modifier = self.parse_one_of_keywords(&[Keyword::SESSION, Keyword::LOCAL]);
4791 if self.parse_keywords(&[Keyword::TIME, Keyword::ZONE]) {
4792 let value = alt((
4793 Keyword::DEFAULT.value(SetTimeZoneValue::Default),
4794 Keyword::LOCAL.value(SetTimeZoneValue::Local),
4795 preceded(
4796 Keyword::INTERVAL,
4797 cut_err(Self::parse_literal_interval.try_map(|e| match e {
4798 Expr::Value(v) => match v {
4801 Value::Interval { value, .. } => {
4802 if value != "+00:00" {
4803 return Err(StrError("only support \"+00:00\" ".into()));
4804 }
4805 Ok(SetTimeZoneValue::Ident(Ident::with_quote_unchecked(
4806 '\'',
4807 "UTC".to_owned(),
4808 )))
4809 }
4810 _ => Err(StrError("expect Value::Interval".into())),
4811 },
4812 _ => Err(StrError("expect Expr::Value".into())),
4813 })),
4814 ),
4815 Self::parse_identifier.map(SetTimeZoneValue::Ident),
4816 Self::ensure_parse_value.map(SetTimeZoneValue::Literal),
4817 ))
4818 .expect("variable")
4819 .parse_next(self)?;
4820
4821 Ok(Statement::SetTimeZone {
4822 local: modifier == Some(Keyword::LOCAL),
4823 value,
4824 })
4825 } else if self.parse_keyword(Keyword::CHARACTERISTICS) && modifier == Some(Keyword::SESSION)
4826 {
4827 self.expect_keywords(&[Keyword::AS, Keyword::TRANSACTION])?;
4828 Ok(Statement::SetTransaction {
4829 modes: self.parse_transaction_modes()?,
4830 snapshot: None,
4831 session: true,
4832 })
4833 } else if self.parse_keyword(Keyword::TRANSACTION) && modifier.is_none() {
4834 if self.parse_keyword(Keyword::SNAPSHOT) {
4835 let snapshot_id = self.ensure_parse_value()?;
4836 return Ok(Statement::SetTransaction {
4837 modes: vec![],
4838 snapshot: Some(snapshot_id),
4839 session: false,
4840 });
4841 }
4842 Ok(Statement::SetTransaction {
4843 modes: self.parse_transaction_modes()?,
4844 snapshot: None,
4845 session: false,
4846 })
4847 } else {
4848 let config_param = self.parse_config_param()?;
4849 Ok(Statement::SetVariable {
4850 local: modifier == Some(Keyword::LOCAL),
4851 variable: config_param.param,
4852 value: config_param.value,
4853 })
4854 }
4855 }
4856
4857 pub fn parse_show(&mut self) -> ModalResult<Statement> {
4861 let checkpoint = *self;
4862 if let Token::Word(w) = self.next_token().token {
4863 match w.keyword {
4864 Keyword::TABLES => {
4865 return Ok(Statement::ShowObjects {
4866 object: ShowObject::Table {
4867 schema: self.parse_from_and_identifier()?,
4868 },
4869 filter: self.parse_show_statement_filter()?,
4870 });
4871 }
4872 Keyword::INTERNAL => {
4873 self.expect_keyword(Keyword::TABLES)?;
4874 return Ok(Statement::ShowObjects {
4875 object: ShowObject::InternalTable {
4876 schema: self.parse_from_and_identifier()?,
4877 },
4878 filter: self.parse_show_statement_filter()?,
4879 });
4880 }
4881 Keyword::SOURCES => {
4882 return Ok(Statement::ShowObjects {
4883 object: ShowObject::Source {
4884 schema: self.parse_from_and_identifier()?,
4885 },
4886 filter: self.parse_show_statement_filter()?,
4887 });
4888 }
4889 Keyword::SINKS => {
4890 return Ok(Statement::ShowObjects {
4891 object: ShowObject::Sink {
4892 schema: self.parse_from_and_identifier()?,
4893 },
4894 filter: self.parse_show_statement_filter()?,
4895 });
4896 }
4897 Keyword::SUBSCRIPTIONS => {
4898 return Ok(Statement::ShowObjects {
4899 object: ShowObject::Subscription {
4900 schema: self.parse_from_and_identifier()?,
4901 },
4902 filter: self.parse_show_statement_filter()?,
4903 });
4904 }
4905 Keyword::DATABASES => {
4906 return Ok(Statement::ShowObjects {
4907 object: ShowObject::Database,
4908 filter: self.parse_show_statement_filter()?,
4909 });
4910 }
4911 Keyword::SCHEMAS => {
4912 return Ok(Statement::ShowObjects {
4913 object: ShowObject::Schema,
4914 filter: self.parse_show_statement_filter()?,
4915 });
4916 }
4917 Keyword::VIEWS => {
4918 return Ok(Statement::ShowObjects {
4919 object: ShowObject::View {
4920 schema: self.parse_from_and_identifier()?,
4921 },
4922 filter: self.parse_show_statement_filter()?,
4923 });
4924 }
4925 Keyword::MATERIALIZED => {
4926 if self.parse_keyword(Keyword::VIEWS) {
4927 return Ok(Statement::ShowObjects {
4928 object: ShowObject::MaterializedView {
4929 schema: self.parse_from_and_identifier()?,
4930 },
4931 filter: self.parse_show_statement_filter()?,
4932 });
4933 } else {
4934 return self.expected("VIEWS after MATERIALIZED");
4935 }
4936 }
4937 Keyword::COLUMNS => {
4938 if self.parse_keyword(Keyword::FROM) {
4939 return Ok(Statement::ShowObjects {
4940 object: ShowObject::Columns {
4941 table: self.parse_object_name()?,
4942 },
4943 filter: self.parse_show_statement_filter()?,
4944 });
4945 } else {
4946 return self.expected("from after columns");
4947 }
4948 }
4949 Keyword::SECRETS => {
4950 return Ok(Statement::ShowObjects {
4951 object: ShowObject::Secret {
4952 schema: self.parse_from_and_identifier()?,
4953 },
4954 filter: self.parse_show_statement_filter()?,
4955 });
4956 }
4957 Keyword::CONNECTIONS => {
4958 return Ok(Statement::ShowObjects {
4959 object: ShowObject::Connection {
4960 schema: self.parse_from_and_identifier()?,
4961 },
4962 filter: self.parse_show_statement_filter()?,
4963 });
4964 }
4965 Keyword::FUNCTIONS => {
4966 return Ok(Statement::ShowObjects {
4967 object: ShowObject::Function {
4968 schema: self.parse_from_and_identifier()?,
4969 },
4970 filter: self.parse_show_statement_filter()?,
4971 });
4972 }
4973 Keyword::INDEXES => {
4974 if self.parse_keyword(Keyword::FROM) {
4975 return Ok(Statement::ShowObjects {
4976 object: ShowObject::Indexes {
4977 table: self.parse_object_name()?,
4978 },
4979 filter: self.parse_show_statement_filter()?,
4980 });
4981 } else {
4982 return self.expected("from after indexes");
4983 }
4984 }
4985 Keyword::CLUSTER => {
4986 return Ok(Statement::ShowObjects {
4987 object: ShowObject::Cluster,
4988 filter: self.parse_show_statement_filter()?,
4989 });
4990 }
4991 Keyword::JOBS => {
4992 return Ok(Statement::ShowObjects {
4993 object: ShowObject::Jobs,
4994 filter: self.parse_show_statement_filter()?,
4995 });
4996 }
4997 Keyword::PROCESSLIST => {
4998 return Ok(Statement::ShowObjects {
4999 object: ShowObject::ProcessList,
5000 filter: self.parse_show_statement_filter()?,
5001 });
5002 }
5003 Keyword::TRANSACTION => {
5004 self.expect_keywords(&[Keyword::ISOLATION, Keyword::LEVEL])?;
5005 return Ok(Statement::ShowTransactionIsolationLevel);
5006 }
5007 Keyword::CURSORS => {
5008 return Ok(Statement::ShowObjects {
5009 object: ShowObject::Cursor,
5010 filter: None,
5011 });
5012 }
5013 Keyword::SUBSCRIPTION => {
5014 self.expect_keyword(Keyword::CURSORS)?;
5015 return Ok(Statement::ShowObjects {
5016 object: ShowObject::SubscriptionCursor,
5017 filter: None,
5018 });
5019 }
5020 _ => {}
5021 }
5022 }
5023 *self = checkpoint;
5024 Ok(Statement::ShowVariable {
5025 variable: self.parse_identifiers()?,
5026 })
5027 }
5028
5029 pub fn parse_cancel_job(&mut self) -> ModalResult<Statement> {
5030 match self.peek_token().token {
5032 Token::Word(w) if Keyword::JOBS == w.keyword || Keyword::JOB == w.keyword => {
5033 self.next_token();
5034 }
5035 _ => return self.expected("JOBS or JOB after CANCEL"),
5036 }
5037
5038 let mut job_ids = vec![];
5039 loop {
5040 job_ids.push(self.parse_literal_u32()?);
5041 if !self.consume_token(&Token::Comma) {
5042 break;
5043 }
5044 }
5045 Ok(Statement::CancelJobs(JobIdents(job_ids)))
5046 }
5047
5048 pub fn parse_kill_process(&mut self) -> ModalResult<Statement> {
5049 let worker_process_id = self.parse_literal_string()?;
5050 Ok(Statement::Kill(worker_process_id))
5051 }
5052
5053 pub fn parse_from_and_identifier(&mut self) -> ModalResult<Option<Ident>> {
5056 if self.parse_keyword(Keyword::FROM) {
5057 Ok(Some(self.parse_identifier_non_reserved()?))
5058 } else {
5059 Ok(None)
5060 }
5061 }
5062
5063 pub fn parse_show_create(&mut self) -> ModalResult<Statement> {
5065 if let Token::Word(w) = self.next_token().token {
5066 let show_type = match w.keyword {
5067 Keyword::TABLE => ShowCreateType::Table,
5068 Keyword::MATERIALIZED => {
5069 if self.parse_keyword(Keyword::VIEW) {
5070 ShowCreateType::MaterializedView
5071 } else {
5072 return self.expected("VIEW after MATERIALIZED");
5073 }
5074 }
5075 Keyword::VIEW => ShowCreateType::View,
5076 Keyword::INDEX => ShowCreateType::Index,
5077 Keyword::SOURCE => ShowCreateType::Source,
5078 Keyword::SINK => ShowCreateType::Sink,
5079 Keyword::SUBSCRIPTION => ShowCreateType::Subscription,
5080 Keyword::FUNCTION => ShowCreateType::Function,
5081 _ => return self.expected(
5082 "TABLE, MATERIALIZED VIEW, VIEW, INDEX, FUNCTION, SOURCE, SUBSCRIPTION or SINK",
5083 ),
5084 };
5085 return Ok(Statement::ShowCreateObject {
5086 create_type: show_type,
5087 name: self.parse_object_name()?,
5088 });
5089 }
5090 self.expected(
5091 "TABLE, MATERIALIZED VIEW, VIEW, INDEX, FUNCTION, SOURCE, SUBSCRIPTION or SINK",
5092 )
5093 }
5094
5095 pub fn parse_show_statement_filter(&mut self) -> ModalResult<Option<ShowStatementFilter>> {
5096 if self.parse_keyword(Keyword::LIKE) {
5097 Ok(Some(ShowStatementFilter::Like(
5098 self.parse_literal_string()?,
5099 )))
5100 } else if self.parse_keyword(Keyword::ILIKE) {
5101 Ok(Some(ShowStatementFilter::ILike(
5102 self.parse_literal_string()?,
5103 )))
5104 } else if self.parse_keyword(Keyword::WHERE) {
5105 Ok(Some(ShowStatementFilter::Where(self.parse_expr()?)))
5106 } else {
5107 Ok(None)
5108 }
5109 }
5110
5111 pub fn parse_table_and_joins(&mut self) -> ModalResult<TableWithJoins> {
5112 let relation = self.parse_table_factor()?;
5113
5114 let mut joins = vec![];
5118 loop {
5119 let join = if self.parse_keyword(Keyword::CROSS) {
5120 let join_operator = if self.parse_keyword(Keyword::JOIN) {
5121 JoinOperator::CrossJoin
5122 } else {
5123 return self.expected("JOIN after CROSS");
5124 };
5125 Join {
5126 relation: self.parse_table_factor()?,
5127 join_operator,
5128 }
5129 } else {
5130 let (natural, asof) =
5131 match self.parse_one_of_keywords(&[Keyword::NATURAL, Keyword::ASOF]) {
5132 Some(Keyword::NATURAL) => (true, false),
5133 Some(Keyword::ASOF) => (false, true),
5134 Some(_) => unreachable!(),
5135 None => (false, false),
5136 };
5137 let peek_keyword = if let Token::Word(w) = self.peek_token().token {
5138 w.keyword
5139 } else {
5140 Keyword::NoKeyword
5141 };
5142
5143 let join_operator_type = match peek_keyword {
5144 Keyword::INNER | Keyword::JOIN => {
5145 let _ = self.parse_keyword(Keyword::INNER);
5146 self.expect_keyword(Keyword::JOIN)?;
5147 if asof {
5148 JoinOperator::AsOfInner
5149 } else {
5150 JoinOperator::Inner
5151 }
5152 }
5153 kw @ Keyword::LEFT | kw @ Keyword::RIGHT | kw @ Keyword::FULL => {
5154 let checkpoint = *self;
5155 let _ = self.next_token();
5156 let _ = self.parse_keyword(Keyword::OUTER);
5157 self.expect_keyword(Keyword::JOIN)?;
5158 if asof {
5159 if Keyword::LEFT == kw {
5160 JoinOperator::AsOfLeft
5161 } else {
5162 return self.expected_at(
5163 checkpoint,
5164 "LEFT after ASOF. RIGHT or FULL are not supported",
5165 );
5166 }
5167 } else {
5168 match kw {
5169 Keyword::LEFT => JoinOperator::LeftOuter,
5170 Keyword::RIGHT => JoinOperator::RightOuter,
5171 Keyword::FULL => JoinOperator::FullOuter,
5172 _ => unreachable!(),
5173 }
5174 }
5175 }
5176 Keyword::OUTER => {
5177 return self.expected("LEFT, RIGHT, or FULL");
5178 }
5179 _ if natural => {
5180 return self.expected("a join type after NATURAL");
5181 }
5182 _ if asof => {
5183 return self.expected("a join type after ASOF");
5184 }
5185 _ => break,
5186 };
5187 let relation = self.parse_table_factor()?;
5188 let join_constraint = self.parse_join_constraint(natural)?;
5189 let join_operator = join_operator_type(join_constraint);
5190 let need_constraint = match join_operator {
5191 JoinOperator::Inner(JoinConstraint::None) => Some("INNER JOIN"),
5192 JoinOperator::AsOfInner(JoinConstraint::None) => Some("ASOF INNER JOIN"),
5193 JoinOperator::AsOfLeft(JoinConstraint::None) => Some("ASOF LEFT JOIN"),
5194 _ => None,
5195 };
5196 if let Some(join_type) = need_constraint {
5197 return self.expected(&format!("join constraint after {join_type}"));
5198 }
5199
5200 Join {
5201 relation,
5202 join_operator,
5203 }
5204 };
5205 joins.push(join);
5206 }
5207 Ok(TableWithJoins { relation, joins })
5208 }
5209
5210 pub fn parse_table_factor(&mut self) -> ModalResult<TableFactor> {
5212 if self.parse_keyword(Keyword::LATERAL) {
5213 if !self.consume_token(&Token::LParen) {
5215 self.expected("subquery after LATERAL")?;
5216 }
5217 self.parse_derived_table_factor(Lateral)
5218 } else if self.consume_token(&Token::LParen) {
5219 match self.peek_token().token {
5239 Token::Word(w)
5240 if [Keyword::SELECT, Keyword::WITH, Keyword::VALUES].contains(&w.keyword) =>
5241 {
5242 return self.parse_derived_table_factor(NotLateral);
5243 }
5244 _ => {}
5245 };
5246 if self.peek_token() == Token::LParen {
5250 return_ok_if_some!(
5251 self.maybe_parse(|parser| parser.parse_derived_table_factor(NotLateral))
5252 );
5253 }
5254
5255 let table_and_joins = self.parse_table_and_joins()?;
5262
5263 #[allow(clippy::if_same_then_else)]
5264 if !table_and_joins.joins.is_empty() {
5265 self.expect_token(&Token::RParen)?;
5266 Ok(TableFactor::NestedJoin(Box::new(table_and_joins))) } else if let TableFactor::NestedJoin(_) = &table_and_joins.relation {
5268 self.expect_token(&Token::RParen)?;
5271 Ok(TableFactor::NestedJoin(Box::new(table_and_joins)))
5272 } else {
5273 parser_err!(
5276 "Expected joined table, found: {table_and_joins}, next_token: {}",
5277 self.peek_token()
5278 );
5279 }
5280 } else {
5281 let name = self.parse_object_name()?;
5282 if self.peek_token() == Token::LParen {
5283 let arg_list = self.parse_argument_list()?;
5286 if arg_list.distinct {
5287 parser_err!("DISTINCT is not supported in table-valued function calls");
5288 }
5289 if !arg_list.order_by.is_empty() {
5290 parser_err!("ORDER BY is not supported in table-valued function calls");
5291 }
5292 if arg_list.ignore_nulls {
5293 parser_err!("IGNORE NULLS is not supported in table-valued function calls");
5294 }
5295
5296 let args = arg_list.args;
5297 let with_ordinality = self.parse_keywords(&[Keyword::WITH, Keyword::ORDINALITY]);
5298 let alias = self.parse_optional_table_alias(keywords::RESERVED_FOR_TABLE_ALIAS)?;
5299
5300 Ok(TableFactor::TableFunction {
5301 name,
5302 alias,
5303 args,
5304 with_ordinality,
5305 })
5306 } else {
5307 let as_of = opt(Self::parse_as_of).parse_next(self)?;
5308 let alias = self.parse_optional_table_alias(keywords::RESERVED_FOR_TABLE_ALIAS)?;
5309 Ok(TableFactor::Table { name, alias, as_of })
5310 }
5311 }
5312 }
5313
5314 pub fn parse_derived_table_factor(&mut self, lateral: IsLateral) -> ModalResult<TableFactor> {
5315 let subquery = Box::new(self.parse_query()?);
5316 self.expect_token(&Token::RParen)?;
5317 let alias = self.parse_optional_table_alias(keywords::RESERVED_FOR_TABLE_ALIAS)?;
5318 Ok(TableFactor::Derived {
5319 lateral: match lateral {
5320 Lateral => true,
5321 NotLateral => false,
5322 },
5323 subquery,
5324 alias,
5325 })
5326 }
5327
5328 fn parse_join_constraint(&mut self, natural: bool) -> ModalResult<JoinConstraint> {
5329 if natural {
5330 Ok(JoinConstraint::Natural)
5331 } else if self.parse_keyword(Keyword::ON) {
5332 let constraint = self.parse_expr()?;
5333 Ok(JoinConstraint::On(constraint))
5334 } else if self.parse_keyword(Keyword::USING) {
5335 let columns = self.parse_parenthesized_column_list(Mandatory)?;
5336 Ok(JoinConstraint::Using(columns))
5337 } else {
5338 Ok(JoinConstraint::None)
5339 }
5341 }
5342
5343 pub fn parse_grant(&mut self) -> ModalResult<Statement> {
5345 let (privileges, objects) = self.parse_grant_revoke_privileges_objects()?;
5346
5347 self.expect_keyword(Keyword::TO)?;
5348 let grantees = self.parse_comma_separated(Parser::parse_identifier)?;
5349
5350 let with_grant_option =
5351 self.parse_keywords(&[Keyword::WITH, Keyword::GRANT, Keyword::OPTION]);
5352
5353 let granted_by = self
5354 .parse_keywords(&[Keyword::GRANTED, Keyword::BY])
5355 .then(|| self.parse_identifier().unwrap());
5356
5357 Ok(Statement::Grant {
5358 privileges,
5359 objects,
5360 grantees,
5361 with_grant_option,
5362 granted_by,
5363 })
5364 }
5365
5366 fn parse_privileges(&mut self) -> ModalResult<Privileges> {
5367 let privileges = if self.parse_keyword(Keyword::ALL) {
5368 Privileges::All {
5369 with_privileges_keyword: self.parse_keyword(Keyword::PRIVILEGES),
5370 }
5371 } else {
5372 Privileges::Actions(
5373 self.parse_comma_separated(Parser::parse_grant_permission)?
5374 .into_iter()
5375 .map(|(kw, columns)| match kw {
5376 Keyword::CONNECT => Action::Connect,
5377 Keyword::CREATE => Action::Create,
5378 Keyword::DELETE => Action::Delete,
5379 Keyword::EXECUTE => Action::Execute,
5380 Keyword::INSERT => Action::Insert { columns },
5381 Keyword::REFERENCES => Action::References { columns },
5382 Keyword::SELECT => Action::Select { columns },
5383 Keyword::TEMPORARY => Action::Temporary,
5384 Keyword::TRIGGER => Action::Trigger,
5385 Keyword::TRUNCATE => Action::Truncate,
5386 Keyword::UPDATE => Action::Update { columns },
5387 Keyword::USAGE => Action::Usage,
5388 _ => unreachable!(),
5389 })
5390 .collect(),
5391 )
5392 };
5393
5394 Ok(privileges)
5395 }
5396
5397 fn parse_grant_revoke_privileges_objects(&mut self) -> ModalResult<(Privileges, GrantObjects)> {
5398 let privileges = self.parse_privileges()?;
5399
5400 self.expect_keyword(Keyword::ON)?;
5401
5402 let objects = if self.parse_keywords(&[
5403 Keyword::ALL,
5404 Keyword::TABLES,
5405 Keyword::IN,
5406 Keyword::SCHEMA,
5407 ]) {
5408 GrantObjects::AllTablesInSchema {
5409 schemas: self.parse_comma_separated(Parser::parse_object_name)?,
5410 }
5411 } else if self.parse_keywords(&[
5412 Keyword::ALL,
5413 Keyword::SEQUENCES,
5414 Keyword::IN,
5415 Keyword::SCHEMA,
5416 ]) {
5417 GrantObjects::AllSequencesInSchema {
5418 schemas: self.parse_comma_separated(Parser::parse_object_name)?,
5419 }
5420 } else if self.parse_keywords(&[
5421 Keyword::ALL,
5422 Keyword::SOURCES,
5423 Keyword::IN,
5424 Keyword::SCHEMA,
5425 ]) {
5426 GrantObjects::AllSourcesInSchema {
5427 schemas: self.parse_comma_separated(Parser::parse_object_name)?,
5428 }
5429 } else if self.parse_keywords(&[Keyword::ALL, Keyword::SINKS, Keyword::IN, Keyword::SCHEMA])
5430 {
5431 GrantObjects::AllSinksInSchema {
5432 schemas: self.parse_comma_separated(Parser::parse_object_name)?,
5433 }
5434 } else if self.parse_keywords(&[
5435 Keyword::ALL,
5436 Keyword::MATERIALIZED,
5437 Keyword::VIEWS,
5438 Keyword::IN,
5439 Keyword::SCHEMA,
5440 ]) {
5441 GrantObjects::AllMviewsInSchema {
5442 schemas: self.parse_comma_separated(Parser::parse_object_name)?,
5443 }
5444 } else if self.parse_keywords(&[Keyword::ALL, Keyword::VIEWS, Keyword::IN, Keyword::SCHEMA])
5445 {
5446 GrantObjects::AllViewsInSchema {
5447 schemas: self.parse_comma_separated(Parser::parse_object_name)?,
5448 }
5449 } else if self.parse_keywords(&[
5450 Keyword::ALL,
5451 Keyword::FUNCTIONS,
5452 Keyword::IN,
5453 Keyword::SCHEMA,
5454 ]) {
5455 GrantObjects::AllFunctionsInSchema {
5456 schemas: self.parse_comma_separated(Parser::parse_object_name)?,
5457 }
5458 } else if self.parse_keywords(&[
5459 Keyword::ALL,
5460 Keyword::SECRETS,
5461 Keyword::IN,
5462 Keyword::SCHEMA,
5463 ]) {
5464 GrantObjects::AllSecretsInSchema {
5465 schemas: self.parse_comma_separated(Parser::parse_object_name)?,
5466 }
5467 } else if self.parse_keywords(&[
5468 Keyword::ALL,
5469 Keyword::CONNECTIONS,
5470 Keyword::IN,
5471 Keyword::SCHEMA,
5472 ]) {
5473 GrantObjects::AllConnectionsInSchema {
5474 schemas: self.parse_comma_separated(Parser::parse_object_name)?,
5475 }
5476 } else if self.parse_keywords(&[
5477 Keyword::ALL,
5478 Keyword::SUBSCRIPTIONS,
5479 Keyword::IN,
5480 Keyword::SCHEMA,
5481 ]) {
5482 GrantObjects::AllSubscriptionsInSchema {
5483 schemas: self.parse_comma_separated(Parser::parse_object_name)?,
5484 }
5485 } else if self.parse_keywords(&[Keyword::MATERIALIZED, Keyword::VIEW]) {
5486 GrantObjects::Mviews(self.parse_comma_separated(Parser::parse_object_name)?)
5487 } else {
5488 let object_type = self.parse_one_of_keywords(&[
5489 Keyword::SEQUENCE,
5490 Keyword::DATABASE,
5491 Keyword::SCHEMA,
5492 Keyword::TABLE,
5493 Keyword::SOURCE,
5494 Keyword::SINK,
5495 Keyword::VIEW,
5496 Keyword::SUBSCRIPTION,
5497 Keyword::FUNCTION,
5498 Keyword::CONNECTION,
5499 Keyword::SECRET,
5500 ]);
5501 if let Some(Keyword::FUNCTION) = object_type {
5502 let func_descs = self.parse_comma_separated(Parser::parse_function_desc)?;
5503 GrantObjects::Functions(func_descs)
5504 } else {
5505 let objects = self.parse_comma_separated(Parser::parse_object_name);
5506 match object_type {
5507 Some(Keyword::DATABASE) => GrantObjects::Databases(objects?),
5508 Some(Keyword::SCHEMA) => GrantObjects::Schemas(objects?),
5509 Some(Keyword::SEQUENCE) => GrantObjects::Sequences(objects?),
5510 Some(Keyword::SOURCE) => GrantObjects::Sources(objects?),
5511 Some(Keyword::SINK) => GrantObjects::Sinks(objects?),
5512 Some(Keyword::VIEW) => GrantObjects::Views(objects?),
5513 Some(Keyword::SUBSCRIPTION) => GrantObjects::Subscriptions(objects?),
5514 Some(Keyword::CONNECTION) => GrantObjects::Connections(objects?),
5515 Some(Keyword::SECRET) => GrantObjects::Secrets(objects?),
5516 Some(Keyword::TABLE) | None => GrantObjects::Tables(objects?),
5517 _ => unreachable!(),
5518 }
5519 }
5520 };
5521
5522 Ok((privileges, objects))
5523 }
5524
5525 fn parse_grant_permission(&mut self) -> ModalResult<(Keyword, Option<Vec<Ident>>)> {
5526 let kw = self.expect_one_of_keywords(&[
5527 Keyword::CONNECT,
5528 Keyword::CREATE,
5529 Keyword::DELETE,
5530 Keyword::EXECUTE,
5531 Keyword::INSERT,
5532 Keyword::REFERENCES,
5533 Keyword::SELECT,
5534 Keyword::TEMPORARY,
5535 Keyword::TRIGGER,
5536 Keyword::TRUNCATE,
5537 Keyword::UPDATE,
5538 Keyword::USAGE,
5539 ])?;
5540 let columns = match kw {
5541 Keyword::INSERT | Keyword::REFERENCES | Keyword::SELECT | Keyword::UPDATE => {
5542 let columns = self.parse_parenthesized_column_list(Optional)?;
5543 if columns.is_empty() {
5544 None
5545 } else {
5546 Some(columns)
5547 }
5548 }
5549 _ => None,
5550 };
5551 Ok((kw, columns))
5552 }
5553
5554 pub fn parse_revoke(&mut self) -> ModalResult<Statement> {
5556 let revoke_grant_option =
5557 self.parse_keywords(&[Keyword::GRANT, Keyword::OPTION, Keyword::FOR]);
5558 let (privileges, objects) = self.parse_grant_revoke_privileges_objects()?;
5559
5560 self.expect_keyword(Keyword::FROM)?;
5561 let grantees = self.parse_comma_separated(Parser::parse_identifier)?;
5562
5563 let granted_by = self
5564 .parse_keywords(&[Keyword::GRANTED, Keyword::BY])
5565 .then(|| self.parse_identifier().unwrap());
5566
5567 let cascade = self.parse_keyword(Keyword::CASCADE);
5568 let restrict = self.parse_keyword(Keyword::RESTRICT);
5569 if cascade && restrict {
5570 parser_err!("Cannot specify both CASCADE and RESTRICT in REVOKE");
5571 }
5572
5573 Ok(Statement::Revoke {
5574 privileges,
5575 objects,
5576 grantees,
5577 granted_by,
5578 revoke_grant_option,
5579 cascade,
5580 })
5581 }
5582
5583 fn parse_privilege_object_types(&mut self) -> ModalResult<PrivilegeObjectType> {
5584 let object_type = if self.parse_keyword(Keyword::TABLES) {
5585 PrivilegeObjectType::Tables
5586 } else if self.parse_keyword(Keyword::SOURCES) {
5587 PrivilegeObjectType::Sources
5588 } else if self.parse_keyword(Keyword::SINKS) {
5589 PrivilegeObjectType::Sinks
5590 } else if self.parse_keywords(&[Keyword::MATERIALIZED, Keyword::VIEWS]) {
5591 PrivilegeObjectType::Mviews
5592 } else if self.parse_keyword(Keyword::VIEWS) {
5593 PrivilegeObjectType::Views
5594 } else if self.parse_keyword(Keyword::FUNCTIONS) {
5595 PrivilegeObjectType::Functions
5596 } else if self.parse_keyword(Keyword::SECRETS) {
5597 PrivilegeObjectType::Secrets
5598 } else if self.parse_keyword(Keyword::CONNECTIONS) {
5599 PrivilegeObjectType::Connections
5600 } else if self.parse_keyword(Keyword::SUBSCRIPTIONS) {
5601 PrivilegeObjectType::Subscriptions
5602 } else if self.parse_keyword(Keyword::SCHEMAS) {
5603 PrivilegeObjectType::Schemas
5604 } else {
5605 return self.expected("TABLES, SOURCES, SINKS, MATERIALIZED VIEWS, VIEWS, FUNCTIONS, SECRETS, CONNECTIONS, SUBSCRIPTIONS or SCHEMAS");
5606 };
5607
5608 Ok(object_type)
5609 }
5610
5611 pub fn parse_alter_default_privileges(&mut self) -> ModalResult<Statement> {
5612 let target_users = if self.parse_keyword(Keyword::FOR) {
5614 self.expect_keyword(Keyword::USER)?;
5615 Some(self.parse_comma_separated(Parser::parse_identifier)?)
5616 } else {
5617 None
5618 };
5619
5620 let schema_names = if self.parse_keywords(&[Keyword::IN, Keyword::SCHEMA]) {
5622 Some(self.parse_comma_separated(Parser::parse_object_name)?)
5623 } else {
5624 None
5625 };
5626 let keyword = self.expect_one_of_keywords(&[Keyword::GRANT, Keyword::REVOKE])?;
5627 let for_grant = keyword == Keyword::GRANT;
5628 if for_grant {
5629 let privileges = self.parse_privileges()?;
5630 self.expect_keyword(Keyword::ON)?;
5631 let object_type = self.parse_privilege_object_types()?;
5632 if schema_names.is_some() && object_type == PrivilegeObjectType::Schemas {
5633 parser_err!("cannot use IN SCHEMA clause when using GRANT/REVOKE ON SCHEMAS");
5634 }
5635 self.expect_keyword(Keyword::TO)?;
5636 let grantees = self.parse_comma_separated(Parser::parse_identifier)?;
5637
5638 let with_grant_option =
5639 self.parse_keywords(&[Keyword::WITH, Keyword::GRANT, Keyword::OPTION]);
5640
5641 Ok(Statement::AlterDefaultPrivileges {
5642 target_users,
5643 schema_names,
5644 operation: DefaultPrivilegeOperation::Grant {
5645 privileges,
5646 object_type,
5647 grantees,
5648 with_grant_option,
5649 },
5650 })
5651 } else {
5652 let revoke_grant_option =
5653 self.parse_keywords(&[Keyword::GRANT, Keyword::OPTION, Keyword::FOR]);
5654 let privileges = self.parse_privileges()?;
5655 self.expect_keyword(Keyword::ON)?;
5656 let object_type = self.parse_privilege_object_types()?;
5657 if schema_names.is_some() && object_type == PrivilegeObjectType::Schemas {
5658 parser_err!("cannot use IN SCHEMA clause when using GRANT/REVOKE ON SCHEMAS");
5659 }
5660 self.expect_keyword(Keyword::FROM)?;
5661 let grantees = self.parse_comma_separated(Parser::parse_identifier)?;
5662 let cascade = self.parse_keyword(Keyword::CASCADE);
5663 let restrict = self.parse_keyword(Keyword::RESTRICT);
5664 if cascade && restrict {
5665 parser_err!("Cannot specify both CASCADE and RESTRICT in REVOKE");
5666 }
5667
5668 Ok(Statement::AlterDefaultPrivileges {
5669 target_users,
5670 schema_names,
5671 operation: DefaultPrivilegeOperation::Revoke {
5672 privileges,
5673 object_type,
5674 grantees,
5675 revoke_grant_option,
5676 cascade,
5677 },
5678 })
5679 }
5680 }
5681
5682 pub fn parse_insert(&mut self) -> ModalResult<Statement> {
5684 self.expect_keyword(Keyword::INTO)?;
5685
5686 let table_name = self.parse_object_name()?;
5687 let columns = self.parse_parenthesized_column_list(Optional)?;
5688
5689 let source = Box::new(self.parse_query()?);
5690 let returning = self.parse_returning(Optional)?;
5691 Ok(Statement::Insert {
5692 table_name,
5693 columns,
5694 source,
5695 returning,
5696 })
5697 }
5698
5699 pub fn parse_update(&mut self) -> ModalResult<Statement> {
5700 let table_name = self.parse_object_name()?;
5701
5702 self.expect_keyword(Keyword::SET)?;
5703 let assignments = self.parse_comma_separated(Parser::parse_assignment)?;
5704 let selection = if self.parse_keyword(Keyword::WHERE) {
5705 Some(self.parse_expr()?)
5706 } else {
5707 None
5708 };
5709 let returning = self.parse_returning(Optional)?;
5710 Ok(Statement::Update {
5711 table_name,
5712 assignments,
5713 selection,
5714 returning,
5715 })
5716 }
5717
5718 pub fn parse_assignment(&mut self) -> ModalResult<Assignment> {
5720 let id = self.parse_identifiers_non_keywords()?;
5721 self.expect_token(&Token::Eq)?;
5722
5723 let value = if self.parse_keyword(Keyword::DEFAULT) {
5724 AssignmentValue::Default
5725 } else {
5726 AssignmentValue::Expr(self.parse_expr()?)
5727 };
5728
5729 Ok(Assignment { id, value })
5730 }
5731
5732 fn parse_function_args(&mut self) -> ModalResult<(bool, FunctionArg)> {
5734 let variadic = self.parse_keyword(Keyword::VARIADIC);
5735 let arg = if self.peek_nth_token(1) == Token::RArrow {
5736 let name = self.parse_identifier()?;
5737
5738 self.expect_token(&Token::RArrow)?;
5739 let arg = self.parse_wildcard_or_expr()?.into();
5740
5741 FunctionArg::Named { name, arg }
5742 } else {
5743 FunctionArg::Unnamed(self.parse_wildcard_or_expr()?.into())
5744 };
5745 Ok((variadic, arg))
5746 }
5747
5748 pub fn parse_argument_list(&mut self) -> ModalResult<FunctionArgList> {
5749 self.expect_token(&Token::LParen)?;
5750 if self.consume_token(&Token::RParen) {
5751 Ok(FunctionArgList::empty())
5752 } else {
5753 let distinct = self.parse_all_or_distinct()?;
5754 let args = self.parse_comma_separated(Parser::parse_function_args)?;
5755 if args
5756 .iter()
5757 .take(args.len() - 1)
5758 .any(|(variadic, _)| *variadic)
5759 {
5760 parser_err!("VARIADIC argument must be the last");
5761 }
5762 let variadic = args.last().map(|(variadic, _)| *variadic).unwrap_or(false);
5763 let args = args.into_iter().map(|(_, arg)| arg).collect();
5764
5765 let order_by = if self.parse_keywords(&[Keyword::ORDER, Keyword::BY]) {
5766 self.parse_comma_separated(Parser::parse_order_by_expr)?
5767 } else {
5768 vec![]
5769 };
5770
5771 let ignore_nulls = self.parse_keywords(&[Keyword::IGNORE, Keyword::NULLS]);
5772
5773 let arg_list = FunctionArgList {
5774 distinct,
5775 args,
5776 variadic,
5777 order_by,
5778 ignore_nulls,
5779 };
5780
5781 self.expect_token(&Token::RParen)?;
5782 Ok(arg_list)
5783 }
5784 }
5785
5786 pub fn parse_select_item(&mut self) -> ModalResult<SelectItem> {
5788 match self.parse_wildcard_or_expr()? {
5789 WildcardOrExpr::Expr(expr) => self
5790 .parse_optional_alias(keywords::RESERVED_FOR_COLUMN_ALIAS)
5791 .map(|alias| match alias {
5792 Some(alias) => SelectItem::ExprWithAlias { expr, alias },
5793 None => SelectItem::UnnamedExpr(expr),
5794 }),
5795 WildcardOrExpr::QualifiedWildcard(prefix, except) => {
5796 Ok(SelectItem::QualifiedWildcard(prefix, except))
5797 }
5798 WildcardOrExpr::ExprQualifiedWildcard(expr, prefix) => {
5799 Ok(SelectItem::ExprQualifiedWildcard(expr, prefix))
5800 }
5801 WildcardOrExpr::Wildcard(except) => Ok(SelectItem::Wildcard(except)),
5802 }
5803 }
5804
5805 pub fn parse_order_by_expr(&mut self) -> ModalResult<OrderByExpr> {
5807 let expr = self.parse_expr()?;
5808
5809 let asc = if self.parse_keyword(Keyword::ASC) {
5810 Some(true)
5811 } else if self.parse_keyword(Keyword::DESC) {
5812 Some(false)
5813 } else {
5814 None
5815 };
5816
5817 let nulls_first = if self.parse_keywords(&[Keyword::NULLS, Keyword::FIRST]) {
5818 Some(true)
5819 } else if self.parse_keywords(&[Keyword::NULLS, Keyword::LAST]) {
5820 Some(false)
5821 } else {
5822 None
5823 };
5824
5825 Ok(OrderByExpr {
5826 expr,
5827 asc,
5828 nulls_first,
5829 })
5830 }
5831
5832 pub fn parse_limit(&mut self) -> ModalResult<Option<Expr>> {
5834 if self.parse_keyword(Keyword::ALL) {
5835 Ok(None)
5836 } else {
5837 let expr = self.parse_expr()?;
5838 Ok(Some(expr))
5839 }
5840 }
5841
5842 pub fn parse_offset(&mut self) -> ModalResult<String> {
5844 let value = self.parse_number_value()?;
5845 if self.consume_token(&Token::DoubleColon) {
5847 self.expect_keyword(Keyword::BIGINT)?;
5848 }
5849 _ = self.parse_one_of_keywords(&[Keyword::ROW, Keyword::ROWS]);
5850 Ok(value)
5851 }
5852
5853 pub fn parse_fetch(&mut self) -> ModalResult<Fetch> {
5855 self.expect_one_of_keywords(&[Keyword::FIRST, Keyword::NEXT])?;
5856 let quantity = if self
5857 .parse_one_of_keywords(&[Keyword::ROW, Keyword::ROWS])
5858 .is_some()
5859 {
5860 None
5861 } else {
5862 let quantity = self.parse_number_value()?;
5863 self.expect_one_of_keywords(&[Keyword::ROW, Keyword::ROWS])?;
5864 Some(quantity)
5865 };
5866 let with_ties = if self.parse_keyword(Keyword::ONLY) {
5867 false
5868 } else if self.parse_keywords(&[Keyword::WITH, Keyword::TIES]) {
5869 true
5870 } else {
5871 return self.expected("one of ONLY or WITH TIES");
5872 };
5873 Ok(Fetch {
5874 with_ties,
5875 quantity,
5876 })
5877 }
5878
5879 pub fn parse_values(&mut self) -> ModalResult<Values> {
5880 let values = self.parse_comma_separated(|parser| {
5881 parser.expect_token(&Token::LParen)?;
5882 let exprs = parser.parse_comma_separated(Parser::parse_expr)?;
5883 parser.expect_token(&Token::RParen)?;
5884 Ok(exprs)
5885 })?;
5886 Ok(Values(values))
5887 }
5888
5889 pub fn parse_start_transaction(&mut self) -> ModalResult<Statement> {
5890 self.expect_keyword(Keyword::TRANSACTION)?;
5891 Ok(Statement::StartTransaction {
5892 modes: self.parse_transaction_modes()?,
5893 })
5894 }
5895
5896 pub fn parse_begin(&mut self) -> ModalResult<Statement> {
5897 let _ = self.parse_one_of_keywords(&[Keyword::TRANSACTION, Keyword::WORK]);
5898 Ok(Statement::Begin {
5899 modes: self.parse_transaction_modes()?,
5900 })
5901 }
5902
5903 pub fn parse_transaction_modes(&mut self) -> ModalResult<Vec<TransactionMode>> {
5904 let mut modes = vec![];
5905 let mut required = false;
5906 loop {
5907 let mode = if self.parse_keywords(&[Keyword::ISOLATION, Keyword::LEVEL]) {
5908 let iso_level = if self.parse_keywords(&[Keyword::READ, Keyword::UNCOMMITTED]) {
5909 TransactionIsolationLevel::ReadUncommitted
5910 } else if self.parse_keywords(&[Keyword::READ, Keyword::COMMITTED]) {
5911 TransactionIsolationLevel::ReadCommitted
5912 } else if self.parse_keywords(&[Keyword::REPEATABLE, Keyword::READ]) {
5913 TransactionIsolationLevel::RepeatableRead
5914 } else if self.parse_keyword(Keyword::SERIALIZABLE) {
5915 TransactionIsolationLevel::Serializable
5916 } else {
5917 self.expected("isolation level")?
5918 };
5919 TransactionMode::IsolationLevel(iso_level)
5920 } else if self.parse_keywords(&[Keyword::READ, Keyword::ONLY]) {
5921 TransactionMode::AccessMode(TransactionAccessMode::ReadOnly)
5922 } else if self.parse_keywords(&[Keyword::READ, Keyword::WRITE]) {
5923 TransactionMode::AccessMode(TransactionAccessMode::ReadWrite)
5924 } else if required {
5925 self.expected("transaction mode")?
5926 } else {
5927 break;
5928 };
5929 modes.push(mode);
5930 required = self.consume_token(&Token::Comma);
5935 }
5936 Ok(modes)
5937 }
5938
5939 pub fn parse_commit(&mut self) -> ModalResult<Statement> {
5940 Ok(Statement::Commit {
5941 chain: self.parse_commit_rollback_chain()?,
5942 })
5943 }
5944
5945 pub fn parse_rollback(&mut self) -> ModalResult<Statement> {
5946 Ok(Statement::Rollback {
5947 chain: self.parse_commit_rollback_chain()?,
5948 })
5949 }
5950
5951 pub fn parse_commit_rollback_chain(&mut self) -> ModalResult<bool> {
5952 let _ = self.parse_one_of_keywords(&[Keyword::TRANSACTION, Keyword::WORK]);
5953 if self.parse_keyword(Keyword::AND) {
5954 let chain = !self.parse_keyword(Keyword::NO);
5955 self.expect_keyword(Keyword::CHAIN)?;
5956 Ok(chain)
5957 } else {
5958 Ok(false)
5959 }
5960 }
5961
5962 fn parse_deallocate(&mut self) -> ModalResult<Statement> {
5963 let prepare = self.parse_keyword(Keyword::PREPARE);
5964 let name = if self.parse_keyword(Keyword::ALL) {
5965 None
5966 } else {
5967 Some(self.parse_identifier()?)
5968 };
5969 Ok(Statement::Deallocate { name, prepare })
5970 }
5971
5972 fn parse_execute(&mut self) -> ModalResult<Statement> {
5973 let name = self.parse_identifier()?;
5974
5975 let mut parameters = vec![];
5976 if self.consume_token(&Token::LParen) {
5977 parameters = self.parse_comma_separated(Parser::parse_expr)?;
5978 self.expect_token(&Token::RParen)?;
5979 }
5980
5981 Ok(Statement::Execute { name, parameters })
5982 }
5983
5984 fn parse_prepare(&mut self) -> ModalResult<Statement> {
5985 let name = self.parse_identifier()?;
5986
5987 let mut data_types = vec![];
5988 if self.consume_token(&Token::LParen) {
5989 data_types = self.parse_comma_separated(Parser::parse_data_type)?;
5990 self.expect_token(&Token::RParen)?;
5991 }
5992
5993 self.expect_keyword(Keyword::AS)?;
5994 let statement = Box::new(self.parse_statement()?);
5995 Ok(Statement::Prepare {
5996 name,
5997 data_types,
5998 statement,
5999 })
6000 }
6001
6002 fn parse_comment(&mut self) -> ModalResult<Statement> {
6003 self.expect_keyword(Keyword::ON)?;
6004 let checkpoint = *self;
6005 let token = self.next_token();
6006
6007 let (object_type, object_name) = match token.token {
6008 Token::Word(w) if w.keyword == Keyword::COLUMN => {
6009 let object_name = self.parse_object_name()?;
6010 (CommentObject::Column, object_name)
6011 }
6012 Token::Word(w) if w.keyword == Keyword::TABLE => {
6013 let object_name = self.parse_object_name()?;
6014 (CommentObject::Table, object_name)
6015 }
6016 _ => self.expected_at(checkpoint, "comment object_type")?,
6017 };
6018
6019 self.expect_keyword(Keyword::IS)?;
6020 let comment = if self.parse_keyword(Keyword::NULL) {
6021 None
6022 } else {
6023 Some(self.parse_literal_string()?)
6024 };
6025 Ok(Statement::Comment {
6026 object_type,
6027 object_name,
6028 comment,
6029 })
6030 }
6031
6032 fn parse_use(&mut self) -> ModalResult<Statement> {
6033 let db_name = self.parse_object_name()?;
6034 Ok(Statement::Use { db_name })
6035 }
6036
6037 pub fn parse_named_window(&mut self) -> ModalResult<NamedWindow> {
6039 let name = self.parse_identifier()?;
6040 self.expect_keywords(&[Keyword::AS])?;
6041 self.expect_token(&Token::LParen)?;
6042 let window_spec = self.parse_window_spec()?;
6043 self.expect_token(&Token::RParen)?;
6044 Ok(NamedWindow { name, window_spec })
6045 }
6046
6047 pub fn parse_window_spec(&mut self) -> ModalResult<WindowSpec> {
6049 let partition_by = if self.parse_keywords(&[Keyword::PARTITION, Keyword::BY]) {
6050 self.parse_comma_separated(Parser::parse_expr)?
6051 } else {
6052 vec![]
6053 };
6054 let order_by = if self.parse_keywords(&[Keyword::ORDER, Keyword::BY]) {
6055 self.parse_comma_separated(Parser::parse_order_by_expr)?
6056 } else {
6057 vec![]
6058 };
6059 let window_frame = if !self.peek_token().eq(&Token::RParen) {
6060 Some(self.parse_window_frame()?)
6061 } else {
6062 None
6063 };
6064 Ok(WindowSpec {
6065 partition_by,
6066 order_by,
6067 window_frame,
6068 })
6069 }
6070}
6071
6072impl Word {
6073 pub fn to_ident(&self) -> ModalResult<Ident> {
6075 if self.value.is_empty() {
6076 parser_err!("zero-length delimited identifier at or near \"{self}\"")
6077 } else {
6078 Ok(Ident {
6079 value: self.value.clone(),
6080 quote_style: self.quote_style,
6081 })
6082 }
6083 }
6084}
6085
6086#[cfg(test)]
6087mod tests {
6088 use super::*;
6089 use crate::test_utils::run_parser_method;
6090
6091 #[test]
6092 fn test_parse_integer_min() {
6093 let min_bigint = "-9223372036854775808";
6094 run_parser_method(min_bigint, |parser| {
6095 assert_eq!(
6096 parser.parse_expr().unwrap(),
6097 Expr::Value(Value::Number("-9223372036854775808".to_owned()))
6098 )
6099 });
6100 }
6101}