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 log::debug;
26
27use crate::ast::*;
28use crate::dialect::*;
29use crate::keywords::{self, Keyword};
30use crate::tokenizer::*;
31
32#[derive(Debug, Clone, PartialEq)]
33pub enum ParserError {
34 TokenizerError(String),
35 ParserError(String),
36}
37
38macro_rules! parser_err {
40 ($MSG:expr) => {
41 Err(ParserError::ParserError($MSG.to_string()))
42 };
43}
44
45macro_rules! return_ok_if_some {
47 ($e:expr) => {{
48 if let Some(v) = $e {
49 return Ok(v);
50 }
51 }};
52}
53
54#[derive(PartialEq)]
55pub enum IsOptional {
56 Optional,
57 Mandatory,
58}
59
60use IsOptional::*;
61
62pub enum IsLateral {
63 Lateral,
64 NotLateral,
65}
66
67use IsLateral::*;
68
69pub enum WildcardExpr {
70 Expr(Expr),
71 QualifiedWildcard(ObjectName),
72 Wildcard,
73}
74
75impl From<WildcardExpr> for FunctionArgExpr {
76 fn from(wildcard_expr: WildcardExpr) -> Self {
77 match wildcard_expr {
78 WildcardExpr::Expr(expr) => Self::Expr(expr),
79 WildcardExpr::QualifiedWildcard(prefix) => Self::QualifiedWildcard(prefix),
80 WildcardExpr::Wildcard => Self::Wildcard,
81 }
82 }
83}
84
85impl From<TokenizerError> for ParserError {
86 fn from(e: TokenizerError) -> Self {
87 ParserError::TokenizerError(e.to_string())
88 }
89}
90
91impl fmt::Display for ParserError {
92 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
93 write!(
94 f,
95 "sql parser error: {}",
96 match self {
97 ParserError::TokenizerError(s) => s,
98 ParserError::ParserError(s) => s,
99 }
100 )
101 }
102}
103
104#[cfg(feature = "std")]
105impl std::error::Error for ParserError {}
106
107pub struct Parser<'a> {
108 tokens: Vec<Token>,
109 index: usize,
111 dialect: &'a dyn Dialect,
112}
113
114impl<'a> Parser<'a> {
115 pub fn new(tokens: Vec<Token>, dialect: &'a dyn Dialect) -> Self {
117 Parser {
118 tokens,
119 index: 0,
120 dialect,
121 }
122 }
123
124 pub fn parse_sql(dialect: &dyn Dialect, sql: &str) -> Result<Vec<Statement>, ParserError> {
126 let mut tokenizer = Tokenizer::new(dialect, sql);
127 let tokens = tokenizer.tokenize()?;
128 let mut parser = Parser::new(tokens, dialect);
129 let mut stmts = Vec::new();
130 let mut expecting_statement_delimiter = false;
131 debug!("Parsing sql '{}'...", sql);
132 loop {
133 while parser.consume_token(&Token::SemiColon) {
135 expecting_statement_delimiter = false;
136 }
137 if parser.peek_token() == Token::EOF {
138 break;
139 }
140 if expecting_statement_delimiter {
141 return parser.expected("end of statement", parser.peek_token());
142 }
143
144 let statement = parser.parse_statement()?;
145 stmts.push(statement);
146 expecting_statement_delimiter = true;
147 }
148 Ok(stmts)
149 }
150
151 pub fn parse_statement(&mut self) -> Result<Statement, ParserError> {
154 match self.next_token() {
155 Token::Word(w) => match w.keyword {
156 Keyword::DESCRIBE => Ok(self.parse_explain(true)?),
157 Keyword::EXPLAIN => Ok(self.parse_explain(false)?),
158 Keyword::ANALYZE => Ok(self.parse_analyze()?),
159 Keyword::SELECT | Keyword::WITH | Keyword::VALUES => {
160 self.prev_token();
161 Ok(Statement::Query(Box::new(self.parse_query()?)))
162 }
163 Keyword::TRUNCATE => Ok(self.parse_truncate()?),
164 Keyword::MSCK => Ok(self.parse_msck()?),
165 Keyword::CREATE => Ok(self.parse_create()?),
166 Keyword::DROP => Ok(self.parse_drop()?),
167 Keyword::DELETE => Ok(self.parse_delete()?),
168 Keyword::INSERT => Ok(self.parse_insert()?),
169 Keyword::UPDATE => Ok(self.parse_update()?),
170 Keyword::ALTER => Ok(self.parse_alter()?),
171 Keyword::COPY => Ok(self.parse_copy()?),
172 Keyword::SET => Ok(self.parse_set()?),
173 Keyword::SHOW => Ok(self.parse_show()?),
174 Keyword::GRANT => Ok(self.parse_grant()?),
175 Keyword::REVOKE => Ok(self.parse_revoke()?),
176 Keyword::START => Ok(self.parse_start_transaction()?),
177 Keyword::BEGIN => Ok(self.parse_begin()?),
181 Keyword::COMMIT => Ok(self.parse_commit()?),
182 Keyword::ROLLBACK => Ok(self.parse_rollback()?),
183 Keyword::ASSERT => Ok(self.parse_assert()?),
184 Keyword::DEALLOCATE => Ok(self.parse_deallocate()?),
187 Keyword::EXECUTE => Ok(self.parse_execute()?),
188 Keyword::PREPARE => Ok(self.parse_prepare()?),
189 Keyword::REPLACE if dialect_of!(self is SQLiteDialect ) => {
190 self.prev_token();
191 Ok(self.parse_insert()?)
192 }
193 Keyword::COMMENT if dialect_of!(self is PostgreSqlDialect) => {
194 Ok(self.parse_comment()?)
195 }
196 _ => self.expected("an SQL statement", Token::Word(w)),
197 },
198 Token::LParen => {
199 self.prev_token();
200 Ok(Statement::Query(Box::new(self.parse_query()?)))
201 }
202 unexpected => self.expected("an SQL statement", unexpected),
203 }
204 }
205
206 pub fn parse_msck(&mut self) -> Result<Statement, ParserError> {
207 let repair = self.parse_keyword(Keyword::REPAIR);
208 self.expect_keyword(Keyword::TABLE)?;
209 let table_name = self.parse_object_name()?;
210 let partition_action = self
211 .maybe_parse(|parser| {
212 let pa = match parser.parse_one_of_keywords(&[
213 Keyword::ADD,
214 Keyword::DROP,
215 Keyword::SYNC,
216 ]) {
217 Some(Keyword::ADD) => Some(AddDropSync::ADD),
218 Some(Keyword::DROP) => Some(AddDropSync::DROP),
219 Some(Keyword::SYNC) => Some(AddDropSync::SYNC),
220 _ => None,
221 };
222 parser.expect_keyword(Keyword::PARTITIONS)?;
223 Ok(pa)
224 })
225 .unwrap_or_default();
226 Ok(Statement::Msck {
227 repair,
228 table_name,
229 partition_action,
230 })
231 }
232
233 pub fn parse_truncate(&mut self) -> Result<Statement, ParserError> {
234 self.expect_keyword(Keyword::TABLE)?;
235 let table_name = self.parse_object_name()?;
236 let mut partitions = None;
237 if self.parse_keyword(Keyword::PARTITION) {
238 self.expect_token(&Token::LParen)?;
239 partitions = Some(self.parse_comma_separated(Parser::parse_expr)?);
240 self.expect_token(&Token::RParen)?;
241 }
242 Ok(Statement::Truncate {
243 table_name,
244 partitions,
245 })
246 }
247
248 pub fn parse_analyze(&mut self) -> Result<Statement, ParserError> {
249 self.expect_keyword(Keyword::TABLE)?;
250 let table_name = self.parse_object_name()?;
251 let mut for_columns = false;
252 let mut cache_metadata = false;
253 let mut noscan = false;
254 let mut partitions = None;
255 let mut compute_statistics = false;
256 let mut columns = vec![];
257 loop {
258 match self.parse_one_of_keywords(&[
259 Keyword::PARTITION,
260 Keyword::FOR,
261 Keyword::CACHE,
262 Keyword::NOSCAN,
263 Keyword::COMPUTE,
264 ]) {
265 Some(Keyword::PARTITION) => {
266 self.expect_token(&Token::LParen)?;
267 partitions = Some(self.parse_comma_separated(Parser::parse_expr)?);
268 self.expect_token(&Token::RParen)?;
269 }
270 Some(Keyword::NOSCAN) => noscan = true,
271 Some(Keyword::FOR) => {
272 self.expect_keyword(Keyword::COLUMNS)?;
273
274 columns = self
275 .maybe_parse(|parser| {
276 parser.parse_comma_separated(Parser::parse_identifier)
277 })
278 .unwrap_or_default();
279 for_columns = true
280 }
281 Some(Keyword::CACHE) => {
282 self.expect_keyword(Keyword::METADATA)?;
283 cache_metadata = true
284 }
285 Some(Keyword::COMPUTE) => {
286 self.expect_keyword(Keyword::STATISTICS)?;
287 compute_statistics = true
288 }
289 _ => break,
290 }
291 }
292
293 Ok(Statement::Analyze {
294 table_name,
295 for_columns,
296 columns,
297 partitions,
298 cache_metadata,
299 noscan,
300 compute_statistics,
301 })
302 }
303
304 pub fn parse_wildcard_expr(&mut self) -> Result<WildcardExpr, ParserError> {
306 let index = self.index;
307
308 match self.next_token() {
309 Token::Word(w) if self.peek_token() == Token::Period => {
310 let mut id_parts: Vec<Ident> = vec![w.to_ident()];
311
312 while self.consume_token(&Token::Period) {
313 match self.next_token() {
314 Token::Word(w) => id_parts.push(w.to_ident()),
315 Token::Mul => {
316 return Ok(WildcardExpr::QualifiedWildcard(ObjectName(id_parts)));
317 }
318 unexpected => {
319 return self.expected("an identifier or a '*' after '.'", unexpected);
320 }
321 }
322 }
323 }
324 Token::Mul => {
325 return Ok(WildcardExpr::Wildcard);
326 }
327 _ => (),
328 };
329
330 self.index = index;
331 self.parse_expr().map(WildcardExpr::Expr)
332 }
333
334 pub fn parse_expr(&mut self) -> Result<Expr, ParserError> {
336 self.parse_subexpr(0)
337 }
338
339 pub fn parse_subexpr(&mut self, precedence: u8) -> Result<Expr, ParserError> {
341 debug!("parsing expr");
342 let mut expr = self.parse_prefix()?;
343 debug!("prefix: {:?}", expr);
344 loop {
345 let next_precedence = self.get_next_precedence()?;
346 debug!("next precedence: {:?}", next_precedence);
347
348 if precedence >= next_precedence {
349 break;
350 }
351
352 expr = self.parse_infix(expr, next_precedence)?;
353 }
354 Ok(expr)
355 }
356
357 pub fn parse_assert(&mut self) -> Result<Statement, ParserError> {
358 let condition = self.parse_expr()?;
359 let message = if self.parse_keyword(Keyword::AS) {
360 Some(self.parse_expr()?)
361 } else {
362 None
363 };
364
365 Ok(Statement::Assert { condition, message })
366 }
367
368 pub fn parse_prefix(&mut self) -> Result<Expr, ParserError> {
370 return_ok_if_some!(self.maybe_parse(|parser| {
387 match parser.parse_data_type()? {
388 DataType::Interval => parser.parse_literal_interval(),
389 DataType::Custom(..) => parser_err!("dummy"),
397 data_type => Ok(Expr::TypedString {
398 data_type,
399 value: parser.parse_literal_string()?,
400 }),
401 }
402 }));
403
404 let expr = match self.next_token() {
405 Token::Word(w) => match w.keyword {
406 Keyword::TRUE | Keyword::FALSE | Keyword::NULL => {
407 self.prev_token();
408 Ok(Expr::Value(self.parse_value()?))
409 }
410 Keyword::CASE => self.parse_case_expr(),
411 Keyword::CAST => self.parse_cast_expr(),
412 Keyword::TRY_CAST => self.parse_try_cast_expr(),
413 Keyword::EXISTS => self.parse_exists_expr(),
414 Keyword::EXTRACT => self.parse_extract_expr(),
415 Keyword::SUBSTRING => self.parse_substring_expr(),
416 Keyword::TRIM => self.parse_trim_expr(),
417 Keyword::INTERVAL => self.parse_literal_interval(),
418 Keyword::LISTAGG => self.parse_listagg_expr(),
419 Keyword::NOT => Ok(Expr::UnaryOp {
420 op: UnaryOperator::Not,
421 expr: Box::new(self.parse_subexpr(Self::UNARY_NOT_PREC)?),
422 }),
423 _ => match self.peek_token() {
426 Token::LParen | Token::Period => {
427 let mut id_parts: Vec<Ident> = vec![w.to_ident()];
428 while self.consume_token(&Token::Period) {
429 match self.next_token() {
430 Token::Word(w) => id_parts.push(w.to_ident()),
431 unexpected => {
432 return self
433 .expected("an identifier or a '*' after '.'", unexpected);
434 }
435 }
436 }
437
438 if self.consume_token(&Token::LParen) {
439 self.prev_token();
440 self.parse_function(ObjectName(id_parts))
441 } else {
442 Ok(Expr::CompoundIdentifier(id_parts))
443 }
444 }
445 _ => Ok(Expr::Identifier(w.to_ident())),
446 },
447 }, tok @ Token::Minus | tok @ Token::Plus => {
449 let op = if tok == Token::Plus {
450 UnaryOperator::Plus
451 } else {
452 UnaryOperator::Minus
453 };
454 Ok(Expr::UnaryOp {
455 op,
456 expr: Box::new(self.parse_subexpr(Self::PLUS_MINUS_PREC)?),
457 })
458 }
459 tok @ Token::DoubleExclamationMark
460 | tok @ Token::PGSquareRoot
461 | tok @ Token::PGCubeRoot
462 | tok @ Token::AtSign
463 | tok @ Token::Tilde
464 if dialect_of!(self is PostgreSqlDialect) =>
465 {
466 let op = match tok {
467 Token::DoubleExclamationMark => UnaryOperator::PGPrefixFactorial,
468 Token::PGSquareRoot => UnaryOperator::PGSquareRoot,
469 Token::PGCubeRoot => UnaryOperator::PGCubeRoot,
470 Token::AtSign => UnaryOperator::PGAbs,
471 Token::Tilde => UnaryOperator::PGBitwiseNot,
472 _ => unreachable!(),
473 };
474 Ok(Expr::UnaryOp {
475 op,
476 expr: Box::new(self.parse_subexpr(Self::PLUS_MINUS_PREC)?),
477 })
478 }
479 Token::Number(_, _)
480 | Token::SingleQuotedString(_)
481 | Token::NationalStringLiteral(_)
482 | Token::HexStringLiteral(_) => {
483 self.prev_token();
484 Ok(Expr::Value(self.parse_value()?))
485 }
486
487 Token::LParen => {
488 let expr =
489 if self.parse_keyword(Keyword::SELECT) || self.parse_keyword(Keyword::WITH) {
490 self.prev_token();
491 Expr::Subquery(Box::new(self.parse_query()?))
492 } else {
493 Expr::Nested(Box::new(self.parse_expr()?))
494 };
495 self.expect_token(&Token::RParen)?;
496 Ok(expr)
497 }
498 Token::Placeholder(_) => {
499 self.prev_token();
500 Ok(Expr::Value(self.parse_value()?))
501 }
502 unexpected => self.expected("an expression:", unexpected),
503 }?;
504
505 if self.parse_keyword(Keyword::COLLATE) {
506 Ok(Expr::Collate {
507 expr: Box::new(expr),
508 collation: self.parse_object_name()?,
509 })
510 } else {
511 Ok(expr)
512 }
513 }
514
515 pub fn parse_function(&mut self, name: ObjectName) -> Result<Expr, ParserError> {
516 self.expect_token(&Token::LParen)?;
517 let distinct = self.parse_all_or_distinct()?;
518 let args = self.parse_optional_args()?;
519 let over = if self.parse_keyword(Keyword::OVER) {
520 self.expect_token(&Token::LParen)?;
522 let partition_by = if self.parse_keywords(&[Keyword::PARTITION, Keyword::BY]) {
523 self.parse_comma_separated(Parser::parse_expr)?
525 } else {
526 vec![]
527 };
528 let order_by = if self.parse_keywords(&[Keyword::ORDER, Keyword::BY]) {
529 self.parse_comma_separated(Parser::parse_order_by_expr)?
530 } else {
531 vec![]
532 };
533 let window_frame = if !self.consume_token(&Token::RParen) {
534 let window_frame = self.parse_window_frame()?;
535 self.expect_token(&Token::RParen)?;
536 Some(window_frame)
537 } else {
538 None
539 };
540
541 Some(WindowSpec {
542 partition_by,
543 order_by,
544 window_frame,
545 })
546 } else {
547 None
548 };
549
550 Ok(Expr::Function(Function {
551 name,
552 args,
553 over,
554 distinct,
555 }))
556 }
557
558 pub fn parse_window_frame_units(&mut self) -> Result<WindowFrameUnits, ParserError> {
559 match self.next_token() {
560 Token::Word(w) => match w.keyword {
561 Keyword::ROWS => Ok(WindowFrameUnits::Rows),
562 Keyword::RANGE => Ok(WindowFrameUnits::Range),
563 Keyword::GROUPS => Ok(WindowFrameUnits::Groups),
564 _ => self.expected("ROWS, RANGE, GROUPS", Token::Word(w))?,
565 },
566 unexpected => self.expected("ROWS, RANGE, GROUPS", unexpected),
567 }
568 }
569
570 pub fn parse_window_frame(&mut self) -> Result<WindowFrame, ParserError> {
571 let units = self.parse_window_frame_units()?;
572 let (start_bound, end_bound) = if self.parse_keyword(Keyword::BETWEEN) {
573 let start_bound = self.parse_window_frame_bound()?;
574 self.expect_keyword(Keyword::AND)?;
575 let end_bound = Some(self.parse_window_frame_bound()?);
576 (start_bound, end_bound)
577 } else {
578 (self.parse_window_frame_bound()?, None)
579 };
580 Ok(WindowFrame {
581 units,
582 start_bound,
583 end_bound,
584 })
585 }
586
587 pub fn parse_window_frame_bound(&mut self) -> Result<WindowFrameBound, ParserError> {
589 if self.parse_keywords(&[Keyword::CURRENT, Keyword::ROW]) {
590 Ok(WindowFrameBound::CurrentRow)
591 } else {
592 let rows = if self.parse_keyword(Keyword::UNBOUNDED) {
593 None
594 } else {
595 Some(self.parse_literal_uint()?)
596 };
597 if self.parse_keyword(Keyword::PRECEDING) {
598 Ok(WindowFrameBound::Preceding(rows))
599 } else if self.parse_keyword(Keyword::FOLLOWING) {
600 Ok(WindowFrameBound::Following(rows))
601 } else {
602 self.expected("PRECEDING or FOLLOWING", self.peek_token())
603 }
604 }
605 }
606
607 fn parse_group_by_expr(&mut self) -> Result<Expr, ParserError> {
610 if dialect_of!(self is PostgreSqlDialect) {
611 if self.parse_keywords(&[Keyword::GROUPING, Keyword::SETS]) {
612 self.expect_token(&Token::LParen)?;
613 let result = self.parse_comma_separated(|p| p.parse_tuple(false, true))?;
614 self.expect_token(&Token::RParen)?;
615 Ok(Expr::GroupingSets(result))
616 } else if self.parse_keyword(Keyword::CUBE) {
617 self.expect_token(&Token::LParen)?;
618 let result = self.parse_comma_separated(|p| p.parse_tuple(true, true))?;
619 self.expect_token(&Token::RParen)?;
620 Ok(Expr::Cube(result))
621 } else if self.parse_keyword(Keyword::ROLLUP) {
622 self.expect_token(&Token::LParen)?;
623 let result = self.parse_comma_separated(|p| p.parse_tuple(true, true))?;
624 self.expect_token(&Token::RParen)?;
625 Ok(Expr::Rollup(result))
626 } else {
627 self.parse_expr()
628 }
629 } else {
630 self.parse_expr()
632 }
633 }
634
635 fn parse_tuple(
639 &mut self,
640 lift_singleton: bool,
641 allow_empty: bool,
642 ) -> Result<Vec<Expr>, ParserError> {
643 if lift_singleton {
644 if self.consume_token(&Token::LParen) {
645 let result = if allow_empty && self.consume_token(&Token::RParen) {
646 vec![]
647 } else {
648 let result = self.parse_comma_separated(Parser::parse_expr)?;
649 self.expect_token(&Token::RParen)?;
650 result
651 };
652 Ok(result)
653 } else {
654 Ok(vec![self.parse_expr()?])
655 }
656 } else {
657 self.expect_token(&Token::LParen)?;
658 let result = if allow_empty && self.consume_token(&Token::RParen) {
659 vec![]
660 } else {
661 let result = self.parse_comma_separated(Parser::parse_expr)?;
662 self.expect_token(&Token::RParen)?;
663 result
664 };
665 Ok(result)
666 }
667 }
668
669 pub fn parse_case_expr(&mut self) -> Result<Expr, ParserError> {
670 let mut operand = None;
671 if !self.parse_keyword(Keyword::WHEN) {
672 operand = Some(Box::new(self.parse_expr()?));
673 self.expect_keyword(Keyword::WHEN)?;
674 }
675 let mut conditions = vec![];
676 let mut results = vec![];
677 loop {
678 conditions.push(self.parse_expr()?);
679 self.expect_keyword(Keyword::THEN)?;
680 results.push(self.parse_expr()?);
681 if !self.parse_keyword(Keyword::WHEN) {
682 break;
683 }
684 }
685 let else_result = if self.parse_keyword(Keyword::ELSE) {
686 Some(Box::new(self.parse_expr()?))
687 } else {
688 None
689 };
690 self.expect_keyword(Keyword::END)?;
691 Ok(Expr::Case {
692 operand,
693 conditions,
694 results,
695 else_result,
696 })
697 }
698
699 pub fn parse_cast_expr(&mut self) -> Result<Expr, ParserError> {
701 self.expect_token(&Token::LParen)?;
702 let expr = self.parse_expr()?;
703 self.expect_keyword(Keyword::AS)?;
704 let data_type = self.parse_data_type()?;
705 self.expect_token(&Token::RParen)?;
706 Ok(Expr::Cast {
707 expr: Box::new(expr),
708 data_type,
709 })
710 }
711
712 pub fn parse_try_cast_expr(&mut self) -> Result<Expr, ParserError> {
714 self.expect_token(&Token::LParen)?;
715 let expr = self.parse_expr()?;
716 self.expect_keyword(Keyword::AS)?;
717 let data_type = self.parse_data_type()?;
718 self.expect_token(&Token::RParen)?;
719 Ok(Expr::TryCast {
720 expr: Box::new(expr),
721 data_type,
722 })
723 }
724
725 pub fn parse_exists_expr(&mut self) -> Result<Expr, ParserError> {
727 self.expect_token(&Token::LParen)?;
728 let exists_node = Expr::Exists(Box::new(self.parse_query()?));
729 self.expect_token(&Token::RParen)?;
730 Ok(exists_node)
731 }
732
733 pub fn parse_extract_expr(&mut self) -> Result<Expr, ParserError> {
734 self.expect_token(&Token::LParen)?;
735 let field = self.parse_date_time_field()?;
736 self.expect_keyword(Keyword::FROM)?;
737 let expr = self.parse_expr()?;
738 self.expect_token(&Token::RParen)?;
739 Ok(Expr::Extract {
740 field,
741 expr: Box::new(expr),
742 })
743 }
744
745 pub fn parse_substring_expr(&mut self) -> Result<Expr, ParserError> {
746 self.expect_token(&Token::LParen)?;
748 let expr = self.parse_expr()?;
749 let mut from_expr = None;
750 if self.parse_keyword(Keyword::FROM) || self.consume_token(&Token::Comma) {
751 from_expr = Some(self.parse_expr()?);
752 }
753
754 let mut to_expr = None;
755 if self.parse_keyword(Keyword::FOR) || self.consume_token(&Token::Comma) {
756 to_expr = Some(self.parse_expr()?);
757 }
758 self.expect_token(&Token::RParen)?;
759
760 Ok(Expr::Substring {
761 expr: Box::new(expr),
762 substring_from: from_expr.map(Box::new),
763 substring_for: to_expr.map(Box::new),
764 })
765 }
766
767 pub fn parse_trim_expr(&mut self) -> Result<Expr, ParserError> {
770 self.expect_token(&Token::LParen)?;
771 let mut where_expr = None;
772 if let Token::Word(word) = self.peek_token() {
773 if [Keyword::BOTH, Keyword::LEADING, Keyword::TRAILING]
774 .iter()
775 .any(|d| word.keyword == *d)
776 {
777 let trim_where = self.parse_trim_where()?;
778 let sub_expr = self.parse_expr()?;
779 self.expect_keyword(Keyword::FROM)?;
780 where_expr = Some((trim_where, Box::new(sub_expr)));
781 }
782 }
783 let expr = self.parse_expr()?;
784 self.expect_token(&Token::RParen)?;
785
786 Ok(Expr::Trim {
787 expr: Box::new(expr),
788 trim_where: where_expr,
789 })
790 }
791
792 pub fn parse_trim_where(&mut self) -> Result<TrimWhereField, ParserError> {
793 match self.next_token() {
794 Token::Word(w) => match w.keyword {
795 Keyword::BOTH => Ok(TrimWhereField::Both),
796 Keyword::LEADING => Ok(TrimWhereField::Leading),
797 Keyword::TRAILING => Ok(TrimWhereField::Trailing),
798 _ => self.expected("trim_where field", Token::Word(w))?,
799 },
800 unexpected => self.expected("trim_where field", unexpected),
801 }
802 }
803
804 pub fn parse_listagg_expr(&mut self) -> Result<Expr, ParserError> {
806 self.expect_token(&Token::LParen)?;
807 let distinct = self.parse_all_or_distinct()?;
808 let expr = Box::new(self.parse_expr()?);
809 let separator = if self.consume_token(&Token::Comma) {
812 Some(Box::new(self.parse_expr()?))
813 } else {
814 None
815 };
816 let on_overflow = if self.parse_keywords(&[Keyword::ON, Keyword::OVERFLOW]) {
817 if self.parse_keyword(Keyword::ERROR) {
818 Some(ListAggOnOverflow::Error)
819 } else {
820 self.expect_keyword(Keyword::TRUNCATE)?;
821 let filler = match self.peek_token() {
822 Token::Word(w)
823 if w.keyword == Keyword::WITH || w.keyword == Keyword::WITHOUT =>
824 {
825 None
826 }
827 Token::SingleQuotedString(_)
828 | Token::NationalStringLiteral(_)
829 | Token::HexStringLiteral(_) => Some(Box::new(self.parse_expr()?)),
830 unexpected => {
831 self.expected("either filler, WITH, or WITHOUT in LISTAGG", unexpected)?
832 }
833 };
834 let with_count = self.parse_keyword(Keyword::WITH);
835 if !with_count && !self.parse_keyword(Keyword::WITHOUT) {
836 self.expected("either WITH or WITHOUT in LISTAGG", self.peek_token())?;
837 }
838 self.expect_keyword(Keyword::COUNT)?;
839 Some(ListAggOnOverflow::Truncate { filler, with_count })
840 }
841 } else {
842 None
843 };
844 self.expect_token(&Token::RParen)?;
845 let within_group = if self.parse_keywords(&[Keyword::WITHIN, Keyword::GROUP]) {
848 self.expect_token(&Token::LParen)?;
849 self.expect_keywords(&[Keyword::ORDER, Keyword::BY])?;
850 let order_by_expr = self.parse_comma_separated(Parser::parse_order_by_expr)?;
851 self.expect_token(&Token::RParen)?;
852 order_by_expr
853 } else {
854 vec![]
855 };
856 Ok(Expr::ListAgg(ListAgg {
857 distinct,
858 expr,
859 separator,
860 on_overflow,
861 within_group,
862 }))
863 }
864
865 pub fn parse_date_time_field(&mut self) -> Result<DateTimeField, ParserError> {
870 match self.next_token() {
871 Token::Word(w) => match w.keyword {
872 Keyword::YEAR => Ok(DateTimeField::Year),
873 Keyword::MONTH => Ok(DateTimeField::Month),
874 Keyword::DAY => Ok(DateTimeField::Day),
875 Keyword::HOUR => Ok(DateTimeField::Hour),
876 Keyword::MINUTE => Ok(DateTimeField::Minute),
877 Keyword::SECOND => Ok(DateTimeField::Second),
878 _ => self.expected("date/time field", Token::Word(w))?,
879 },
880 unexpected => self.expected("date/time field", unexpected),
881 }
882 }
883
884 pub fn parse_literal_interval(&mut self) -> Result<Expr, ParserError> {
897 let value = self.parse_literal_string()?;
905
906 let leading_field = match self.peek_token() {
912 Token::Word(kw)
913 if [
914 Keyword::YEAR,
915 Keyword::MONTH,
916 Keyword::DAY,
917 Keyword::HOUR,
918 Keyword::MINUTE,
919 Keyword::SECOND,
920 ]
921 .iter()
922 .any(|d| kw.keyword == *d) =>
923 {
924 Some(self.parse_date_time_field()?)
925 }
926 _ => None,
927 };
928
929 let (leading_precision, last_field, fsec_precision) =
930 if leading_field == Some(DateTimeField::Second) {
931 let last_field = None;
937 let (leading_precision, fsec_precision) = self.parse_optional_precision_scale()?;
938 (leading_precision, last_field, fsec_precision)
939 } else {
940 let leading_precision = self.parse_optional_precision()?;
941 if self.parse_keyword(Keyword::TO) {
942 let last_field = Some(self.parse_date_time_field()?);
943 let fsec_precision = if last_field == Some(DateTimeField::Second) {
944 self.parse_optional_precision()?
945 } else {
946 None
947 };
948 (leading_precision, last_field, fsec_precision)
949 } else {
950 (leading_precision, None, None)
951 }
952 };
953
954 Ok(Expr::Value(Value::Interval {
955 value,
956 leading_field,
957 leading_precision,
958 last_field,
959 fractional_seconds_precision: fsec_precision,
960 }))
961 }
962
963 pub fn parse_infix(&mut self, expr: Expr, precedence: u8) -> Result<Expr, ParserError> {
965 let tok = self.next_token();
966 let regular_binary_operator = match &tok {
967 Token::Spaceship => Some(BinaryOperator::Spaceship),
968 Token::DoubleEq => Some(BinaryOperator::Eq),
969 Token::Eq => Some(BinaryOperator::Eq),
970 Token::Neq => Some(BinaryOperator::NotEq),
971 Token::Gt => Some(BinaryOperator::Gt),
972 Token::GtEq => Some(BinaryOperator::GtEq),
973 Token::Lt => Some(BinaryOperator::Lt),
974 Token::LtEq => Some(BinaryOperator::LtEq),
975 Token::Plus => Some(BinaryOperator::Plus),
976 Token::Minus => Some(BinaryOperator::Minus),
977 Token::Mul => Some(BinaryOperator::Multiply),
978 Token::Mod => Some(BinaryOperator::Modulo),
979 Token::StringConcat => Some(BinaryOperator::StringConcat),
980 Token::Pipe => Some(BinaryOperator::BitwiseOr),
981 Token::Caret => Some(BinaryOperator::BitwiseXor),
982 Token::Ampersand => Some(BinaryOperator::BitwiseAnd),
983 Token::Div => Some(BinaryOperator::Divide),
984 Token::ShiftLeft if dialect_of!(self is PostgreSqlDialect) => {
985 Some(BinaryOperator::PGBitwiseShiftLeft)
986 }
987 Token::ShiftRight if dialect_of!(self is PostgreSqlDialect) => {
988 Some(BinaryOperator::PGBitwiseShiftRight)
989 }
990 Token::Sharp if dialect_of!(self is PostgreSqlDialect) => {
991 Some(BinaryOperator::PGBitwiseXor)
992 }
993 Token::Tilde => Some(BinaryOperator::PGRegexMatch),
994 Token::TildeAsterisk => Some(BinaryOperator::PGRegexIMatch),
995 Token::ExclamationMarkTilde => Some(BinaryOperator::PGRegexNotMatch),
996 Token::ExclamationMarkTildeAsterisk => Some(BinaryOperator::PGRegexNotIMatch),
997 Token::Word(w) => match w.keyword {
998 Keyword::AND => Some(BinaryOperator::And),
999 Keyword::OR => Some(BinaryOperator::Or),
1000 Keyword::LIKE => Some(BinaryOperator::Like),
1001 Keyword::ILIKE => Some(BinaryOperator::ILike),
1002 Keyword::NOT => {
1003 if self.parse_keyword(Keyword::LIKE) {
1004 Some(BinaryOperator::NotLike)
1005 } else if self.parse_keyword(Keyword::ILIKE) {
1006 Some(BinaryOperator::NotILike)
1007 } else {
1008 None
1009 }
1010 }
1011 Keyword::XOR => Some(BinaryOperator::Xor),
1012 _ => None,
1013 },
1014 _ => None,
1015 };
1016
1017 if let Some(op) = regular_binary_operator {
1018 Ok(Expr::BinaryOp {
1019 left: Box::new(expr),
1020 op,
1021 right: Box::new(self.parse_subexpr(precedence)?),
1022 })
1023 } else if let Token::Word(w) = &tok {
1024 match w.keyword {
1025 Keyword::IS => {
1026 if self.parse_keyword(Keyword::NULL) {
1027 Ok(Expr::IsNull(Box::new(expr)))
1028 } else if self.parse_keywords(&[Keyword::NOT, Keyword::NULL]) {
1029 Ok(Expr::IsNotNull(Box::new(expr)))
1030 } else if self.parse_keywords(&[Keyword::DISTINCT, Keyword::FROM]) {
1031 let expr2 = self.parse_expr()?;
1032 Ok(Expr::IsDistinctFrom(Box::new(expr), Box::new(expr2)))
1033 } else if self.parse_keywords(&[Keyword::NOT, Keyword::DISTINCT, Keyword::FROM])
1034 {
1035 let expr2 = self.parse_expr()?;
1036 Ok(Expr::IsNotDistinctFrom(Box::new(expr), Box::new(expr2)))
1037 } else {
1038 self.expected(
1039 "[NOT] NULL or [NOT] DISTINCT FROM after IS",
1040 self.peek_token(),
1041 )
1042 }
1043 }
1044 Keyword::NOT | Keyword::IN | Keyword::BETWEEN => {
1045 self.prev_token();
1046 let negated = self.parse_keyword(Keyword::NOT);
1047 if self.parse_keyword(Keyword::IN) {
1048 self.parse_in(expr, negated)
1049 } else if self.parse_keyword(Keyword::BETWEEN) {
1050 self.parse_between(expr, negated)
1051 } else {
1052 self.expected("IN or BETWEEN after NOT", self.peek_token())
1053 }
1054 }
1055 _ => parser_err!(format!("No infix parser for token {:?}", tok)),
1057 }
1058 } else if Token::DoubleColon == tok {
1059 self.parse_pg_cast(expr)
1060 } else if Token::ExclamationMark == tok {
1061 Ok(Expr::UnaryOp {
1063 op: UnaryOperator::PGPostfixFactorial,
1064 expr: Box::new(expr),
1065 })
1066 } else if Token::LBracket == tok {
1067 self.parse_map_access(expr)
1068 } else {
1069 parser_err!(format!("No infix parser for token {:?}", tok))
1071 }
1072 }
1073
1074 pub fn parse_map_access(&mut self, expr: Expr) -> Result<Expr, ParserError> {
1075 let key = self.parse_map_key()?;
1076 let tok = self.consume_token(&Token::RBracket);
1077 debug!("Tok: {}", tok);
1078 let mut key_parts: Vec<Expr> = vec![key];
1079 while self.consume_token(&Token::LBracket) {
1080 let key = self.parse_map_key()?;
1081 let tok = self.consume_token(&Token::RBracket);
1082 debug!("Tok: {}", tok);
1083 key_parts.push(key);
1084 }
1085 match expr {
1086 e @ Expr::Identifier(_) | e @ Expr::CompoundIdentifier(_) => Ok(Expr::MapAccess {
1087 column: Box::new(e),
1088 keys: key_parts,
1089 }),
1090 _ => Ok(expr),
1091 }
1092 }
1093
1094 pub fn parse_in(&mut self, expr: Expr, negated: bool) -> Result<Expr, ParserError> {
1096 self.expect_token(&Token::LParen)?;
1097 let in_op = if self.parse_keyword(Keyword::SELECT) || self.parse_keyword(Keyword::WITH) {
1098 self.prev_token();
1099 Expr::InSubquery {
1100 expr: Box::new(expr),
1101 subquery: Box::new(self.parse_query()?),
1102 negated,
1103 }
1104 } else {
1105 Expr::InList {
1106 expr: Box::new(expr),
1107 list: self.parse_comma_separated(Parser::parse_expr)?,
1108 negated,
1109 }
1110 };
1111 self.expect_token(&Token::RParen)?;
1112 Ok(in_op)
1113 }
1114
1115 pub fn parse_between(&mut self, expr: Expr, negated: bool) -> Result<Expr, ParserError> {
1117 let low = self.parse_subexpr(Self::BETWEEN_PREC)?;
1120 self.expect_keyword(Keyword::AND)?;
1121 let high = self.parse_subexpr(Self::BETWEEN_PREC)?;
1122 Ok(Expr::Between {
1123 expr: Box::new(expr),
1124 negated,
1125 low: Box::new(low),
1126 high: Box::new(high),
1127 })
1128 }
1129
1130 pub fn parse_pg_cast(&mut self, expr: Expr) -> Result<Expr, ParserError> {
1132 Ok(Expr::Cast {
1133 expr: Box::new(expr),
1134 data_type: self.parse_data_type()?,
1135 })
1136 }
1137
1138 const UNARY_NOT_PREC: u8 = 15;
1139 const BETWEEN_PREC: u8 = 20;
1140 const PLUS_MINUS_PREC: u8 = 30;
1141
1142 pub fn get_next_precedence(&self) -> Result<u8, ParserError> {
1144 let token = self.peek_token();
1145 debug!("get_next_precedence() {:?}", token);
1146 match token {
1147 Token::Word(w) if w.keyword == Keyword::OR => Ok(5),
1148 Token::Word(w) if w.keyword == Keyword::AND => Ok(10),
1149 Token::Word(w) if w.keyword == Keyword::XOR => Ok(24),
1150 Token::Word(w) if w.keyword == Keyword::NOT => match self.peek_nth_token(1) {
1151 Token::Word(w) if w.keyword == Keyword::IN => Ok(Self::BETWEEN_PREC),
1157 Token::Word(w) if w.keyword == Keyword::BETWEEN => Ok(Self::BETWEEN_PREC),
1158 Token::Word(w) if w.keyword == Keyword::LIKE => Ok(Self::BETWEEN_PREC),
1159 Token::Word(w) if w.keyword == Keyword::ILIKE => Ok(Self::BETWEEN_PREC),
1160 _ => Ok(0),
1161 },
1162 Token::Word(w) if w.keyword == Keyword::IS => Ok(17),
1163 Token::Word(w) if w.keyword == Keyword::IN => Ok(Self::BETWEEN_PREC),
1164 Token::Word(w) if w.keyword == Keyword::BETWEEN => Ok(Self::BETWEEN_PREC),
1165 Token::Word(w) if w.keyword == Keyword::LIKE => Ok(Self::BETWEEN_PREC),
1166 Token::Word(w) if w.keyword == Keyword::ILIKE => Ok(Self::BETWEEN_PREC),
1167 Token::Eq
1168 | Token::Lt
1169 | Token::LtEq
1170 | Token::Neq
1171 | Token::Gt
1172 | Token::GtEq
1173 | Token::DoubleEq
1174 | Token::Tilde
1175 | Token::TildeAsterisk
1176 | Token::ExclamationMarkTilde
1177 | Token::ExclamationMarkTildeAsterisk
1178 | Token::Spaceship => Ok(20),
1179 Token::Pipe => Ok(21),
1180 Token::Caret | Token::Sharp | Token::ShiftRight | Token::ShiftLeft => Ok(22),
1181 Token::Ampersand => Ok(23),
1182 Token::Plus | Token::Minus => Ok(Self::PLUS_MINUS_PREC),
1183 Token::Mul | Token::Div | Token::Mod | Token::StringConcat => Ok(40),
1184 Token::DoubleColon => Ok(50),
1185 Token::ExclamationMark => Ok(50),
1186 Token::LBracket | Token::RBracket => Ok(10),
1187 _ => Ok(0),
1188 }
1189 }
1190
1191 pub fn peek_token(&self) -> Token {
1194 self.peek_nth_token(0)
1195 }
1196
1197 pub fn peek_nth_token(&self, mut n: usize) -> Token {
1199 let mut index = self.index;
1200 loop {
1201 index += 1;
1202 match self.tokens.get(index - 1) {
1203 Some(Token::Whitespace(_)) => continue,
1204 non_whitespace => {
1205 if n == 0 {
1206 return non_whitespace.cloned().unwrap_or(Token::EOF);
1207 }
1208 n -= 1;
1209 }
1210 }
1211 }
1212 }
1213
1214 pub fn next_token(&mut self) -> Token {
1218 loop {
1219 self.index += 1;
1220 match self.tokens.get(self.index - 1) {
1221 Some(Token::Whitespace(_)) => continue,
1222 token => return token.cloned().unwrap_or(Token::EOF),
1223 }
1224 }
1225 }
1226
1227 pub fn next_token_no_skip(&mut self) -> Option<&Token> {
1229 self.index += 1;
1230 self.tokens.get(self.index - 1)
1231 }
1232
1233 pub fn prev_token(&mut self) {
1237 loop {
1238 assert!(self.index > 0);
1239 self.index -= 1;
1240 if let Some(Token::Whitespace(_)) = self.tokens.get(self.index) {
1241 continue;
1242 }
1243 return;
1244 }
1245 }
1246
1247 fn expected<T>(&self, expected: &str, found: Token) -> Result<T, ParserError> {
1249 parser_err!(format!("Expected {}, found: {}", expected, found))
1250 }
1251
1252 #[must_use]
1254 pub fn parse_keyword(&mut self, expected: Keyword) -> bool {
1255 match self.peek_token() {
1256 Token::Word(w) if expected == w.keyword => {
1257 self.next_token();
1258 true
1259 }
1260 _ => false,
1261 }
1262 }
1263
1264 #[must_use]
1266 pub fn parse_keywords(&mut self, keywords: &[Keyword]) -> bool {
1267 let index = self.index;
1268 for &keyword in keywords {
1269 if !self.parse_keyword(keyword) {
1270 self.index = index;
1273 return false;
1274 }
1275 }
1276 true
1277 }
1278
1279 #[must_use]
1281 pub fn parse_one_of_keywords(&mut self, keywords: &[Keyword]) -> Option<Keyword> {
1282 match self.peek_token() {
1283 Token::Word(w) => {
1284 keywords
1285 .iter()
1286 .find(|keyword| **keyword == w.keyword)
1287 .map(|keyword| {
1288 self.next_token();
1289 *keyword
1290 })
1291 }
1292 _ => None,
1293 }
1294 }
1295
1296 pub fn expect_one_of_keywords(&mut self, keywords: &[Keyword]) -> Result<Keyword, ParserError> {
1298 if let Some(keyword) = self.parse_one_of_keywords(keywords) {
1299 Ok(keyword)
1300 } else {
1301 let keywords: Vec<String> = keywords.iter().map(|x| format!("{:?}", x)).collect();
1302 self.expected(
1303 &format!("one of {}", keywords.join(" or ")),
1304 self.peek_token(),
1305 )
1306 }
1307 }
1308
1309 pub fn expect_keyword(&mut self, expected: Keyword) -> Result<(), ParserError> {
1311 if self.parse_keyword(expected) {
1312 Ok(())
1313 } else {
1314 self.expected(format!("{:?}", &expected).as_str(), self.peek_token())
1315 }
1316 }
1317
1318 pub fn expect_keywords(&mut self, expected: &[Keyword]) -> Result<(), ParserError> {
1321 for &kw in expected {
1322 self.expect_keyword(kw)?;
1323 }
1324 Ok(())
1325 }
1326
1327 #[must_use]
1329 pub fn consume_token(&mut self, expected: &Token) -> bool {
1330 if self.peek_token() == *expected {
1331 self.next_token();
1332 true
1333 } else {
1334 false
1335 }
1336 }
1337
1338 pub fn expect_token(&mut self, expected: &Token) -> Result<(), ParserError> {
1340 if self.consume_token(expected) {
1341 Ok(())
1342 } else {
1343 self.expected(&expected.to_string(), self.peek_token())
1344 }
1345 }
1346
1347 pub fn parse_comma_separated<T, F>(&mut self, mut f: F) -> Result<Vec<T>, ParserError>
1349 where
1350 F: FnMut(&mut Parser<'a>) -> Result<T, ParserError>,
1351 {
1352 let mut values = vec![];
1353 loop {
1354 values.push(f(self)?);
1355 if !self.consume_token(&Token::Comma) {
1356 break;
1357 }
1358 }
1359 Ok(values)
1360 }
1361
1362 #[must_use]
1365 fn maybe_parse<T, F>(&mut self, mut f: F) -> Option<T>
1366 where
1367 F: FnMut(&mut Parser) -> Result<T, ParserError>,
1368 {
1369 let index = self.index;
1370 if let Ok(t) = f(self) {
1371 Some(t)
1372 } else {
1373 self.index = index;
1374 None
1375 }
1376 }
1377
1378 pub fn parse_all_or_distinct(&mut self) -> Result<bool, ParserError> {
1381 let all = self.parse_keyword(Keyword::ALL);
1382 let distinct = self.parse_keyword(Keyword::DISTINCT);
1383 if all && distinct {
1384 return parser_err!("Cannot specify both ALL and DISTINCT".to_string());
1385 } else {
1386 Ok(distinct)
1387 }
1388 }
1389
1390 pub fn parse_create(&mut self) -> Result<Statement, ParserError> {
1392 let or_replace = self.parse_keywords(&[Keyword::OR, Keyword::REPLACE]);
1393 let temporary = self
1394 .parse_one_of_keywords(&[Keyword::TEMP, Keyword::TEMPORARY])
1395 .is_some();
1396 if self.parse_keyword(Keyword::TABLE) {
1397 self.parse_create_table(or_replace, temporary)
1398 } else if self.parse_keyword(Keyword::MATERIALIZED) || self.parse_keyword(Keyword::VIEW) {
1399 self.prev_token();
1400 self.parse_create_view(or_replace)
1401 } else if self.parse_keyword(Keyword::EXTERNAL) {
1402 self.parse_create_external_table(or_replace)
1403 } else if or_replace {
1404 self.expected(
1405 "[EXTERNAL] TABLE or [MATERIALIZED] VIEW after CREATE OR REPLACE",
1406 self.peek_token(),
1407 )
1408 } else if self.parse_keyword(Keyword::INDEX) {
1409 self.parse_create_index(false)
1410 } else if self.parse_keywords(&[Keyword::UNIQUE, Keyword::INDEX]) {
1411 self.parse_create_index(true)
1412 } else if self.parse_keyword(Keyword::VIRTUAL) {
1413 self.parse_create_virtual_table()
1414 } else if self.parse_keyword(Keyword::SCHEMA) {
1415 self.parse_create_schema()
1416 } else {
1417 self.expected("an object type after CREATE", self.peek_token())
1418 }
1419 }
1420
1421 pub fn parse_create_virtual_table(&mut self) -> Result<Statement, ParserError> {
1423 self.expect_keyword(Keyword::TABLE)?;
1424 let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]);
1425 let table_name = self.parse_object_name()?;
1426 self.expect_keyword(Keyword::USING)?;
1427 let module_name = self.parse_identifier()?;
1428 let module_args = self.parse_parenthesized_column_list(Optional)?;
1433 Ok(Statement::CreateVirtualTable {
1434 name: table_name,
1435 if_not_exists,
1436 module_name,
1437 module_args,
1438 })
1439 }
1440
1441 pub fn parse_create_schema(&mut self) -> Result<Statement, ParserError> {
1442 let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]);
1443 let schema_name = self.parse_object_name()?;
1444 Ok(Statement::CreateSchema {
1445 schema_name,
1446 if_not_exists,
1447 })
1448 }
1449
1450 pub fn parse_create_database(&mut self) -> Result<Statement, ParserError> {
1451 let ine = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]);
1452 let db_name = self.parse_object_name()?;
1453 let mut location = None;
1454 let mut managed_location = None;
1455 loop {
1456 match self.parse_one_of_keywords(&[Keyword::LOCATION, Keyword::MANAGEDLOCATION]) {
1457 Some(Keyword::LOCATION) => location = Some(self.parse_literal_string()?),
1458 Some(Keyword::MANAGEDLOCATION) => {
1459 managed_location = Some(self.parse_literal_string()?)
1460 }
1461 _ => break,
1462 }
1463 }
1464 Ok(Statement::CreateDatabase {
1465 db_name,
1466 if_not_exists: ine,
1467 location,
1468 managed_location,
1469 })
1470 }
1471
1472 pub fn parse_create_external_table(
1473 &mut self,
1474 or_replace: bool,
1475 ) -> Result<Statement, ParserError> {
1476 self.expect_keyword(Keyword::TABLE)?;
1477 let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]);
1478 let table_name = self.parse_object_name()?;
1479 let (columns, constraints) = self.parse_columns()?;
1480
1481 let hive_distribution = self.parse_hive_distribution()?;
1482 let hive_formats = self.parse_hive_formats()?;
1483
1484 let file_format = if let Some(ff) = &hive_formats.storage {
1485 match ff {
1486 HiveIOFormat::FileFormat { format } => Some(format.clone()),
1487 _ => None,
1488 }
1489 } else {
1490 None
1491 };
1492 let location = hive_formats.location.clone();
1493 let table_properties = self.parse_options(Keyword::TBLPROPERTIES)?;
1494 Ok(Statement::CreateTable {
1495 name: table_name,
1496 columns,
1497 constraints,
1498 hive_distribution,
1499 hive_formats: Some(hive_formats),
1500 with_options: vec![],
1501 table_properties,
1502 or_replace,
1503 if_not_exists,
1504 external: true,
1505 temporary: false,
1506 file_format,
1507 location,
1508 query: None,
1509 without_rowid: false,
1510 like: None,
1511 })
1512 }
1513
1514 pub fn parse_file_format(&mut self) -> Result<FileFormat, ParserError> {
1515 match self.next_token() {
1516 Token::Word(w) => match w.keyword {
1517 Keyword::AVRO => Ok(FileFormat::AVRO),
1518 Keyword::JSONFILE => Ok(FileFormat::JSONFILE),
1519 Keyword::ORC => Ok(FileFormat::ORC),
1520 Keyword::PARQUET => Ok(FileFormat::PARQUET),
1521 Keyword::RCFILE => Ok(FileFormat::RCFILE),
1522 Keyword::SEQUENCEFILE => Ok(FileFormat::SEQUENCEFILE),
1523 Keyword::TEXTFILE => Ok(FileFormat::TEXTFILE),
1524 _ => self.expected("fileformat", Token::Word(w)),
1525 },
1526 unexpected => self.expected("fileformat", unexpected),
1527 }
1528 }
1529
1530 pub fn parse_create_view(&mut self, or_replace: bool) -> Result<Statement, ParserError> {
1531 let materialized = self.parse_keyword(Keyword::MATERIALIZED);
1532 self.expect_keyword(Keyword::VIEW)?;
1533 let name = self.parse_object_name()?;
1536 let columns = self.parse_parenthesized_column_list(Optional)?;
1537 let with_options = self.parse_options(Keyword::WITH)?;
1538 self.expect_keyword(Keyword::AS)?;
1539 let query = Box::new(self.parse_query()?);
1540 Ok(Statement::CreateView {
1542 name,
1543 columns,
1544 query,
1545 materialized,
1546 or_replace,
1547 with_options,
1548 })
1549 }
1550
1551 pub fn parse_drop(&mut self) -> Result<Statement, ParserError> {
1552 let object_type = if self.parse_keyword(Keyword::TABLE) {
1553 ObjectType::Table
1554 } else if self.parse_keyword(Keyword::VIEW) {
1555 ObjectType::View
1556 } else if self.parse_keyword(Keyword::INDEX) {
1557 ObjectType::Index
1558 } else if self.parse_keyword(Keyword::SCHEMA) {
1559 ObjectType::Schema
1560 } else {
1561 return self.expected("TABLE, VIEW, INDEX or SCHEMA after DROP", self.peek_token());
1562 };
1563 let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]);
1566 let names = self.parse_comma_separated(Parser::parse_object_name)?;
1567 let cascade = self.parse_keyword(Keyword::CASCADE);
1568 let restrict = self.parse_keyword(Keyword::RESTRICT);
1569 let purge = self.parse_keyword(Keyword::PURGE);
1570 if cascade && restrict {
1571 return parser_err!("Cannot specify both CASCADE and RESTRICT in DROP");
1572 }
1573 Ok(Statement::Drop {
1574 object_type,
1575 if_exists,
1576 names,
1577 cascade,
1578 purge,
1579 })
1580 }
1581
1582 pub fn parse_create_index(&mut self, unique: bool) -> Result<Statement, ParserError> {
1583 let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]);
1584 let index_name = self.parse_object_name()?;
1585 self.expect_keyword(Keyword::ON)?;
1586 let table_name = self.parse_object_name()?;
1587 self.expect_token(&Token::LParen)?;
1588 let columns = self.parse_comma_separated(Parser::parse_order_by_expr)?;
1589 self.expect_token(&Token::RParen)?;
1590 Ok(Statement::CreateIndex {
1591 name: index_name,
1592 table_name,
1593 columns,
1594 unique,
1595 if_not_exists,
1596 })
1597 }
1598
1599 pub fn parse_hive_distribution(&mut self) -> Result<HiveDistributionStyle, ParserError> {
1601 if self.parse_keywords(&[Keyword::PARTITIONED, Keyword::BY]) {
1602 self.expect_token(&Token::LParen)?;
1603 let columns = self.parse_comma_separated(Parser::parse_column_def)?;
1604 self.expect_token(&Token::RParen)?;
1605 Ok(HiveDistributionStyle::PARTITIONED { columns })
1606 } else {
1607 Ok(HiveDistributionStyle::NONE)
1608 }
1609 }
1610
1611 pub fn parse_hive_formats(&mut self) -> Result<HiveFormat, ParserError> {
1612 let mut hive_format = HiveFormat::default();
1613 loop {
1614 match self.parse_one_of_keywords(&[Keyword::ROW, Keyword::STORED, Keyword::LOCATION]) {
1615 Some(Keyword::ROW) => {
1616 hive_format.row_format = Some(self.parse_row_format()?);
1617 }
1618 Some(Keyword::STORED) => {
1619 self.expect_keyword(Keyword::AS)?;
1620 if self.parse_keyword(Keyword::INPUTFORMAT) {
1621 let input_format = self.parse_expr()?;
1622 self.expect_keyword(Keyword::OUTPUTFORMAT)?;
1623 let output_format = self.parse_expr()?;
1624 hive_format.storage = Some(HiveIOFormat::IOF {
1625 input_format,
1626 output_format,
1627 });
1628 } else {
1629 let format = self.parse_file_format()?;
1630 hive_format.storage = Some(HiveIOFormat::FileFormat { format });
1631 }
1632 }
1633 Some(Keyword::LOCATION) => {
1634 hive_format.location = Some(self.parse_literal_string()?);
1635 }
1636 None => break,
1637 _ => break,
1638 }
1639 }
1640
1641 Ok(hive_format)
1642 }
1643
1644 pub fn parse_row_format(&mut self) -> Result<HiveRowFormat, ParserError> {
1645 self.expect_keyword(Keyword::FORMAT)?;
1646 match self.parse_one_of_keywords(&[Keyword::SERDE, Keyword::DELIMITED]) {
1647 Some(Keyword::SERDE) => {
1648 let class = self.parse_literal_string()?;
1649 Ok(HiveRowFormat::SERDE { class })
1650 }
1651 _ => Ok(HiveRowFormat::DELIMITED),
1652 }
1653 }
1654
1655 pub fn parse_create_table(
1656 &mut self,
1657 or_replace: bool,
1658 temporary: bool,
1659 ) -> Result<Statement, ParserError> {
1660 let if_not_exists = self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]);
1661 let table_name = self.parse_object_name()?;
1662 let like = if self.parse_keyword(Keyword::LIKE) || self.parse_keyword(Keyword::ILIKE) {
1663 self.parse_object_name().ok()
1664 } else {
1665 None
1666 };
1667 let (columns, constraints) = self.parse_columns()?;
1669
1670 let without_rowid = self.parse_keywords(&[Keyword::WITHOUT, Keyword::ROWID]);
1672
1673 let hive_distribution = self.parse_hive_distribution()?;
1674 let hive_formats = self.parse_hive_formats()?;
1675 let with_options = self.parse_options(Keyword::WITH)?;
1677 let table_properties = self.parse_options(Keyword::TBLPROPERTIES)?;
1678 let query = if self.parse_keyword(Keyword::AS) {
1680 Some(Box::new(self.parse_query()?))
1681 } else {
1682 None
1683 };
1684
1685 Ok(Statement::CreateTable {
1686 name: table_name,
1687 temporary,
1688 columns,
1689 constraints,
1690 with_options,
1691 table_properties,
1692 or_replace,
1693 if_not_exists,
1694 hive_distribution,
1695 hive_formats: Some(hive_formats),
1696 external: false,
1697 file_format: None,
1698 location: None,
1699 query,
1700 without_rowid,
1701 like,
1702 })
1703 }
1704
1705 fn parse_columns(&mut self) -> Result<(Vec<ColumnDef>, Vec<TableConstraint>), ParserError> {
1706 let mut columns = vec![];
1707 let mut constraints = vec![];
1708 if !self.consume_token(&Token::LParen) || self.consume_token(&Token::RParen) {
1709 return Ok((columns, constraints));
1710 }
1711
1712 loop {
1713 if let Some(constraint) = self.parse_optional_table_constraint()? {
1714 constraints.push(constraint);
1715 } else if let Token::Word(_) = self.peek_token() {
1716 columns.push(self.parse_column_def()?);
1717 } else {
1718 return self.expected("column name or constraint definition", self.peek_token());
1719 }
1720 let comma = self.consume_token(&Token::Comma);
1721 if self.consume_token(&Token::RParen) {
1722 break;
1724 } else if !comma {
1725 return self.expected("',' or ')' after column definition", self.peek_token());
1726 }
1727 }
1728
1729 Ok((columns, constraints))
1730 }
1731
1732 fn parse_column_def(&mut self) -> Result<ColumnDef, ParserError> {
1733 let name = self.parse_identifier()?;
1734 let data_type = self.parse_data_type()?;
1735 let collation = if self.parse_keyword(Keyword::COLLATE) {
1736 Some(self.parse_object_name()?)
1737 } else {
1738 None
1739 };
1740 let mut options = vec![];
1741 loop {
1742 if self.parse_keyword(Keyword::CONSTRAINT) {
1743 let name = Some(self.parse_identifier()?);
1744 if let Some(option) = self.parse_optional_column_option()? {
1745 options.push(ColumnOptionDef { name, option });
1746 } else {
1747 return self.expected(
1748 "constraint details after CONSTRAINT <name>",
1749 self.peek_token(),
1750 );
1751 }
1752 } else if let Some(option) = self.parse_optional_column_option()? {
1753 options.push(ColumnOptionDef { name: None, option });
1754 } else {
1755 break;
1756 };
1757 }
1758 Ok(ColumnDef {
1759 name,
1760 data_type,
1761 collation,
1762 options,
1763 })
1764 }
1765
1766 pub fn parse_optional_column_option(&mut self) -> Result<Option<ColumnOption>, ParserError> {
1767 if self.parse_keywords(&[Keyword::NOT, Keyword::NULL]) {
1768 Ok(Some(ColumnOption::NotNull))
1769 } else if self.parse_keyword(Keyword::NULL) {
1770 Ok(Some(ColumnOption::Null))
1771 } else if self.parse_keyword(Keyword::DEFAULT) {
1772 Ok(Some(ColumnOption::Default(self.parse_expr()?)))
1773 } else if self.parse_keywords(&[Keyword::PRIMARY, Keyword::KEY]) {
1774 Ok(Some(ColumnOption::Unique { is_primary: true }))
1775 } else if self.parse_keyword(Keyword::UNIQUE) {
1776 Ok(Some(ColumnOption::Unique { is_primary: false }))
1777 } else if self.parse_keyword(Keyword::REFERENCES) {
1778 let foreign_table = self.parse_object_name()?;
1779 let referred_columns = self.parse_parenthesized_column_list(Optional)?;
1782 let mut on_delete = None;
1783 let mut on_update = None;
1784 loop {
1785 if on_delete.is_none() && self.parse_keywords(&[Keyword::ON, Keyword::DELETE]) {
1786 on_delete = Some(self.parse_referential_action()?);
1787 } else if on_update.is_none()
1788 && self.parse_keywords(&[Keyword::ON, Keyword::UPDATE])
1789 {
1790 on_update = Some(self.parse_referential_action()?);
1791 } else {
1792 break;
1793 }
1794 }
1795 Ok(Some(ColumnOption::ForeignKey {
1796 foreign_table,
1797 referred_columns,
1798 on_delete,
1799 on_update,
1800 }))
1801 } else if self.parse_keyword(Keyword::CHECK) {
1802 self.expect_token(&Token::LParen)?;
1803 let expr = self.parse_expr()?;
1804 self.expect_token(&Token::RParen)?;
1805 Ok(Some(ColumnOption::Check(expr)))
1806 } else if self.parse_keyword(Keyword::AUTO_INCREMENT)
1807 && dialect_of!(self is MySqlDialect | GenericDialect)
1808 {
1809 Ok(Some(ColumnOption::DialectSpecific(vec![
1811 Token::make_keyword("AUTO_INCREMENT"),
1812 ])))
1813 } else if self.parse_keyword(Keyword::AUTOINCREMENT)
1814 && dialect_of!(self is SQLiteDialect | GenericDialect)
1815 {
1816 Ok(Some(ColumnOption::DialectSpecific(vec![
1818 Token::make_keyword("AUTOINCREMENT"),
1819 ])))
1820 } else {
1821 Ok(None)
1822 }
1823 }
1824
1825 pub fn parse_referential_action(&mut self) -> Result<ReferentialAction, ParserError> {
1826 if self.parse_keyword(Keyword::RESTRICT) {
1827 Ok(ReferentialAction::Restrict)
1828 } else if self.parse_keyword(Keyword::CASCADE) {
1829 Ok(ReferentialAction::Cascade)
1830 } else if self.parse_keywords(&[Keyword::SET, Keyword::NULL]) {
1831 Ok(ReferentialAction::SetNull)
1832 } else if self.parse_keywords(&[Keyword::NO, Keyword::ACTION]) {
1833 Ok(ReferentialAction::NoAction)
1834 } else if self.parse_keywords(&[Keyword::SET, Keyword::DEFAULT]) {
1835 Ok(ReferentialAction::SetDefault)
1836 } else {
1837 self.expected(
1838 "one of RESTRICT, CASCADE, SET NULL, NO ACTION or SET DEFAULT",
1839 self.peek_token(),
1840 )
1841 }
1842 }
1843
1844 pub fn parse_optional_table_constraint(
1845 &mut self,
1846 ) -> Result<Option<TableConstraint>, ParserError> {
1847 let name = if self.parse_keyword(Keyword::CONSTRAINT) {
1848 Some(self.parse_identifier()?)
1849 } else {
1850 None
1851 };
1852 match self.next_token() {
1853 Token::Word(w) if w.keyword == Keyword::PRIMARY || w.keyword == Keyword::UNIQUE => {
1854 let is_primary = w.keyword == Keyword::PRIMARY;
1855 if is_primary {
1856 self.expect_keyword(Keyword::KEY)?;
1857 }
1858 let columns = self.parse_parenthesized_column_list(Mandatory)?;
1859 Ok(Some(TableConstraint::Unique {
1860 name,
1861 columns,
1862 is_primary,
1863 }))
1864 }
1865 Token::Word(w) if w.keyword == Keyword::FOREIGN => {
1866 self.expect_keyword(Keyword::KEY)?;
1867 let columns = self.parse_parenthesized_column_list(Mandatory)?;
1868 self.expect_keyword(Keyword::REFERENCES)?;
1869 let foreign_table = self.parse_object_name()?;
1870 let referred_columns = self.parse_parenthesized_column_list(Mandatory)?;
1871 let mut on_delete = None;
1872 let mut on_update = None;
1873 loop {
1874 if on_delete.is_none() && self.parse_keywords(&[Keyword::ON, Keyword::DELETE]) {
1875 on_delete = Some(self.parse_referential_action()?);
1876 } else if on_update.is_none()
1877 && self.parse_keywords(&[Keyword::ON, Keyword::UPDATE])
1878 {
1879 on_update = Some(self.parse_referential_action()?);
1880 } else {
1881 break;
1882 }
1883 }
1884 Ok(Some(TableConstraint::ForeignKey {
1885 name,
1886 columns,
1887 foreign_table,
1888 referred_columns,
1889 on_delete,
1890 on_update,
1891 }))
1892 }
1893 Token::Word(w) if w.keyword == Keyword::CHECK => {
1894 self.expect_token(&Token::LParen)?;
1895 let expr = Box::new(self.parse_expr()?);
1896 self.expect_token(&Token::RParen)?;
1897 Ok(Some(TableConstraint::Check { name, expr }))
1898 }
1899 unexpected => {
1900 if name.is_some() {
1901 self.expected("PRIMARY, UNIQUE, FOREIGN, or CHECK", unexpected)
1902 } else {
1903 self.prev_token();
1904 Ok(None)
1905 }
1906 }
1907 }
1908 }
1909
1910 pub fn parse_options(&mut self, keyword: Keyword) -> Result<Vec<SqlOption>, ParserError> {
1911 if self.parse_keyword(keyword) {
1912 self.expect_token(&Token::LParen)?;
1913 let options = self.parse_comma_separated(Parser::parse_sql_option)?;
1914 self.expect_token(&Token::RParen)?;
1915 Ok(options)
1916 } else {
1917 Ok(vec![])
1918 }
1919 }
1920
1921 pub fn parse_sql_option(&mut self) -> Result<SqlOption, ParserError> {
1922 let name = self.parse_identifier()?;
1923 self.expect_token(&Token::Eq)?;
1924 let value = self.parse_value()?;
1925 Ok(SqlOption { name, value })
1926 }
1927
1928 pub fn parse_alter(&mut self) -> Result<Statement, ParserError> {
1929 self.expect_keyword(Keyword::TABLE)?;
1930 let _ = self.parse_keyword(Keyword::ONLY);
1931 let table_name = self.parse_object_name()?;
1932 let operation = if self.parse_keyword(Keyword::ADD) {
1933 if let Some(constraint) = self.parse_optional_table_constraint()? {
1934 AlterTableOperation::AddConstraint(constraint)
1935 } else {
1936 let if_not_exists =
1937 self.parse_keywords(&[Keyword::IF, Keyword::NOT, Keyword::EXISTS]);
1938 if self.parse_keyword(Keyword::PARTITION) {
1939 self.expect_token(&Token::LParen)?;
1940 let partitions = self.parse_comma_separated(Parser::parse_expr)?;
1941 self.expect_token(&Token::RParen)?;
1942 AlterTableOperation::AddPartitions {
1943 if_not_exists,
1944 new_partitions: partitions,
1945 }
1946 } else {
1947 let _ = self.parse_keyword(Keyword::COLUMN);
1948 let column_def = self.parse_column_def()?;
1949 AlterTableOperation::AddColumn { column_def }
1950 }
1951 }
1952 } else if self.parse_keyword(Keyword::RENAME) {
1953 if dialect_of!(self is PostgreSqlDialect) && self.parse_keyword(Keyword::CONSTRAINT) {
1954 let old_name = self.parse_identifier()?;
1955 self.expect_keyword(Keyword::TO)?;
1956 let new_name = self.parse_identifier()?;
1957 AlterTableOperation::RenameConstraint { old_name, new_name }
1958 } else if self.parse_keyword(Keyword::TO) {
1959 let table_name = self.parse_object_name()?;
1960 AlterTableOperation::RenameTable { table_name }
1961 } else {
1962 let _ = self.parse_keyword(Keyword::COLUMN);
1963 let old_column_name = self.parse_identifier()?;
1964 self.expect_keyword(Keyword::TO)?;
1965 let new_column_name = self.parse_identifier()?;
1966 AlterTableOperation::RenameColumn {
1967 old_column_name,
1968 new_column_name,
1969 }
1970 }
1971 } else if self.parse_keyword(Keyword::DROP) {
1972 if self.parse_keywords(&[Keyword::IF, Keyword::EXISTS, Keyword::PARTITION]) {
1973 self.expect_token(&Token::LParen)?;
1974 let partitions = self.parse_comma_separated(Parser::parse_expr)?;
1975 self.expect_token(&Token::RParen)?;
1976 AlterTableOperation::DropPartitions {
1977 partitions,
1978 if_exists: true,
1979 }
1980 } else if self.parse_keyword(Keyword::PARTITION) {
1981 self.expect_token(&Token::LParen)?;
1982 let partitions = self.parse_comma_separated(Parser::parse_expr)?;
1983 self.expect_token(&Token::RParen)?;
1984 AlterTableOperation::DropPartitions {
1985 partitions,
1986 if_exists: false,
1987 }
1988 } else {
1989 let _ = self.parse_keyword(Keyword::COLUMN);
1990 let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]);
1991 let column_name = self.parse_identifier()?;
1992 let cascade = self.parse_keyword(Keyword::CASCADE);
1993 AlterTableOperation::DropColumn {
1994 column_name,
1995 if_exists,
1996 cascade,
1997 }
1998 }
1999 } else if self.parse_keyword(Keyword::PARTITION) {
2000 self.expect_token(&Token::LParen)?;
2001 let before = self.parse_comma_separated(Parser::parse_expr)?;
2002 self.expect_token(&Token::RParen)?;
2003 self.expect_keyword(Keyword::RENAME)?;
2004 self.expect_keywords(&[Keyword::TO, Keyword::PARTITION])?;
2005 self.expect_token(&Token::LParen)?;
2006 let renames = self.parse_comma_separated(Parser::parse_expr)?;
2007 self.expect_token(&Token::RParen)?;
2008 AlterTableOperation::RenamePartitions {
2009 old_partitions: before,
2010 new_partitions: renames,
2011 }
2012 } else if self.parse_keyword(Keyword::CHANGE) {
2013 let _ = self.parse_keyword(Keyword::COLUMN);
2014 let old_name = self.parse_identifier()?;
2015 let new_name = self.parse_identifier()?;
2016 let data_type = self.parse_data_type()?;
2017 let mut options = vec![];
2018 while let Some(option) = self.parse_optional_column_option()? {
2019 options.push(option);
2020 }
2021
2022 AlterTableOperation::ChangeColumn {
2023 old_name,
2024 new_name,
2025 data_type,
2026 options,
2027 }
2028 } else if self.parse_keyword(Keyword::ALTER) {
2029 let _ = self.parse_keyword(Keyword::COLUMN);
2030 let column_name = self.parse_identifier()?;
2031 let is_postgresql = dialect_of!(self is PostgreSqlDialect);
2032
2033 let op = if self.parse_keywords(&[Keyword::SET, Keyword::NOT, Keyword::NULL]) {
2034 AlterColumnOperation::SetNotNull {}
2035 } else if self.parse_keywords(&[Keyword::DROP, Keyword::NOT, Keyword::NULL]) {
2036 AlterColumnOperation::DropNotNull {}
2037 } else if self.parse_keywords(&[Keyword::SET, Keyword::DEFAULT]) {
2038 AlterColumnOperation::SetDefault {
2039 value: self.parse_expr()?,
2040 }
2041 } else if self.parse_keywords(&[Keyword::DROP, Keyword::DEFAULT]) {
2042 AlterColumnOperation::DropDefault {}
2043 } else if self.parse_keywords(&[Keyword::SET, Keyword::DATA, Keyword::TYPE])
2044 || (is_postgresql && self.parse_keyword(Keyword::TYPE))
2045 {
2046 let data_type = self.parse_data_type()?;
2047 let using = if is_postgresql && self.parse_keyword(Keyword::USING) {
2048 Some(self.parse_expr()?)
2049 } else {
2050 None
2051 };
2052 AlterColumnOperation::SetDataType { data_type, using }
2053 } else {
2054 return self.expected(
2055 "SET/DROP NOT NULL, SET DEFAULT, SET DATA TYPE after ALTER COLUMN",
2056 self.peek_token(),
2057 );
2058 };
2059 AlterTableOperation::AlterColumn { column_name, op }
2060 } else {
2061 return self.expected(
2062 "ADD, RENAME, PARTITION or DROP after ALTER TABLE",
2063 self.peek_token(),
2064 );
2065 };
2066 Ok(Statement::AlterTable {
2067 name: table_name,
2068 operation,
2069 })
2070 }
2071
2072 pub fn parse_copy(&mut self) -> Result<Statement, ParserError> {
2074 let table_name = self.parse_object_name()?;
2075 let columns = self.parse_parenthesized_column_list(Optional)?;
2076 self.expect_keywords(&[Keyword::FROM, Keyword::STDIN])?;
2077 self.expect_token(&Token::SemiColon)?;
2078 let values = self.parse_tsv();
2079 Ok(Statement::Copy {
2080 table_name,
2081 columns,
2082 values,
2083 })
2084 }
2085
2086 fn parse_tsv(&mut self) -> Vec<Option<String>> {
2089 self.parse_tab_value()
2090 }
2091
2092 fn parse_tab_value(&mut self) -> Vec<Option<String>> {
2093 let mut values = vec![];
2094 let mut content = String::from("");
2095 while let Some(t) = self.next_token_no_skip() {
2096 match t {
2097 Token::Whitespace(Whitespace::Tab) => {
2098 values.push(Some(content.to_string()));
2099 content.clear();
2100 }
2101 Token::Whitespace(Whitespace::Newline) => {
2102 values.push(Some(content.to_string()));
2103 content.clear();
2104 }
2105 Token::Backslash => {
2106 if self.consume_token(&Token::Period) {
2107 return values;
2108 }
2109 if let Token::Word(w) = self.next_token() {
2110 if w.value == "N" {
2111 values.push(None);
2112 }
2113 }
2114 }
2115 _ => {
2116 content.push_str(&t.to_string());
2117 }
2118 }
2119 }
2120 values
2121 }
2122
2123 fn parse_value(&mut self) -> Result<Value, ParserError> {
2125 match self.next_token() {
2126 Token::Word(w) => match w.keyword {
2127 Keyword::TRUE => Ok(Value::Boolean(true)),
2128 Keyword::FALSE => Ok(Value::Boolean(false)),
2129 Keyword::NULL => Ok(Value::Null),
2130 Keyword::NoKeyword if w.quote_style.is_some() => match w.quote_style {
2131 Some('"') => Ok(Value::DoubleQuotedString(w.value)),
2132 Some('\'') => Ok(Value::SingleQuotedString(w.value)),
2133 _ => self.expected("A value?", Token::Word(w))?,
2134 },
2135 _ => self.expected("a concrete value", Token::Word(w)),
2136 },
2137 Token::Number(ref n, l) => match n.parse() {
2141 Ok(n) => Ok(Value::Number(n, l)),
2142 Err(e) => parser_err!(format!("Could not parse '{}' as number: {}", n, e)),
2143 },
2144 Token::SingleQuotedString(ref s) => Ok(Value::SingleQuotedString(s.to_string())),
2145 Token::NationalStringLiteral(ref s) => Ok(Value::NationalStringLiteral(s.to_string())),
2146 Token::HexStringLiteral(ref s) => Ok(Value::HexStringLiteral(s.to_string())),
2147 Token::Placeholder(ref s) => Ok(Value::Placeholder(s.to_string())),
2148 unexpected => self.expected("a value", unexpected),
2149 }
2150 }
2151
2152 pub fn parse_number_value(&mut self) -> Result<Value, ParserError> {
2153 match self.parse_value()? {
2154 v @ Value::Number(_, _) => Ok(v),
2155 _ => {
2156 self.prev_token();
2157 self.expected("literal number", self.peek_token())
2158 }
2159 }
2160 }
2161
2162 pub fn parse_literal_uint(&mut self) -> Result<u64, ParserError> {
2164 match self.next_token() {
2165 Token::Number(s, _) => s.parse::<u64>().map_err(|e| {
2166 ParserError::ParserError(format!("Could not parse '{}' as u64: {}", s, e))
2167 }),
2168 unexpected => self.expected("literal int", unexpected),
2169 }
2170 }
2171
2172 pub fn parse_literal_string(&mut self) -> Result<String, ParserError> {
2174 match self.next_token() {
2175 Token::Word(Word { value, keyword, .. }) if keyword == Keyword::NoKeyword => Ok(value),
2176 Token::SingleQuotedString(s) => Ok(s),
2177 unexpected => self.expected("literal string", unexpected),
2178 }
2179 }
2180
2181 pub fn parse_map_key(&mut self) -> Result<Expr, ParserError> {
2183 match self.next_token() {
2184 Token::Word(Word { value, keyword, .. }) if keyword == Keyword::NoKeyword => {
2185 if self.peek_token() == Token::LParen {
2186 return self.parse_function(ObjectName(vec![Ident::new(value)]));
2187 }
2188 Ok(Expr::Value(Value::SingleQuotedString(value)))
2189 }
2190 Token::SingleQuotedString(s) => Ok(Expr::Value(Value::SingleQuotedString(s))),
2191 #[cfg(not(feature = "bigdecimal"))]
2192 Token::Number(s, _) => Ok(Expr::Value(Value::Number(s, false))),
2193 #[cfg(feature = "bigdecimal")]
2194 Token::Number(s, _) => Ok(Expr::Value(Value::Number(s.parse().unwrap(), false))),
2195 unexpected => self.expected("literal string, number or function", unexpected),
2196 }
2197 }
2198
2199 pub fn parse_data_type(&mut self) -> Result<DataType, ParserError> {
2201 match self.next_token() {
2202 Token::Word(w) => match w.keyword {
2203 Keyword::BOOLEAN => Ok(DataType::Boolean),
2204 Keyword::FLOAT => Ok(DataType::Float(self.parse_optional_precision()?)),
2205 Keyword::REAL => Ok(DataType::Real),
2206 Keyword::DOUBLE => {
2207 let _ = self.parse_keyword(Keyword::PRECISION);
2208 Ok(DataType::Double)
2209 }
2210 Keyword::TINYINT => Ok(DataType::TinyInt(self.parse_optional_precision()?)),
2211 Keyword::SMALLINT => Ok(DataType::SmallInt(self.parse_optional_precision()?)),
2212 Keyword::INT | Keyword::INTEGER => {
2213 Ok(DataType::Int(self.parse_optional_precision()?))
2214 }
2215 Keyword::BIGINT => Ok(DataType::BigInt(self.parse_optional_precision()?)),
2216 Keyword::VARCHAR => Ok(DataType::Varchar(self.parse_optional_precision()?)),
2217 Keyword::CHAR | Keyword::CHARACTER => {
2218 if self.parse_keyword(Keyword::VARYING) {
2219 Ok(DataType::Varchar(self.parse_optional_precision()?))
2220 } else {
2221 Ok(DataType::Char(self.parse_optional_precision()?))
2222 }
2223 }
2224 Keyword::UUID => Ok(DataType::Uuid),
2225 Keyword::DATE => Ok(DataType::Date),
2226 Keyword::TIMESTAMP => {
2227 if self.parse_keyword(Keyword::WITH) || self.parse_keyword(Keyword::WITHOUT) {
2229 self.expect_keywords(&[Keyword::TIME, Keyword::ZONE])?;
2230 }
2231 Ok(DataType::Timestamp)
2232 }
2233 Keyword::TIME => {
2234 if self.parse_keyword(Keyword::WITH) || self.parse_keyword(Keyword::WITHOUT) {
2236 self.expect_keywords(&[Keyword::TIME, Keyword::ZONE])?;
2237 }
2238 Ok(DataType::Time)
2239 }
2240 Keyword::INTERVAL => Ok(DataType::Interval),
2244 Keyword::REGCLASS => Ok(DataType::Regclass),
2245 Keyword::STRING => Ok(DataType::String),
2246 Keyword::TEXT => {
2247 if self.consume_token(&Token::LBracket) {
2248 self.expect_token(&Token::RBracket)?;
2250 Ok(DataType::Array(Box::new(DataType::Text)))
2251 } else {
2252 Ok(DataType::Text)
2253 }
2254 }
2255 Keyword::BYTEA => Ok(DataType::Bytea),
2256 Keyword::NUMERIC | Keyword::DECIMAL | Keyword::DEC => {
2257 let (precision, scale) = self.parse_optional_precision_scale()?;
2258 Ok(DataType::Decimal(precision, scale))
2259 }
2260 _ => {
2261 self.prev_token();
2262 let type_name = self.parse_object_name()?;
2263 Ok(DataType::Custom(type_name))
2264 }
2265 },
2266 unexpected => self.expected("a data type name", unexpected),
2267 }
2268 }
2269
2270 pub fn parse_optional_alias(
2274 &mut self,
2275 reserved_kwds: &[Keyword],
2276 ) -> Result<Option<Ident>, ParserError> {
2277 let after_as = self.parse_keyword(Keyword::AS);
2278 match self.next_token() {
2279 Token::Word(w) if after_as || !reserved_kwds.contains(&w.keyword) => {
2285 Ok(Some(w.to_ident()))
2286 }
2287 Token::SingleQuotedString(s) => Ok(Some(Ident::with_quote('\'', s))),
2300 not_an_ident => {
2301 if after_as {
2302 return self.expected("an identifier after AS", not_an_ident);
2303 }
2304 self.prev_token();
2305 Ok(None) }
2307 }
2308 }
2309
2310 pub fn parse_optional_table_alias(
2315 &mut self,
2316 reserved_kwds: &[Keyword],
2317 ) -> Result<Option<TableAlias>, ParserError> {
2318 match self.parse_optional_alias(reserved_kwds)? {
2319 Some(name) => {
2320 let columns = self.parse_parenthesized_column_list(Optional)?;
2321 Ok(Some(TableAlias { name, columns }))
2322 }
2323 None => Ok(None),
2324 }
2325 }
2326
2327 pub fn parse_object_name(&mut self) -> Result<ObjectName, ParserError> {
2330 let mut idents = vec![];
2331 loop {
2332 idents.push(self.parse_identifier()?);
2333 if !self.consume_token(&Token::Period) {
2334 break;
2335 }
2336 }
2337 Ok(ObjectName(idents))
2338 }
2339
2340 pub fn parse_identifiers_non_keywords(&mut self) -> Result<Vec<Ident>, ParserError> {
2342 let mut idents = vec![];
2343 loop {
2344 match self.peek_token() {
2345 Token::Word(w) => {
2346 if w.keyword != Keyword::NoKeyword {
2347 break;
2348 }
2349
2350 idents.push(w.to_ident());
2351 }
2352 Token::EOF | Token::Eq => break,
2353 _ => {}
2354 }
2355
2356 self.next_token();
2357 }
2358
2359 Ok(idents)
2360 }
2361
2362 pub fn parse_identifiers(&mut self) -> Result<Vec<Ident>, ParserError> {
2364 let mut idents = vec![];
2365 loop {
2366 match self.next_token() {
2367 Token::Word(w) => {
2368 idents.push(w.to_ident());
2369 }
2370 Token::EOF => break,
2371 _ => {}
2372 }
2373 }
2374
2375 Ok(idents)
2376 }
2377
2378 pub fn parse_identifier(&mut self) -> Result<Ident, ParserError> {
2380 match self.next_token() {
2381 Token::Word(w) => Ok(w.to_ident()),
2382 Token::SingleQuotedString(s) => Ok(Ident::with_quote('\'', s)),
2383 unexpected => self.expected("identifier", unexpected),
2384 }
2385 }
2386
2387 pub fn parse_parenthesized_column_list(
2389 &mut self,
2390 optional: IsOptional,
2391 ) -> Result<Vec<Ident>, ParserError> {
2392 if self.consume_token(&Token::LParen) {
2393 let cols = self.parse_comma_separated(Parser::parse_identifier)?;
2394 self.expect_token(&Token::RParen)?;
2395 Ok(cols)
2396 } else if optional == Optional {
2397 Ok(vec![])
2398 } else {
2399 self.expected("a list of columns in parentheses", self.peek_token())
2400 }
2401 }
2402
2403 pub fn parse_optional_precision(&mut self) -> Result<Option<u64>, ParserError> {
2404 if self.consume_token(&Token::LParen) {
2405 let n = self.parse_literal_uint()?;
2406 self.expect_token(&Token::RParen)?;
2407 Ok(Some(n))
2408 } else {
2409 Ok(None)
2410 }
2411 }
2412
2413 pub fn parse_optional_precision_scale(
2414 &mut self,
2415 ) -> Result<(Option<u64>, Option<u64>), ParserError> {
2416 if self.consume_token(&Token::LParen) {
2417 let n = self.parse_literal_uint()?;
2418 let scale = if self.consume_token(&Token::Comma) {
2419 Some(self.parse_literal_uint()?)
2420 } else {
2421 None
2422 };
2423 self.expect_token(&Token::RParen)?;
2424 Ok((Some(n), scale))
2425 } else {
2426 Ok((None, None))
2427 }
2428 }
2429
2430 pub fn parse_delete(&mut self) -> Result<Statement, ParserError> {
2431 self.expect_keyword(Keyword::FROM)?;
2432 let table_name = self.parse_object_name()?;
2433 let selection = if self.parse_keyword(Keyword::WHERE) {
2434 Some(self.parse_expr()?)
2435 } else {
2436 None
2437 };
2438
2439 Ok(Statement::Delete {
2440 table_name,
2441 selection,
2442 })
2443 }
2444
2445 pub fn parse_explain(&mut self, describe_alias: bool) -> Result<Statement, ParserError> {
2446 let analyze = self.parse_keyword(Keyword::ANALYZE);
2447 let verbose = self.parse_keyword(Keyword::VERBOSE);
2448
2449 if let Some(statement) = self.maybe_parse(|parser| parser.parse_statement()) {
2450 Ok(Statement::Explain {
2451 describe_alias,
2452 analyze,
2453 verbose,
2454 statement: Box::new(statement),
2455 })
2456 } else {
2457 let table_name = self.parse_object_name()?;
2458
2459 Ok(Statement::ExplainTable {
2460 describe_alias,
2461 table_name,
2462 })
2463 }
2464 }
2465
2466 pub fn parse_query(&mut self) -> Result<Query, ParserError> {
2471 let with = if self.parse_keyword(Keyword::WITH) {
2472 Some(With {
2473 recursive: self.parse_keyword(Keyword::RECURSIVE),
2474 cte_tables: self.parse_comma_separated(Parser::parse_cte)?,
2475 })
2476 } else {
2477 None
2478 };
2479
2480 if !self.parse_keyword(Keyword::INSERT) {
2481 let body = self.parse_query_body(0)?;
2482
2483 let order_by = if self.parse_keywords(&[Keyword::ORDER, Keyword::BY]) {
2484 self.parse_comma_separated(Parser::parse_order_by_expr)?
2485 } else {
2486 vec![]
2487 };
2488
2489 let limit = if self.parse_keyword(Keyword::LIMIT) {
2490 self.parse_limit()?
2491 } else {
2492 None
2493 };
2494
2495 let offset = if self.parse_keyword(Keyword::OFFSET) {
2496 Some(self.parse_offset()?)
2497 } else {
2498 None
2499 };
2500
2501 let fetch = if self.parse_keyword(Keyword::FETCH) {
2502 Some(self.parse_fetch()?)
2503 } else {
2504 None
2505 };
2506
2507 let lock = if self.parse_keyword(Keyword::FOR) {
2508 Some(self.parse_lock()?)
2509 } else {
2510 None
2511 };
2512
2513 Ok(Query {
2514 with,
2515 body,
2516 order_by,
2517 limit,
2518 offset,
2519 fetch,
2520 lock,
2521 })
2522 } else {
2523 let insert = self.parse_insert()?;
2524
2525 Ok(Query {
2526 with,
2527 body: SetExpr::Insert(insert),
2528 limit: None,
2529 order_by: vec![],
2530 offset: None,
2531 fetch: None,
2532 lock: None,
2533 })
2534 }
2535 }
2536
2537 fn parse_cte(&mut self) -> Result<Cte, ParserError> {
2539 let name = self.parse_identifier()?;
2540
2541 let mut cte = if self.parse_keyword(Keyword::AS) {
2542 self.expect_token(&Token::LParen)?;
2543 let query = self.parse_query()?;
2544 self.expect_token(&Token::RParen)?;
2545 let alias = TableAlias {
2546 name,
2547 columns: vec![],
2548 };
2549 Cte {
2550 alias,
2551 query,
2552 from: None,
2553 }
2554 } else {
2555 let columns = self.parse_parenthesized_column_list(Optional)?;
2556 self.expect_keyword(Keyword::AS)?;
2557 self.expect_token(&Token::LParen)?;
2558 let query = self.parse_query()?;
2559 self.expect_token(&Token::RParen)?;
2560 let alias = TableAlias { name, columns };
2561 Cte {
2562 alias,
2563 query,
2564 from: None,
2565 }
2566 };
2567 if self.parse_keyword(Keyword::FROM) {
2568 cte.from = Some(self.parse_identifier()?);
2569 }
2570 Ok(cte)
2571 }
2572
2573 fn parse_query_body(&mut self, precedence: u8) -> Result<SetExpr, ParserError> {
2582 let mut expr = if self.parse_keyword(Keyword::SELECT) {
2585 SetExpr::Select(Box::new(self.parse_select()?))
2586 } else if self.consume_token(&Token::LParen) {
2587 let subquery = self.parse_query()?;
2589 self.expect_token(&Token::RParen)?;
2590 SetExpr::Query(Box::new(subquery))
2591 } else if self.parse_keyword(Keyword::VALUES) {
2592 SetExpr::Values(self.parse_values()?)
2593 } else {
2594 return self.expected(
2595 "SELECT, VALUES, or a subquery in the query body",
2596 self.peek_token(),
2597 );
2598 };
2599
2600 loop {
2601 let op = self.parse_set_operator(&self.peek_token());
2603 let next_precedence = match op {
2604 Some(SetOperator::Union) | Some(SetOperator::Except) => 10,
2606 Some(SetOperator::Intersect) => 20,
2608 None => break,
2610 };
2611 if precedence >= next_precedence {
2612 break;
2613 }
2614 self.next_token(); expr = SetExpr::SetOperation {
2616 left: Box::new(expr),
2617 op: op.unwrap(),
2618 all: self.parse_keyword(Keyword::ALL),
2619 right: Box::new(self.parse_query_body(next_precedence)?),
2620 };
2621 }
2622
2623 Ok(expr)
2624 }
2625
2626 fn parse_set_operator(&mut self, token: &Token) -> Option<SetOperator> {
2627 match token {
2628 Token::Word(w) if w.keyword == Keyword::UNION => Some(SetOperator::Union),
2629 Token::Word(w) if w.keyword == Keyword::EXCEPT => Some(SetOperator::Except),
2630 Token::Word(w) if w.keyword == Keyword::INTERSECT => Some(SetOperator::Intersect),
2631 _ => None,
2632 }
2633 }
2634
2635 pub fn parse_select(&mut self) -> Result<Select, ParserError> {
2638 let distinct = self.parse_all_or_distinct()?;
2639
2640 let top = if self.parse_keyword(Keyword::TOP) {
2641 Some(self.parse_top()?)
2642 } else {
2643 None
2644 };
2645
2646 let projection = self.parse_comma_separated(Parser::parse_select_item)?;
2647
2648 let from = if self.parse_keyword(Keyword::FROM) {
2654 self.parse_comma_separated(Parser::parse_table_and_joins)?
2655 } else {
2656 vec![]
2657 };
2658 let mut lateral_views = vec![];
2659 loop {
2660 if self.parse_keywords(&[Keyword::LATERAL, Keyword::VIEW]) {
2661 let outer = self.parse_keyword(Keyword::OUTER);
2662 let lateral_view = self.parse_expr()?;
2663 let lateral_view_name = self.parse_object_name()?;
2664 let lateral_col_alias = self
2665 .parse_comma_separated(|parser| {
2666 parser.parse_optional_alias(&[
2667 Keyword::WHERE,
2668 Keyword::GROUP,
2669 Keyword::CLUSTER,
2670 Keyword::HAVING,
2671 Keyword::LATERAL,
2672 ]) })?
2674 .into_iter()
2675 .flatten()
2676 .collect();
2677
2678 lateral_views.push(LateralView {
2679 lateral_view,
2680 lateral_view_name,
2681 lateral_col_alias,
2682 outer,
2683 });
2684 } else {
2685 break;
2686 }
2687 }
2688
2689 let selection = if self.parse_keyword(Keyword::WHERE) {
2690 Some(self.parse_expr()?)
2691 } else {
2692 None
2693 };
2694
2695 let group_by = if self.parse_keywords(&[Keyword::GROUP, Keyword::BY]) {
2696 self.parse_comma_separated(Parser::parse_group_by_expr)?
2697 } else {
2698 vec![]
2699 };
2700
2701 let cluster_by = if self.parse_keywords(&[Keyword::CLUSTER, Keyword::BY]) {
2702 self.parse_comma_separated(Parser::parse_expr)?
2703 } else {
2704 vec![]
2705 };
2706
2707 let distribute_by = if self.parse_keywords(&[Keyword::DISTRIBUTE, Keyword::BY]) {
2708 self.parse_comma_separated(Parser::parse_expr)?
2709 } else {
2710 vec![]
2711 };
2712
2713 let sort_by = if self.parse_keywords(&[Keyword::SORT, Keyword::BY]) {
2714 self.parse_comma_separated(Parser::parse_expr)?
2715 } else {
2716 vec![]
2717 };
2718
2719 let having = if self.parse_keyword(Keyword::HAVING) {
2720 Some(self.parse_expr()?)
2721 } else {
2722 None
2723 };
2724
2725 Ok(Select {
2726 distinct,
2727 top,
2728 projection,
2729 from,
2730 lateral_views,
2731 selection,
2732 group_by,
2733 cluster_by,
2734 distribute_by,
2735 sort_by,
2736 having,
2737 })
2738 }
2739
2740 pub fn parse_set(&mut self) -> Result<Statement, ParserError> {
2741 let modifier =
2742 self.parse_one_of_keywords(&[Keyword::SESSION, Keyword::LOCAL, Keyword::HIVEVAR]);
2743 if let Some(Keyword::HIVEVAR) = modifier {
2744 self.expect_token(&Token::Colon)?;
2745 }
2746 let variable = self.parse_identifier()?;
2747 if self.consume_token(&Token::Eq) || self.parse_keyword(Keyword::TO) {
2748 let mut values = vec![];
2749 loop {
2750 let token = self.peek_token();
2751 let value = match (self.parse_value(), token) {
2752 (Ok(value), _) => SetVariableValue::Literal(value),
2753 (Err(_), Token::Word(ident)) => SetVariableValue::Ident(ident.to_ident()),
2754 (Err(_), unexpected) => self.expected("variable value", unexpected)?,
2755 };
2756 values.push(value);
2757 if self.consume_token(&Token::Comma) {
2758 continue;
2759 }
2760 return Ok(Statement::SetVariable {
2761 local: modifier == Some(Keyword::LOCAL),
2762 hivevar: Some(Keyword::HIVEVAR) == modifier,
2763 variable,
2764 value: values,
2765 });
2766 }
2767 } else if variable.value == "CHARACTERISTICS" {
2768 self.expect_keywords(&[Keyword::AS, Keyword::TRANSACTION])?;
2769 Ok(Statement::SetTransaction {
2770 modes: self.parse_transaction_modes()?,
2771 snapshot: None,
2772 session: true,
2773 })
2774 } else if variable.value == "TRANSACTION" && modifier.is_none() {
2775 if self.parse_keyword(Keyword::SNAPSHOT) {
2776 let snaphot_id = self.parse_value()?;
2777 return Ok(Statement::SetTransaction {
2778 modes: vec![],
2779 snapshot: Some(snaphot_id),
2780 session: false,
2781 });
2782 }
2783 Ok(Statement::SetTransaction {
2784 modes: self.parse_transaction_modes()?,
2785 snapshot: None,
2786 session: false,
2787 })
2788 } else {
2789 self.expected("equals sign or TO", self.peek_token())
2790 }
2791 }
2792
2793 pub fn parse_show(&mut self) -> Result<Statement, ParserError> {
2794 if self
2795 .parse_one_of_keywords(&[
2796 Keyword::EXTENDED,
2797 Keyword::FULL,
2798 Keyword::COLUMNS,
2799 Keyword::FIELDS,
2800 ])
2801 .is_some()
2802 {
2803 self.prev_token();
2804 Ok(self.parse_show_columns()?)
2805 } else if self.parse_one_of_keywords(&[Keyword::CREATE]).is_some() {
2806 Ok(self.parse_show_create()?)
2807 } else {
2808 Ok(Statement::ShowVariable {
2809 variable: self.parse_identifiers()?,
2810 })
2811 }
2812 }
2813
2814 fn parse_show_create(&mut self) -> Result<Statement, ParserError> {
2815 let obj_type = match self.expect_one_of_keywords(&[
2816 Keyword::TABLE,
2817 Keyword::TRIGGER,
2818 Keyword::FUNCTION,
2819 Keyword::PROCEDURE,
2820 Keyword::EVENT,
2821 ])? {
2822 Keyword::TABLE => Ok(ShowCreateObject::Table),
2823 Keyword::TRIGGER => Ok(ShowCreateObject::Trigger),
2824 Keyword::FUNCTION => Ok(ShowCreateObject::Function),
2825 Keyword::PROCEDURE => Ok(ShowCreateObject::Procedure),
2826 Keyword::EVENT => Ok(ShowCreateObject::Event),
2827 keyword => Err(ParserError::ParserError(format!(
2828 "Unable to map keyword to ShowCreateObject: {:?}",
2829 keyword
2830 ))),
2831 }?;
2832
2833 let obj_name = self.parse_object_name()?;
2834
2835 Ok(Statement::ShowCreate { obj_type, obj_name })
2836 }
2837
2838 fn parse_show_columns(&mut self) -> Result<Statement, ParserError> {
2839 let extended = self.parse_keyword(Keyword::EXTENDED);
2840 let full = self.parse_keyword(Keyword::FULL);
2841 self.expect_one_of_keywords(&[Keyword::COLUMNS, Keyword::FIELDS])?;
2842 self.expect_one_of_keywords(&[Keyword::FROM, Keyword::IN])?;
2843 let table_name = self.parse_object_name()?;
2844 let filter = self.parse_show_statement_filter()?;
2848 Ok(Statement::ShowColumns {
2849 extended,
2850 full,
2851 table_name,
2852 filter,
2853 })
2854 }
2855
2856 fn parse_show_statement_filter(&mut self) -> Result<Option<ShowStatementFilter>, ParserError> {
2857 if self.parse_keyword(Keyword::LIKE) {
2858 Ok(Some(ShowStatementFilter::Like(
2859 self.parse_literal_string()?,
2860 )))
2861 } else if self.parse_keyword(Keyword::ILIKE) {
2862 Ok(Some(ShowStatementFilter::ILike(
2863 self.parse_literal_string()?,
2864 )))
2865 } else if self.parse_keyword(Keyword::WHERE) {
2866 Ok(Some(ShowStatementFilter::Where(self.parse_expr()?)))
2867 } else {
2868 Ok(None)
2869 }
2870 }
2871
2872 pub fn parse_table_and_joins(&mut self) -> Result<TableWithJoins, ParserError> {
2873 let relation = self.parse_table_factor()?;
2874
2875 let mut joins = vec![];
2879 loop {
2880 let join = if self.parse_keyword(Keyword::CROSS) {
2881 let join_operator = if self.parse_keyword(Keyword::JOIN) {
2882 JoinOperator::CrossJoin
2883 } else if self.parse_keyword(Keyword::APPLY) {
2884 JoinOperator::CrossApply
2886 } else {
2887 return self.expected("JOIN or APPLY after CROSS", self.peek_token());
2888 };
2889 Join {
2890 relation: self.parse_table_factor()?,
2891 join_operator,
2892 }
2893 } else if self.parse_keyword(Keyword::OUTER) {
2894 self.expect_keyword(Keyword::APPLY)?;
2896 Join {
2897 relation: self.parse_table_factor()?,
2898 join_operator: JoinOperator::OuterApply,
2899 }
2900 } else {
2901 let natural = self.parse_keyword(Keyword::NATURAL);
2902 let peek_keyword = if let Token::Word(w) = self.peek_token() {
2903 w.keyword
2904 } else {
2905 Keyword::NoKeyword
2906 };
2907
2908 let join_operator_type = match peek_keyword {
2909 Keyword::INNER | Keyword::JOIN => {
2910 let _ = self.parse_keyword(Keyword::INNER);
2911 self.expect_keyword(Keyword::JOIN)?;
2912 JoinOperator::Inner
2913 }
2914 kw @ Keyword::LEFT | kw @ Keyword::RIGHT | kw @ Keyword::FULL => {
2915 let _ = self.next_token();
2916 let _ = self.parse_keyword(Keyword::OUTER);
2917 self.expect_keyword(Keyword::JOIN)?;
2918 match kw {
2919 Keyword::LEFT => JoinOperator::LeftOuter,
2920 Keyword::RIGHT => JoinOperator::RightOuter,
2921 Keyword::FULL => JoinOperator::FullOuter,
2922 _ => unreachable!(),
2923 }
2924 }
2925 Keyword::OUTER => {
2926 return self.expected("LEFT, RIGHT, or FULL", self.peek_token());
2927 }
2928 _ if natural => {
2929 return self.expected("a join type after NATURAL", self.peek_token());
2930 }
2931 _ => break,
2932 };
2933 let relation = self.parse_table_factor()?;
2934 let join_constraint = self.parse_join_constraint(natural)?;
2935 Join {
2936 relation,
2937 join_operator: join_operator_type(join_constraint),
2938 }
2939 };
2940 joins.push(join);
2941 }
2942 Ok(TableWithJoins { relation, joins })
2943 }
2944
2945 pub fn parse_table_factor(&mut self) -> Result<TableFactor, ParserError> {
2947 if self.parse_keyword(Keyword::LATERAL) {
2948 if !self.consume_token(&Token::LParen) {
2950 self.expected("subquery after LATERAL", self.peek_token())?;
2951 }
2952 self.parse_derived_table_factor(Lateral)
2953 } else if self.parse_keyword(Keyword::TABLE) {
2954 self.expect_token(&Token::LParen)?;
2956 let expr = self.parse_expr()?;
2957 self.expect_token(&Token::RParen)?;
2958 let alias = self.parse_optional_table_alias(keywords::RESERVED_FOR_TABLE_ALIAS)?;
2959 Ok(TableFactor::TableFunction { expr, alias })
2960 } else if self.consume_token(&Token::LParen) {
2961 return_ok_if_some!(
2983 self.maybe_parse(|parser| parser.parse_derived_table_factor(NotLateral))
2984 );
2985 let mut table_and_joins = self.parse_table_and_joins()?;
2992
2993 #[allow(clippy::if_same_then_else)]
2994 if !table_and_joins.joins.is_empty() {
2995 self.expect_token(&Token::RParen)?;
2996 Ok(TableFactor::NestedJoin(Box::new(table_and_joins))) } else if let TableFactor::NestedJoin(_) = &table_and_joins.relation {
2998 self.expect_token(&Token::RParen)?;
3001 Ok(TableFactor::NestedJoin(Box::new(table_and_joins)))
3002 } else if dialect_of!(self is SnowflakeDialect | GenericDialect) {
3003 self.expect_token(&Token::RParen)?;
3010
3011 if let Some(outer_alias) =
3012 self.parse_optional_table_alias(keywords::RESERVED_FOR_TABLE_ALIAS)?
3013 {
3014 match &mut table_and_joins.relation {
3017 TableFactor::Derived { alias, .. }
3018 | TableFactor::Table { alias, .. }
3019 | TableFactor::TableFunction { alias, .. } => {
3020 if let Some(inner_alias) = alias {
3022 return Err(ParserError::ParserError(format!(
3023 "duplicate alias {}",
3024 inner_alias
3025 )));
3026 }
3027 alias.replace(outer_alias);
3031 }
3032 TableFactor::NestedJoin(_) => unreachable!(),
3033 };
3034 }
3035 Ok(table_and_joins.relation)
3037 } else {
3038 self.expected("joined table", self.peek_token())
3041 }
3042 } else {
3043 let name = self.parse_object_name()?;
3044 let args = if self.consume_token(&Token::LParen) {
3046 self.parse_optional_args()?
3047 } else {
3048 vec![]
3049 };
3050 let alias = self.parse_optional_table_alias(keywords::RESERVED_FOR_TABLE_ALIAS)?;
3051 let mut with_hints = vec![];
3053 if self.parse_keyword(Keyword::WITH) {
3054 if self.consume_token(&Token::LParen) {
3055 with_hints = self.parse_comma_separated(Parser::parse_expr)?;
3056 self.expect_token(&Token::RParen)?;
3057 } else {
3058 self.prev_token();
3060 }
3061 };
3062 Ok(TableFactor::Table {
3063 name,
3064 alias,
3065 args,
3066 with_hints,
3067 })
3068 }
3069 }
3070
3071 pub fn parse_derived_table_factor(
3072 &mut self,
3073 lateral: IsLateral,
3074 ) -> Result<TableFactor, ParserError> {
3075 let subquery = Box::new(self.parse_query()?);
3076 self.expect_token(&Token::RParen)?;
3077 let alias = self.parse_optional_table_alias(keywords::RESERVED_FOR_TABLE_ALIAS)?;
3078 Ok(TableFactor::Derived {
3079 lateral: match lateral {
3080 Lateral => true,
3081 NotLateral => false,
3082 },
3083 subquery,
3084 alias,
3085 })
3086 }
3087
3088 fn parse_join_constraint(&mut self, natural: bool) -> Result<JoinConstraint, ParserError> {
3089 if natural {
3090 Ok(JoinConstraint::Natural)
3091 } else if self.parse_keyword(Keyword::ON) {
3092 let constraint = self.parse_expr()?;
3093 Ok(JoinConstraint::On(constraint))
3094 } else if self.parse_keyword(Keyword::USING) {
3095 let columns = self.parse_parenthesized_column_list(Mandatory)?;
3096 Ok(JoinConstraint::Using(columns))
3097 } else {
3098 Ok(JoinConstraint::None)
3099 }
3101 }
3102
3103 pub fn parse_grant(&mut self) -> Result<Statement, ParserError> {
3105 let (privileges, objects) = self.parse_grant_revoke_privileges_objects()?;
3106
3107 self.expect_keyword(Keyword::TO)?;
3108 let grantees = self.parse_comma_separated(Parser::parse_identifier)?;
3109
3110 let with_grant_option =
3111 self.parse_keywords(&[Keyword::WITH, Keyword::GRANT, Keyword::OPTION]);
3112
3113 let granted_by = self
3114 .parse_keywords(&[Keyword::GRANTED, Keyword::BY])
3115 .then(|| self.parse_identifier().unwrap());
3116
3117 Ok(Statement::Grant {
3118 privileges,
3119 objects,
3120 grantees,
3121 with_grant_option,
3122 granted_by,
3123 })
3124 }
3125
3126 fn parse_grant_revoke_privileges_objects(
3127 &mut self,
3128 ) -> Result<(Privileges, GrantObjects), ParserError> {
3129 let privileges = if self.parse_keyword(Keyword::ALL) {
3130 Privileges::All {
3131 with_privileges_keyword: self.parse_keyword(Keyword::PRIVILEGES),
3132 }
3133 } else {
3134 Privileges::Actions(
3135 self.parse_comma_separated(Parser::parse_grant_permission)?
3136 .into_iter()
3137 .map(|(kw, columns)| match kw {
3138 Keyword::DELETE => Action::Delete,
3139 Keyword::INSERT => Action::Insert { columns },
3140 Keyword::REFERENCES => Action::References { columns },
3141 Keyword::SELECT => Action::Select { columns },
3142 Keyword::TRIGGER => Action::Trigger,
3143 Keyword::TRUNCATE => Action::Truncate,
3144 Keyword::UPDATE => Action::Update { columns },
3145 Keyword::USAGE => Action::Usage,
3146 _ => unreachable!(),
3147 })
3148 .collect(),
3149 )
3150 };
3151
3152 self.expect_keyword(Keyword::ON)?;
3153
3154 let objects = if self.parse_keywords(&[
3155 Keyword::ALL,
3156 Keyword::TABLES,
3157 Keyword::IN,
3158 Keyword::SCHEMA,
3159 ]) {
3160 GrantObjects::AllTablesInSchema {
3161 schemas: self.parse_comma_separated(Parser::parse_object_name)?,
3162 }
3163 } else if self.parse_keywords(&[
3164 Keyword::ALL,
3165 Keyword::SEQUENCES,
3166 Keyword::IN,
3167 Keyword::SCHEMA,
3168 ]) {
3169 GrantObjects::AllSequencesInSchema {
3170 schemas: self.parse_comma_separated(Parser::parse_object_name)?,
3171 }
3172 } else {
3173 let object_type =
3174 self.parse_one_of_keywords(&[Keyword::SEQUENCE, Keyword::SCHEMA, Keyword::TABLE]);
3175 let objects = self.parse_comma_separated(Parser::parse_object_name);
3176 match object_type {
3177 Some(Keyword::SCHEMA) => GrantObjects::Schemas(objects?),
3178 Some(Keyword::SEQUENCE) => GrantObjects::Sequences(objects?),
3179 Some(Keyword::TABLE) | None => GrantObjects::Tables(objects?),
3180 _ => unreachable!(),
3181 }
3182 };
3183
3184 Ok((privileges, objects))
3185 }
3186
3187 fn parse_grant_permission(&mut self) -> Result<(Keyword, Option<Vec<Ident>>), ParserError> {
3188 if let Some(kw) = self.parse_one_of_keywords(&[
3189 Keyword::CONNECT,
3190 Keyword::CREATE,
3191 Keyword::DELETE,
3192 Keyword::EXECUTE,
3193 Keyword::INSERT,
3194 Keyword::REFERENCES,
3195 Keyword::SELECT,
3196 Keyword::TEMPORARY,
3197 Keyword::TRIGGER,
3198 Keyword::TRUNCATE,
3199 Keyword::UPDATE,
3200 Keyword::USAGE,
3201 ]) {
3202 let columns = match kw {
3203 Keyword::INSERT | Keyword::REFERENCES | Keyword::SELECT | Keyword::UPDATE => {
3204 let columns = self.parse_parenthesized_column_list(Optional)?;
3205 if columns.is_empty() {
3206 None
3207 } else {
3208 Some(columns)
3209 }
3210 }
3211 _ => None,
3212 };
3213 Ok((kw, columns))
3214 } else {
3215 self.expected("a privilege keyword", self.peek_token())?
3216 }
3217 }
3218
3219 pub fn parse_revoke(&mut self) -> Result<Statement, ParserError> {
3221 let (privileges, objects) = self.parse_grant_revoke_privileges_objects()?;
3222
3223 self.expect_keyword(Keyword::FROM)?;
3224 let grantees = self.parse_comma_separated(Parser::parse_identifier)?;
3225
3226 let granted_by = self
3227 .parse_keywords(&[Keyword::GRANTED, Keyword::BY])
3228 .then(|| self.parse_identifier().unwrap());
3229
3230 let cascade = self.parse_keyword(Keyword::CASCADE);
3231 let restrict = self.parse_keyword(Keyword::RESTRICT);
3232 if cascade && restrict {
3233 return parser_err!("Cannot specify both CASCADE and RESTRICT in REVOKE");
3234 }
3235
3236 Ok(Statement::Revoke {
3237 privileges,
3238 objects,
3239 grantees,
3240 granted_by,
3241 cascade,
3242 })
3243 }
3244
3245 pub fn parse_insert(&mut self) -> Result<Statement, ParserError> {
3247 let or = if !dialect_of!(self is SQLiteDialect) {
3248 None
3249 } else if self.parse_keywords(&[Keyword::OR, Keyword::REPLACE]) {
3250 Some(SqliteOnConflict::Replace)
3251 } else if self.parse_keywords(&[Keyword::OR, Keyword::ROLLBACK]) {
3252 Some(SqliteOnConflict::Rollback)
3253 } else if self.parse_keywords(&[Keyword::OR, Keyword::ABORT]) {
3254 Some(SqliteOnConflict::Abort)
3255 } else if self.parse_keywords(&[Keyword::OR, Keyword::FAIL]) {
3256 Some(SqliteOnConflict::Fail)
3257 } else if self.parse_keywords(&[Keyword::OR, Keyword::IGNORE]) {
3258 Some(SqliteOnConflict::Ignore)
3259 } else if self.parse_keyword(Keyword::REPLACE) {
3260 Some(SqliteOnConflict::Replace)
3261 } else {
3262 None
3263 };
3264 let action = self.expect_one_of_keywords(&[Keyword::INTO, Keyword::OVERWRITE])?;
3265 let overwrite = action == Keyword::OVERWRITE;
3266 let local = self.parse_keyword(Keyword::LOCAL);
3267
3268 if self.parse_keyword(Keyword::DIRECTORY) {
3269 let path = self.parse_literal_string()?;
3270 let file_format = if self.parse_keywords(&[Keyword::STORED, Keyword::AS]) {
3271 Some(self.parse_file_format()?)
3272 } else {
3273 None
3274 };
3275 let source = Box::new(self.parse_query()?);
3276 Ok(Statement::Directory {
3277 local,
3278 path,
3279 overwrite,
3280 file_format,
3281 source,
3282 })
3283 } else {
3284 let table = self.parse_keyword(Keyword::TABLE);
3286 let table_name = self.parse_object_name()?;
3287 let columns = self.parse_parenthesized_column_list(Optional)?;
3288
3289 let partitioned = if self.parse_keyword(Keyword::PARTITION) {
3290 self.expect_token(&Token::LParen)?;
3291 let r = Some(self.parse_comma_separated(Parser::parse_expr)?);
3292 self.expect_token(&Token::RParen)?;
3293 r
3294 } else {
3295 None
3296 };
3297
3298 let after_columns = self.parse_parenthesized_column_list(Optional)?;
3300
3301 let source = Box::new(self.parse_query()?);
3302 let on = if self.parse_keyword(Keyword::ON) {
3303 self.expect_keyword(Keyword::DUPLICATE)?;
3304 self.expect_keyword(Keyword::KEY)?;
3305 self.expect_keyword(Keyword::UPDATE)?;
3306 let l = self.parse_comma_separated(Parser::parse_assignment)?;
3307
3308 Some(OnInsert::DuplicateKeyUpdate(l))
3309 } else {
3310 None
3311 };
3312
3313 Ok(Statement::Insert {
3314 or,
3315 table_name,
3316 overwrite,
3317 partitioned,
3318 columns,
3319 after_columns,
3320 source,
3321 table,
3322 on,
3323 })
3324 }
3325 }
3326
3327 pub fn parse_update(&mut self) -> Result<Statement, ParserError> {
3328 let table = self.parse_table_and_joins()?;
3329 self.expect_keyword(Keyword::SET)?;
3330 let assignments = self.parse_comma_separated(Parser::parse_assignment)?;
3331 let selection = if self.parse_keyword(Keyword::WHERE) {
3332 Some(self.parse_expr()?)
3333 } else {
3334 None
3335 };
3336 Ok(Statement::Update {
3337 table,
3338 assignments,
3339 selection,
3340 })
3341 }
3342
3343 pub fn parse_assignment(&mut self) -> Result<Assignment, ParserError> {
3345 let id = self.parse_identifiers_non_keywords()?;
3346 self.expect_token(&Token::Eq)?;
3347 let value = self.parse_expr()?;
3348 Ok(Assignment { id, value })
3349 }
3350
3351 fn parse_function_args(&mut self) -> Result<FunctionArg, ParserError> {
3352 if self.peek_nth_token(1) == Token::RArrow {
3353 let name = self.parse_identifier()?;
3354
3355 self.expect_token(&Token::RArrow)?;
3356 let arg = self.parse_wildcard_expr()?.into();
3357
3358 Ok(FunctionArg::Named { name, arg })
3359 } else {
3360 Ok(FunctionArg::Unnamed(self.parse_wildcard_expr()?.into()))
3361 }
3362 }
3363
3364 pub fn parse_optional_args(&mut self) -> Result<Vec<FunctionArg>, ParserError> {
3365 if self.consume_token(&Token::RParen) {
3366 Ok(vec![])
3367 } else {
3368 let args = self.parse_comma_separated(Parser::parse_function_args)?;
3369 self.expect_token(&Token::RParen)?;
3370 Ok(args)
3371 }
3372 }
3373
3374 pub fn parse_select_item(&mut self) -> Result<SelectItem, ParserError> {
3376 match self.parse_wildcard_expr()? {
3377 WildcardExpr::Expr(expr) => self
3378 .parse_optional_alias(keywords::RESERVED_FOR_COLUMN_ALIAS)
3379 .map(|alias| match alias {
3380 Some(alias) => SelectItem::ExprWithAlias { expr, alias },
3381 None => SelectItem::UnnamedExpr(expr),
3382 }),
3383 WildcardExpr::QualifiedWildcard(prefix) => Ok(SelectItem::QualifiedWildcard(prefix)),
3384 WildcardExpr::Wildcard => Ok(SelectItem::Wildcard),
3385 }
3386 }
3387
3388 pub fn parse_order_by_expr(&mut self) -> Result<OrderByExpr, ParserError> {
3390 let expr = self.parse_expr()?;
3391
3392 let asc = if self.parse_keyword(Keyword::ASC) {
3393 Some(true)
3394 } else if self.parse_keyword(Keyword::DESC) {
3395 Some(false)
3396 } else {
3397 None
3398 };
3399
3400 let nulls_first = if self.parse_keywords(&[Keyword::NULLS, Keyword::FIRST]) {
3401 Some(true)
3402 } else if self.parse_keywords(&[Keyword::NULLS, Keyword::LAST]) {
3403 Some(false)
3404 } else {
3405 None
3406 };
3407
3408 Ok(OrderByExpr {
3409 expr,
3410 asc,
3411 nulls_first,
3412 })
3413 }
3414
3415 pub fn parse_top(&mut self) -> Result<Top, ParserError> {
3418 let quantity = if self.consume_token(&Token::LParen) {
3419 let quantity = self.parse_expr()?;
3420 self.expect_token(&Token::RParen)?;
3421 Some(quantity)
3422 } else {
3423 Some(Expr::Value(self.parse_number_value()?))
3424 };
3425
3426 let percent = self.parse_keyword(Keyword::PERCENT);
3427
3428 let with_ties = self.parse_keywords(&[Keyword::WITH, Keyword::TIES]);
3429
3430 Ok(Top {
3431 with_ties,
3432 percent,
3433 quantity,
3434 })
3435 }
3436
3437 pub fn parse_limit(&mut self) -> Result<Option<Expr>, ParserError> {
3439 if self.parse_keyword(Keyword::ALL) {
3440 Ok(None)
3441 } else {
3442 Ok(Some(Expr::Value(self.parse_number_value()?)))
3443 }
3444 }
3445
3446 pub fn parse_offset(&mut self) -> Result<Offset, ParserError> {
3448 let value = Expr::Value(self.parse_number_value()?);
3449 let rows = if self.parse_keyword(Keyword::ROW) {
3450 OffsetRows::Row
3451 } else if self.parse_keyword(Keyword::ROWS) {
3452 OffsetRows::Rows
3453 } else {
3454 OffsetRows::None
3455 };
3456 Ok(Offset { value, rows })
3457 }
3458
3459 pub fn parse_fetch(&mut self) -> Result<Fetch, ParserError> {
3461 self.expect_one_of_keywords(&[Keyword::FIRST, Keyword::NEXT])?;
3462 let (quantity, percent) = if self
3463 .parse_one_of_keywords(&[Keyword::ROW, Keyword::ROWS])
3464 .is_some()
3465 {
3466 (None, false)
3467 } else {
3468 let quantity = Expr::Value(self.parse_value()?);
3469 let percent = self.parse_keyword(Keyword::PERCENT);
3470 self.expect_one_of_keywords(&[Keyword::ROW, Keyword::ROWS])?;
3471 (Some(quantity), percent)
3472 };
3473 let with_ties = if self.parse_keyword(Keyword::ONLY) {
3474 false
3475 } else if self.parse_keywords(&[Keyword::WITH, Keyword::TIES]) {
3476 true
3477 } else {
3478 return self.expected("one of ONLY or WITH TIES", self.peek_token());
3479 };
3480 Ok(Fetch {
3481 with_ties,
3482 percent,
3483 quantity,
3484 })
3485 }
3486
3487 pub fn parse_lock(&mut self) -> Result<LockType, ParserError> {
3489 match self.expect_one_of_keywords(&[Keyword::UPDATE, Keyword::SHARE])? {
3490 Keyword::UPDATE => Ok(LockType::Exclusive),
3491 Keyword::SHARE => Ok(LockType::Shared),
3492 _ => unreachable!(),
3493 }
3494 }
3495
3496 pub fn parse_values(&mut self) -> Result<Values, ParserError> {
3497 let values = self.parse_comma_separated(|parser| {
3498 parser.expect_token(&Token::LParen)?;
3499 let exprs = parser.parse_comma_separated(Parser::parse_expr)?;
3500 parser.expect_token(&Token::RParen)?;
3501 Ok(exprs)
3502 })?;
3503 Ok(Values(values))
3504 }
3505
3506 pub fn parse_start_transaction(&mut self) -> Result<Statement, ParserError> {
3507 self.expect_keyword(Keyword::TRANSACTION)?;
3508 Ok(Statement::StartTransaction {
3509 modes: self.parse_transaction_modes()?,
3510 })
3511 }
3512
3513 pub fn parse_begin(&mut self) -> Result<Statement, ParserError> {
3514 let _ = self.parse_one_of_keywords(&[Keyword::TRANSACTION, Keyword::WORK]);
3515 Ok(Statement::StartTransaction {
3516 modes: self.parse_transaction_modes()?,
3517 })
3518 }
3519
3520 pub fn parse_transaction_modes(&mut self) -> Result<Vec<TransactionMode>, ParserError> {
3521 let mut modes = vec![];
3522 let mut required = false;
3523 loop {
3524 let mode = if self.parse_keywords(&[Keyword::ISOLATION, Keyword::LEVEL]) {
3525 let iso_level = if self.parse_keywords(&[Keyword::READ, Keyword::UNCOMMITTED]) {
3526 TransactionIsolationLevel::ReadUncommitted
3527 } else if self.parse_keywords(&[Keyword::READ, Keyword::COMMITTED]) {
3528 TransactionIsolationLevel::ReadCommitted
3529 } else if self.parse_keywords(&[Keyword::REPEATABLE, Keyword::READ]) {
3530 TransactionIsolationLevel::RepeatableRead
3531 } else if self.parse_keyword(Keyword::SERIALIZABLE) {
3532 TransactionIsolationLevel::Serializable
3533 } else {
3534 self.expected("isolation level", self.peek_token())?
3535 };
3536 TransactionMode::IsolationLevel(iso_level)
3537 } else if self.parse_keywords(&[Keyword::READ, Keyword::ONLY]) {
3538 TransactionMode::AccessMode(TransactionAccessMode::ReadOnly)
3539 } else if self.parse_keywords(&[Keyword::READ, Keyword::WRITE]) {
3540 TransactionMode::AccessMode(TransactionAccessMode::ReadWrite)
3541 } else if required {
3542 self.expected("transaction mode", self.peek_token())?
3543 } else {
3544 break;
3545 };
3546 modes.push(mode);
3547 required = self.consume_token(&Token::Comma);
3552 }
3553 Ok(modes)
3554 }
3555
3556 pub fn parse_commit(&mut self) -> Result<Statement, ParserError> {
3557 Ok(Statement::Commit {
3558 chain: self.parse_commit_rollback_chain()?,
3559 })
3560 }
3561
3562 pub fn parse_rollback(&mut self) -> Result<Statement, ParserError> {
3563 Ok(Statement::Rollback {
3564 chain: self.parse_commit_rollback_chain()?,
3565 })
3566 }
3567
3568 pub fn parse_commit_rollback_chain(&mut self) -> Result<bool, ParserError> {
3569 let _ = self.parse_one_of_keywords(&[Keyword::TRANSACTION, Keyword::WORK]);
3570 if self.parse_keyword(Keyword::AND) {
3571 let chain = !self.parse_keyword(Keyword::NO);
3572 self.expect_keyword(Keyword::CHAIN)?;
3573 Ok(chain)
3574 } else {
3575 Ok(false)
3576 }
3577 }
3578
3579 fn parse_deallocate(&mut self) -> Result<Statement, ParserError> {
3580 let prepare = self.parse_keyword(Keyword::PREPARE);
3581 let name = self.parse_identifier()?;
3582 Ok(Statement::Deallocate { name, prepare })
3583 }
3584
3585 fn parse_execute(&mut self) -> Result<Statement, ParserError> {
3586 let name = self.parse_identifier()?;
3587
3588 let mut parameters = vec![];
3589 if self.consume_token(&Token::LParen) {
3590 parameters = self.parse_comma_separated(Parser::parse_expr)?;
3591 self.expect_token(&Token::RParen)?;
3592 }
3593
3594 Ok(Statement::Execute { name, parameters })
3595 }
3596
3597 fn parse_prepare(&mut self) -> Result<Statement, ParserError> {
3598 let name = self.parse_identifier()?;
3599
3600 let mut data_types = vec![];
3601 if self.consume_token(&Token::LParen) {
3602 data_types = self.parse_comma_separated(Parser::parse_data_type)?;
3603 self.expect_token(&Token::RParen)?;
3604 }
3605
3606 self.expect_keyword(Keyword::AS)?;
3607 let statement = Box::new(self.parse_statement()?);
3608 Ok(Statement::Prepare {
3609 name,
3610 data_types,
3611 statement,
3612 })
3613 }
3614
3615 fn parse_comment(&mut self) -> Result<Statement, ParserError> {
3616 self.expect_keyword(Keyword::ON)?;
3617 let token = self.next_token();
3618
3619 let (object_type, object_name) = match token {
3620 Token::Word(w) if w.keyword == Keyword::COLUMN => {
3621 let object_name = self.parse_object_name()?;
3622 (CommentObject::Column, object_name)
3623 }
3624 Token::Word(w) if w.keyword == Keyword::TABLE => {
3625 let object_name = self.parse_object_name()?;
3626 (CommentObject::Table, object_name)
3627 }
3628 _ => self.expected("comment object_type", token)?,
3629 };
3630
3631 self.expect_keyword(Keyword::IS)?;
3632 let comment = if self.parse_keyword(Keyword::NULL) {
3633 None
3634 } else {
3635 Some(self.parse_literal_string()?)
3636 };
3637 Ok(Statement::Comment {
3638 object_type,
3639 object_name,
3640 comment,
3641 })
3642 }
3643}
3644
3645impl Word {
3646 pub fn to_ident(&self) -> Ident {
3647 Ident {
3648 value: self.value.clone(),
3649 quote_style: self.quote_style,
3650 }
3651 }
3652}
3653
3654#[cfg(test)]
3655mod tests {
3656 use super::*;
3657 use crate::test_utils::all_dialects;
3658
3659 #[test]
3660 fn test_prev_index() {
3661 let sql = "SELECT version";
3662 all_dialects().run_parser_method(sql, |parser| {
3663 assert_eq!(parser.peek_token(), Token::make_keyword("SELECT"));
3664 assert_eq!(parser.next_token(), Token::make_keyword("SELECT"));
3665 parser.prev_token();
3666 assert_eq!(parser.next_token(), Token::make_keyword("SELECT"));
3667 assert_eq!(parser.next_token(), Token::make_word("version", None));
3668 parser.prev_token();
3669 assert_eq!(parser.peek_token(), Token::make_word("version", None));
3670 assert_eq!(parser.next_token(), Token::make_word("version", None));
3671 assert_eq!(parser.peek_token(), Token::EOF);
3672 parser.prev_token();
3673 assert_eq!(parser.next_token(), Token::make_word("version", None));
3674 assert_eq!(parser.next_token(), Token::EOF);
3675 assert_eq!(parser.next_token(), Token::EOF);
3676 parser.prev_token();
3677 });
3678 }
3679}