1use crate::ast::*;
2use crate::errors::{Result, SqlglotError};
3use crate::tokens::{Token, TokenType, Tokenizer};
4
5fn quote_style_from_char(c: char) -> QuoteStyle {
7 match c {
8 '"' => QuoteStyle::DoubleQuote,
9 '`' => QuoteStyle::Backtick,
10 '[' => QuoteStyle::Bracket,
11 _ => QuoteStyle::None,
12 }
13}
14
15pub struct Parser {
20 tokens: Vec<Token>,
21 pos: usize,
22}
23
24impl Parser {
25 pub fn new(sql: &str) -> Result<Self> {
27 let mut tokenizer = Tokenizer::new(sql);
28 let tokens = tokenizer.tokenize()?;
29 Ok(Self { tokens, pos: 0 })
30 }
31
32 fn peek(&self) -> &Token {
35 &self.tokens[self.pos.min(self.tokens.len() - 1)]
36 }
37
38 fn peek_type(&self) -> &TokenType {
39 &self.peek().token_type
40 }
41
42 fn advance(&mut self) -> &Token {
43 let token = &self.tokens[self.pos.min(self.tokens.len() - 1)];
44 if self.pos < self.tokens.len() {
45 self.pos += 1;
46 }
47 token
48 }
49
50 fn expect(&mut self, expected: TokenType) -> Result<Token> {
51 let token = self.peek().clone();
52 if token.token_type == expected {
53 self.advance();
54 Ok(token)
55 } else {
56 Err(SqlglotError::ParserError {
57 message: format!(
58 "Expected {expected:?}, got {:?} ('{}') at line {} col {}",
59 token.token_type, token.value, token.line, token.col
60 ),
61 })
62 }
63 }
64
65 fn match_token(&mut self, expected: TokenType) -> bool {
66 if self.peek().token_type == expected {
67 self.advance();
68 true
69 } else {
70 false
71 }
72 }
73
74 fn check_keyword(&self, keyword: &str) -> bool {
76 self.peek().value.to_uppercase() == keyword
77 }
78
79 fn match_keyword(&mut self, keyword: &str) -> bool {
81 if self.check_keyword(keyword) {
82 self.advance();
83 true
84 } else {
85 false
86 }
87 }
88
89 fn is_name_token(&self) -> bool {
91 matches!(
92 self.peek_type(),
93 TokenType::Identifier
94 | TokenType::Year
95 | TokenType::Month
96 | TokenType::Day
97 | TokenType::Hour
98 | TokenType::Minute
99 | TokenType::Second
100 | TokenType::Key
101 | TokenType::Filter
102 | TokenType::First
103 | TokenType::Next
104 | TokenType::Only
105 | TokenType::Respect
106 | TokenType::Epoch
107 | TokenType::Schema
108 | TokenType::Database
109 | TokenType::View
110 | TokenType::Collate
111 | TokenType::Comment
112 | TokenType::Left
113 | TokenType::Right
114 | TokenType::Replace
115 | TokenType::Cube
116 | TokenType::Rollup
117 | TokenType::Grouping
118 | TokenType::Sets
119 )
120 }
121
122 fn expect_name(&mut self) -> Result<String> {
124 let (name, _) = self.expect_name_with_quote()?;
125 Ok(name)
126 }
127
128 fn expect_name_with_quote(&mut self) -> Result<(String, QuoteStyle)> {
130 if self.is_name_token() {
131 let token = self.advance().clone();
132 let qs = quote_style_from_char(token.quote_char);
133 return Ok((token.value.clone(), qs));
134 }
135 let token = self.peek().clone();
137 if matches!(
138 token.token_type,
139 TokenType::Identifier
140 | TokenType::Int
141 | TokenType::Integer
142 | TokenType::BigInt
143 | TokenType::SmallInt
144 | TokenType::TinyInt
145 | TokenType::Float
146 | TokenType::Double
147 | TokenType::Decimal
148 | TokenType::Numeric
149 | TokenType::Real
150 | TokenType::Varchar
151 | TokenType::Char
152 | TokenType::Text
153 | TokenType::Boolean
154 | TokenType::Date
155 | TokenType::Timestamp
156 | TokenType::TimestampTz
157 | TokenType::Time
158 | TokenType::Interval
159 | TokenType::Blob
160 | TokenType::Bytea
161 | TokenType::Json
162 | TokenType::Jsonb
163 | TokenType::Uuid
164 | TokenType::Array
165 | TokenType::Map
166 | TokenType::Struct
167 ) {
168 let t = self.advance().clone();
169 let qs = quote_style_from_char(t.quote_char);
170 Ok((t.value.clone(), qs))
171 } else {
172 Err(SqlglotError::ParserError {
173 message: format!(
174 "Expected identifier, got {:?} ('{}') at line {} col {}",
175 token.token_type, token.value, token.line, token.col
176 ),
177 })
178 }
179 }
180
181 pub fn parse_statement(&mut self) -> Result<Statement> {
185 let stmt = self.parse_statement_inner()?;
186 while self.match_token(TokenType::Semicolon) {}
188 Ok(stmt)
189 }
190
191 fn parse_statement_inner(&mut self) -> Result<Statement> {
192 match self.peek_type() {
193 TokenType::With => self.parse_with_statement(),
194 TokenType::Select => {
195 let select = self.parse_select_body(vec![])?;
196 self.maybe_parse_set_operation(Statement::Select(select))
197 }
198 TokenType::LParen => {
199 let saved_pos = self.pos;
201 self.advance(); if matches!(self.peek_type(), TokenType::Select | TokenType::With) {
203 let inner = self.parse_statement_inner()?;
204 self.expect(TokenType::RParen)?;
205 self.maybe_parse_set_operation(inner)
206 } else {
207 self.pos = saved_pos;
208 Err(SqlglotError::ParserError {
209 message: "Expected statement".into(),
210 })
211 }
212 }
213 TokenType::Insert => self.parse_insert().map(Statement::Insert),
214 TokenType::Update => self.parse_update().map(Statement::Update),
215 TokenType::Delete => self.parse_delete().map(Statement::Delete),
216 TokenType::Create => self.parse_create(),
217 TokenType::Drop => self.parse_drop(),
218 TokenType::Alter => self.parse_alter_table().map(Statement::AlterTable),
219 TokenType::Truncate => self.parse_truncate().map(Statement::Truncate),
220 TokenType::Begin | TokenType::Commit | TokenType::Rollback | TokenType::Savepoint => {
221 self.parse_transaction().map(Statement::Transaction)
222 }
223 TokenType::Explain => self.parse_explain().map(Statement::Explain),
224 TokenType::Use => self.parse_use().map(Statement::Use),
225 _ => Err(SqlglotError::UnexpectedToken {
226 token: self.peek().clone(),
227 }),
228 }
229 }
230
231 pub fn parse_statements(&mut self) -> Result<Vec<Statement>> {
233 let mut stmts = Vec::new();
234 while !matches!(self.peek_type(), TokenType::Eof) {
235 while self.match_token(TokenType::Semicolon) {}
236 if matches!(self.peek_type(), TokenType::Eof) {
237 break;
238 }
239 stmts.push(self.parse_statement()?);
240 }
241 Ok(stmts)
242 }
243
244 fn parse_with_statement(&mut self) -> Result<Statement> {
247 self.expect(TokenType::With)?;
248 let recursive = self.match_token(TokenType::Recursive);
249 let mut ctes = vec![self.parse_cte(recursive)?];
250 while self.match_token(TokenType::Comma) {
251 ctes.push(self.parse_cte(recursive)?);
252 }
253
254 match self.peek_type() {
256 TokenType::Select => {
257 let select = self.parse_select_body(ctes)?;
258 self.maybe_parse_set_operation(Statement::Select(select))
259 }
260 TokenType::Insert => {
261 let ins = self.parse_insert()?;
263 let _ = ctes; Ok(Statement::Insert(ins))
266 }
267 _ => Err(SqlglotError::ParserError {
268 message: "Expected SELECT or INSERT after WITH clause".into(),
269 }),
270 }
271 }
272
273 fn parse_cte(&mut self, recursive: bool) -> Result<Cte> {
274 let name = self.expect_name()?;
275
276 let columns = if self.match_token(TokenType::LParen) {
277 let mut cols = vec![self.expect_name()?];
278 while self.match_token(TokenType::Comma) {
279 cols.push(self.expect_name()?);
280 }
281 self.expect(TokenType::RParen)?;
282 cols
283 } else {
284 vec![]
285 };
286
287 self.expect(TokenType::As)?;
288
289 let materialized = if self.match_keyword("MATERIALIZED") {
290 Some(true)
291 } else if self.check_keyword("NOT") {
292 let saved = self.pos;
293 self.advance();
294 if self.match_keyword("MATERIALIZED") {
295 Some(false)
296 } else {
297 self.pos = saved;
298 None
299 }
300 } else {
301 None
302 };
303
304 self.expect(TokenType::LParen)?;
305 let query = self.parse_statement_inner()?;
306 self.expect(TokenType::RParen)?;
307
308 Ok(Cte {
309 name,
310 columns,
311 query: Box::new(query),
312 materialized,
313 recursive,
314 })
315 }
316
317 fn parse_select_body(&mut self, ctes: Vec<Cte>) -> Result<SelectStatement> {
320 self.expect(TokenType::Select)?;
321
322 let distinct = self.match_token(TokenType::Distinct);
323
324 let top = if self.match_token(TokenType::Top) {
329 Some(Box::new(self.parse_primary()?))
330 } else {
331 None
332 };
333
334 let columns = self.parse_select_items()?;
335
336 let from = if self.match_token(TokenType::From) {
337 Some(FromClause {
338 source: self.parse_table_source()?,
339 })
340 } else {
341 None
342 };
343
344 let joins = self.parse_joins()?;
345
346 let where_clause = if self.match_token(TokenType::Where) {
347 Some(self.parse_expr()?)
348 } else {
349 None
350 };
351
352 let group_by = if self.match_token(TokenType::Group) {
353 self.expect(TokenType::By)?;
354 self.parse_group_by_list()?
355 } else {
356 vec![]
357 };
358
359 let having = if self.match_token(TokenType::Having) {
360 Some(self.parse_expr()?)
361 } else {
362 None
363 };
364
365 let qualify = if self.match_token(TokenType::Qualify) {
366 Some(self.parse_expr()?)
367 } else {
368 None
369 };
370
371 let window_definitions = if self.match_token(TokenType::Window) {
373 self.parse_window_definitions()?
374 } else {
375 vec![]
376 };
377
378 let order_by = if self.match_token(TokenType::Order) {
379 self.expect(TokenType::By)?;
380 self.parse_order_by_items()?
381 } else {
382 vec![]
383 };
384
385 let limit = if self.match_token(TokenType::Limit) {
386 Some(self.parse_expr()?)
387 } else {
388 None
389 };
390
391 let offset = if self.match_token(TokenType::Offset) {
392 Some(self.parse_expr()?)
393 } else {
394 None
395 };
396
397 let fetch_first = if self.match_token(TokenType::Fetch) {
399 let _ = self.match_token(TokenType::First) || self.match_token(TokenType::Next);
401 let count = self.parse_expr()?;
402 let _ = self.match_keyword("ROWS") || self.match_keyword("ROW");
404 let _ = self.match_token(TokenType::Only);
406 Some(count)
407 } else {
408 None
409 };
410
411 Ok(SelectStatement {
412 ctes,
413 distinct,
414 top,
415 columns,
416 from,
417 joins,
418 where_clause,
419 group_by,
420 having,
421 order_by,
422 limit,
423 offset,
424 fetch_first,
425 qualify,
426 window_definitions,
427 })
428 }
429
430 fn parse_window_definitions(&mut self) -> Result<Vec<WindowDefinition>> {
431 let mut defs = Vec::new();
432 loop {
433 let name = self.expect_name()?;
434 self.expect(TokenType::As)?;
435 self.expect(TokenType::LParen)?;
436 let spec = self.parse_window_spec()?;
437 self.expect(TokenType::RParen)?;
438 defs.push(WindowDefinition { name, spec });
439 if !self.match_token(TokenType::Comma) {
440 break;
441 }
442 }
443 Ok(defs)
444 }
445
446 fn maybe_parse_set_operation(&mut self, left: Statement) -> Result<Statement> {
448 let op = match self.peek_type() {
449 TokenType::Union => SetOperationType::Union,
450 TokenType::Intersect => SetOperationType::Intersect,
451 TokenType::Except => SetOperationType::Except,
452 _ => return Ok(left),
453 };
454 self.advance();
455
456 let all = self.match_token(TokenType::All);
457 let _ = self.match_token(TokenType::Distinct); let right = self.parse_statement_inner()?;
460
461 let combined = Statement::SetOperation(SetOperationStatement {
463 op,
464 all,
465 left: Box::new(left),
466 right: Box::new(right),
467 order_by: vec![],
468 limit: None,
469 offset: None,
470 });
471
472 if matches!(
474 self.peek_type(),
475 TokenType::Union | TokenType::Intersect | TokenType::Except
476 ) {
477 self.maybe_parse_set_operation(combined)
478 } else {
479 if let Statement::SetOperation(mut sop) = combined {
481 if self.match_token(TokenType::Order) {
482 self.expect(TokenType::By)?;
483 sop.order_by = self.parse_order_by_items()?;
484 }
485 if self.match_token(TokenType::Limit) {
486 sop.limit = Some(self.parse_expr()?);
487 }
488 if self.match_token(TokenType::Offset) {
489 sop.offset = Some(self.parse_expr()?);
490 }
491 Ok(Statement::SetOperation(sop))
492 } else {
493 Ok(combined)
494 }
495 }
496 }
497
498 fn parse_select_items(&mut self) -> Result<Vec<SelectItem>> {
499 let mut items = vec![self.parse_select_item()?];
500 while self.match_token(TokenType::Comma) {
501 items.push(self.parse_select_item()?);
502 }
503 Ok(items)
504 }
505
506 fn parse_select_item(&mut self) -> Result<SelectItem> {
507 if self.peek().token_type == TokenType::Star {
508 self.advance();
509 return Ok(SelectItem::Wildcard);
510 }
511
512 let expr = self.parse_expr()?;
513
514 if let Expr::QualifiedWildcard { ref table } = expr {
516 return Ok(SelectItem::QualifiedWildcard {
517 table: table.clone(),
518 });
519 }
520
521 let alias = self.parse_optional_alias()?;
522
523 Ok(SelectItem::Expr { expr, alias })
524 }
525
526 fn parse_optional_alias(&mut self) -> Result<Option<String>> {
527 if self.match_token(TokenType::As) {
528 return Ok(Some(self.expect_name()?));
529 }
530 if self.is_name_token() {
532 let peeked_upper = self.peek().value.to_uppercase();
533 if !matches!(
534 peeked_upper.as_str(),
535 "FROM"
536 | "WHERE"
537 | "GROUP"
538 | "ORDER"
539 | "LIMIT"
540 | "HAVING"
541 | "UNION"
542 | "INTERSECT"
543 | "EXCEPT"
544 | "JOIN"
545 | "INNER"
546 | "LEFT"
547 | "RIGHT"
548 | "FULL"
549 | "CROSS"
550 | "ON"
551 | "WINDOW"
552 | "QUALIFY"
553 | "INTO"
554 | "SET"
555 | "RETURNING"
556 ) {
557 return Ok(Some(self.advance().value.clone()));
558 }
559 }
560 Ok(None)
561 }
562
563 fn parse_table_source(&mut self) -> Result<TableSource> {
564 if self.match_token(TokenType::Lateral) {
566 let source = self.parse_table_source()?;
567 return Ok(TableSource::Lateral {
568 source: Box::new(source),
569 });
570 }
571
572 if self.match_token(TokenType::Unnest) {
574 self.expect(TokenType::LParen)?;
575 let expr = self.parse_expr()?;
576 self.expect(TokenType::RParen)?;
577 let alias = self.parse_optional_alias()?;
578 let with_offset = self.match_keyword("WITH") && self.match_keyword("OFFSET");
579 return Ok(TableSource::Unnest {
580 expr: Box::new(expr),
581 alias,
582 with_offset,
583 });
584 }
585
586 if self.peek_type() == &TokenType::LParen {
588 let saved = self.pos;
589 self.advance();
590 if matches!(self.peek_type(), TokenType::Select | TokenType::With) {
591 let query = self.parse_statement_inner()?;
592 self.expect(TokenType::RParen)?;
593 let alias = self.parse_optional_alias()?;
594 return Ok(TableSource::Subquery {
595 query: Box::new(query),
596 alias,
597 });
598 }
599 self.pos = saved;
600 }
601
602 let table_ref = self.parse_table_ref()?;
604
605 if self.peek_type() == &TokenType::LParen && table_ref.schema.is_none() {
607 self.advance();
608 let args = if self.peek_type() != &TokenType::RParen {
609 self.parse_expr_list()?
610 } else {
611 vec![]
612 };
613 self.expect(TokenType::RParen)?;
614 let alias = self.parse_optional_alias()?;
615 return Ok(TableSource::TableFunction {
616 name: table_ref.name,
617 args,
618 alias,
619 });
620 }
621
622 Ok(TableSource::Table(table_ref))
623 }
624
625 fn parse_table_ref(&mut self) -> Result<TableRef> {
626 let (first, first_qs) = self.expect_name_with_quote()?;
627
628 let (catalog, schema, name, name_qs) = if self.match_token(TokenType::Dot) {
630 let (second, second_qs) = self.expect_name_with_quote()?;
631 if self.match_token(TokenType::Dot) {
632 let (third, third_qs) = self.expect_name_with_quote()?;
633 (Some(first), Some(second), third, third_qs)
634 } else {
635 (None, Some(first), second, second_qs)
636 }
637 } else {
638 (None, None, first, first_qs)
639 };
640
641 let alias = self.parse_optional_alias()?;
642
643 Ok(TableRef {
644 catalog,
645 schema,
646 name,
647 alias,
648 name_quote_style: name_qs,
649 })
650 }
651
652 fn parse_table_ref_no_alias(&mut self) -> Result<TableRef> {
654 let (first, first_qs) = self.expect_name_with_quote()?;
655
656 let (catalog, schema, name, name_qs) = if self.match_token(TokenType::Dot) {
657 let (second, second_qs) = self.expect_name_with_quote()?;
658 if self.match_token(TokenType::Dot) {
659 let (third, third_qs) = self.expect_name_with_quote()?;
660 (Some(first), Some(second), third, third_qs)
661 } else {
662 (None, Some(first), second, second_qs)
663 }
664 } else {
665 (None, None, first, first_qs)
666 };
667
668 Ok(TableRef {
669 catalog,
670 schema,
671 name,
672 alias: None,
673 name_quote_style: name_qs,
674 })
675 }
676
677 fn parse_joins(&mut self) -> Result<Vec<JoinClause>> {
678 let mut joins = Vec::new();
679 loop {
680 let join_type = match self.peek_type() {
681 TokenType::Join => {
682 self.advance();
683 JoinType::Inner
684 }
685 TokenType::Inner => {
686 self.advance();
687 self.expect(TokenType::Join)?;
688 JoinType::Inner
689 }
690 TokenType::Left => {
691 self.advance();
692 let _ = self.match_token(TokenType::Outer);
693 self.expect(TokenType::Join)?;
694 JoinType::Left
695 }
696 TokenType::Right => {
697 self.advance();
698 let _ = self.match_token(TokenType::Outer);
699 self.expect(TokenType::Join)?;
700 JoinType::Right
701 }
702 TokenType::Full => {
703 self.advance();
704 let _ = self.match_token(TokenType::Outer);
705 self.expect(TokenType::Join)?;
706 JoinType::Full
707 }
708 TokenType::Cross => {
709 self.advance();
710 self.expect(TokenType::Join)?;
711 JoinType::Cross
712 }
713 _ => break,
714 };
715
716 let table = self.parse_table_source()?;
717 let mut on = None;
718 let mut using = vec![];
719
720 if self.match_token(TokenType::On) {
721 on = Some(self.parse_expr()?);
722 } else if self.match_token(TokenType::Using) {
723 self.expect(TokenType::LParen)?;
724 using = vec![self.expect_name()?];
725 while self.match_token(TokenType::Comma) {
726 using.push(self.expect_name()?);
727 }
728 self.expect(TokenType::RParen)?;
729 }
730
731 joins.push(JoinClause {
732 join_type,
733 table,
734 on,
735 using,
736 });
737 }
738 Ok(joins)
739 }
740
741 fn parse_order_by_items(&mut self) -> Result<Vec<OrderByItem>> {
742 let mut items = Vec::new();
743 loop {
744 let expr = self.parse_expr()?;
745 let ascending = if self.match_token(TokenType::Desc) {
746 false
747 } else {
748 let _ = self.match_token(TokenType::Asc);
749 true
750 };
751
752 let nulls_first = if self.match_token(TokenType::Nulls) {
753 if self.match_token(TokenType::First) {
754 Some(true)
755 } else {
756 self.expect(TokenType::Identifier)?; Some(false)
758 }
759 } else {
760 None
761 };
762
763 items.push(OrderByItem {
764 expr,
765 ascending,
766 nulls_first,
767 });
768 if !self.match_token(TokenType::Comma) {
769 break;
770 }
771 }
772 Ok(items)
773 }
774
775 fn parse_expr_list(&mut self) -> Result<Vec<Expr>> {
776 let mut exprs = vec![self.parse_expr()?];
777 while self.match_token(TokenType::Comma) {
778 exprs.push(self.parse_expr()?);
779 }
780 Ok(exprs)
781 }
782
783 fn parse_group_by_list(&mut self) -> Result<Vec<Expr>> {
786 let mut items = vec![self.parse_group_by_item()?];
787 while self.match_token(TokenType::Comma) {
788 items.push(self.parse_group_by_item()?);
789 }
790 Ok(items)
791 }
792
793 fn parse_group_by_item(&mut self) -> Result<Expr> {
795 match self.peek_type() {
796 TokenType::Cube => {
797 self.advance();
798 self.expect(TokenType::LParen)?;
799 let exprs = if self.peek_type() == &TokenType::RParen {
800 vec![]
801 } else {
802 self.parse_group_by_element_list()?
803 };
804 self.expect(TokenType::RParen)?;
805 Ok(Expr::Cube { exprs })
806 }
807 TokenType::Rollup => {
808 self.advance();
809 self.expect(TokenType::LParen)?;
810 let exprs = if self.peek_type() == &TokenType::RParen {
811 vec![]
812 } else {
813 self.parse_group_by_element_list()?
814 };
815 self.expect(TokenType::RParen)?;
816 Ok(Expr::Rollup { exprs })
817 }
818 TokenType::Grouping => {
819 let saved = self.pos;
821 self.advance();
822 if self.peek_type() == &TokenType::Sets {
823 self.advance();
825 self.expect(TokenType::LParen)?;
826 let sets = self.parse_grouping_sets_elements()?;
827 self.expect(TokenType::RParen)?;
828 Ok(Expr::GroupingSets { sets })
829 } else {
830 self.pos = saved;
832 self.parse_expr()
833 }
834 }
835 _ => self.parse_expr(),
836 }
837 }
838
839 fn parse_group_by_element_list(&mut self) -> Result<Vec<Expr>> {
842 let mut items = vec![self.parse_group_by_element()?];
843 while self.match_token(TokenType::Comma) {
844 items.push(self.parse_group_by_element()?);
845 }
846 Ok(items)
847 }
848
849 fn parse_group_by_element(&mut self) -> Result<Expr> {
851 if self.peek_type() == &TokenType::LParen {
852 self.advance();
853 let exprs = self.parse_expr_list()?;
854 self.expect(TokenType::RParen)?;
855 if exprs.len() == 1 {
856 Ok(Expr::Nested(Box::new(exprs.into_iter().next().unwrap())))
857 } else {
858 Ok(Expr::Tuple(exprs))
859 }
860 } else {
861 self.parse_expr()
862 }
863 }
864
865 fn parse_grouping_sets_elements(&mut self) -> Result<Vec<Expr>> {
868 let mut items = vec![self.parse_grouping_sets_element()?];
869 while self.match_token(TokenType::Comma) {
870 items.push(self.parse_grouping_sets_element()?);
871 }
872 Ok(items)
873 }
874
875 fn parse_grouping_sets_element(&mut self) -> Result<Expr> {
877 match self.peek_type() {
878 TokenType::Cube => {
879 self.advance();
880 self.expect(TokenType::LParen)?;
881 let exprs = if self.peek_type() == &TokenType::RParen {
882 vec![]
883 } else {
884 self.parse_group_by_element_list()?
885 };
886 self.expect(TokenType::RParen)?;
887 Ok(Expr::Cube { exprs })
888 }
889 TokenType::Rollup => {
890 self.advance();
891 self.expect(TokenType::LParen)?;
892 let exprs = if self.peek_type() == &TokenType::RParen {
893 vec![]
894 } else {
895 self.parse_group_by_element_list()?
896 };
897 self.expect(TokenType::RParen)?;
898 Ok(Expr::Rollup { exprs })
899 }
900 TokenType::LParen => {
901 self.advance();
902 if self.peek_type() == &TokenType::RParen {
903 self.advance();
905 Ok(Expr::Tuple(vec![]))
906 } else {
907 let exprs = self.parse_expr_list()?;
908 self.expect(TokenType::RParen)?;
909 if exprs.len() == 1 {
910 Ok(Expr::Nested(Box::new(exprs.into_iter().next().unwrap())))
911 } else {
912 Ok(Expr::Tuple(exprs))
913 }
914 }
915 }
916 _ => self.parse_expr(),
917 }
918 }
919
920 fn parse_insert(&mut self) -> Result<InsertStatement> {
923 self.expect(TokenType::Insert)?;
924 let _ = self.match_token(TokenType::Into);
925 let table = self.parse_table_ref()?;
926
927 let columns = if self.match_token(TokenType::LParen) {
928 let mut cols = vec![self.expect_name()?];
929 while self.match_token(TokenType::Comma) {
930 cols.push(self.expect_name()?);
931 }
932 self.expect(TokenType::RParen)?;
933 cols
934 } else {
935 vec![]
936 };
937
938 let source = if self.match_token(TokenType::Values) {
939 let mut rows = Vec::new();
940 loop {
941 self.expect(TokenType::LParen)?;
942 let row = self.parse_expr_list()?;
943 self.expect(TokenType::RParen)?;
944 rows.push(row);
945 if !self.match_token(TokenType::Comma) {
946 break;
947 }
948 }
949 InsertSource::Values(rows)
950 } else if matches!(
951 self.peek_type(),
952 TokenType::Select | TokenType::With | TokenType::LParen
953 ) {
954 InsertSource::Query(Box::new(self.parse_statement_inner()?))
955 } else if self.match_token(TokenType::Default) {
956 self.expect(TokenType::Values)?;
957 InsertSource::Default
958 } else {
959 return Err(SqlglotError::ParserError {
960 message: "Expected VALUES, SELECT, or DEFAULT VALUES after INSERT".into(),
961 });
962 };
963
964 let on_conflict = if self.match_token(TokenType::On) {
966 if self.match_token(TokenType::Conflict) {
967 let columns = if self.match_token(TokenType::LParen) {
968 let mut cols = vec![self.expect_name()?];
969 while self.match_token(TokenType::Comma) {
970 cols.push(self.expect_name()?);
971 }
972 self.expect(TokenType::RParen)?;
973 cols
974 } else {
975 vec![]
976 };
977 self.expect(TokenType::Do)?;
978 let action = if self.match_token(TokenType::Nothing) {
979 ConflictAction::DoNothing
980 } else {
981 self.expect(TokenType::Update)?;
982 self.expect(TokenType::Set)?;
983 let mut assignments = Vec::new();
984 loop {
985 let col = self.expect_name()?;
986 self.expect(TokenType::Eq)?;
987 let val = self.parse_expr()?;
988 assignments.push((col, val));
989 if !self.match_token(TokenType::Comma) {
990 break;
991 }
992 }
993 ConflictAction::DoUpdate(assignments)
994 };
995 Some(OnConflict { columns, action })
996 } else {
997 None
998 }
999 } else {
1000 None
1001 };
1002
1003 let returning = if self.match_token(TokenType::Returning) {
1004 self.parse_select_items()?
1005 } else {
1006 vec![]
1007 };
1008
1009 Ok(InsertStatement {
1010 table,
1011 columns,
1012 source,
1013 on_conflict,
1014 returning,
1015 })
1016 }
1017
1018 fn parse_update(&mut self) -> Result<UpdateStatement> {
1021 self.expect(TokenType::Update)?;
1022 let table = self.parse_table_ref()?;
1023 self.expect(TokenType::Set)?;
1024
1025 let mut assignments = Vec::new();
1026 loop {
1027 let col = self.expect_name()?;
1028 self.expect(TokenType::Eq)?;
1029 let val = self.parse_expr()?;
1030 assignments.push((col, val));
1031 if !self.match_token(TokenType::Comma) {
1032 break;
1033 }
1034 }
1035
1036 let from = if self.match_token(TokenType::From) {
1037 Some(FromClause {
1038 source: self.parse_table_source()?,
1039 })
1040 } else {
1041 None
1042 };
1043
1044 let where_clause = if self.match_token(TokenType::Where) {
1045 Some(self.parse_expr()?)
1046 } else {
1047 None
1048 };
1049
1050 let returning = if self.match_token(TokenType::Returning) {
1051 self.parse_select_items()?
1052 } else {
1053 vec![]
1054 };
1055
1056 Ok(UpdateStatement {
1057 table,
1058 assignments,
1059 from,
1060 where_clause,
1061 returning,
1062 })
1063 }
1064
1065 fn parse_delete(&mut self) -> Result<DeleteStatement> {
1068 self.expect(TokenType::Delete)?;
1069 self.expect(TokenType::From)?;
1070 let table = self.parse_table_ref()?;
1071
1072 let using = if self.match_token(TokenType::Using) {
1073 Some(FromClause {
1074 source: self.parse_table_source()?,
1075 })
1076 } else {
1077 None
1078 };
1079
1080 let where_clause = if self.match_token(TokenType::Where) {
1081 Some(self.parse_expr()?)
1082 } else {
1083 None
1084 };
1085
1086 let returning = if self.match_token(TokenType::Returning) {
1087 self.parse_select_items()?
1088 } else {
1089 vec![]
1090 };
1091
1092 Ok(DeleteStatement {
1093 table,
1094 using,
1095 where_clause,
1096 returning,
1097 })
1098 }
1099
1100 fn parse_create(&mut self) -> Result<Statement> {
1103 self.expect(TokenType::Create)?;
1104
1105 let or_replace = if self.check_keyword("OR") {
1106 self.advance();
1107 self.expect(TokenType::Replace)?;
1108 true
1109 } else {
1110 false
1111 };
1112
1113 let temporary = self.match_token(TokenType::Temporary) || self.match_token(TokenType::Temp);
1114
1115 let materialized = self.match_token(TokenType::Materialized);
1116
1117 if self.match_token(TokenType::View) {
1118 return self
1119 .parse_create_view(or_replace, materialized)
1120 .map(Statement::CreateView);
1121 }
1122
1123 self.expect(TokenType::Table)?;
1124
1125 let if_not_exists = if self.match_token(TokenType::If) {
1126 self.expect(TokenType::Not)?;
1127 self.expect(TokenType::Exists)?;
1128 true
1129 } else {
1130 false
1131 };
1132
1133 let table = self.parse_table_ref_no_alias()?;
1134
1135 if self.match_token(TokenType::As) {
1137 let query = self.parse_statement_inner()?;
1138 return Ok(Statement::CreateTable(CreateTableStatement {
1139 if_not_exists,
1140 temporary,
1141 table,
1142 columns: vec![],
1143 constraints: vec![],
1144 as_select: Some(Box::new(query)),
1145 }));
1146 }
1147
1148 self.expect(TokenType::LParen)?;
1149
1150 let mut columns = Vec::new();
1151 let mut constraints = Vec::new();
1152
1153 loop {
1154 if matches!(
1156 self.peek_type(),
1157 TokenType::Primary
1158 | TokenType::Unique
1159 | TokenType::Foreign
1160 | TokenType::Check
1161 | TokenType::Constraint
1162 ) {
1163 constraints.push(self.parse_table_constraint()?);
1164 } else if self.peek_type() != &TokenType::RParen {
1165 columns.push(self.parse_column_def()?);
1166 }
1167
1168 if !self.match_token(TokenType::Comma) {
1169 break;
1170 }
1171 }
1172 self.expect(TokenType::RParen)?;
1173
1174 Ok(Statement::CreateTable(CreateTableStatement {
1175 if_not_exists,
1176 temporary,
1177 table,
1178 columns,
1179 constraints,
1180 as_select: None,
1181 }))
1182 }
1183
1184 fn parse_create_view(
1185 &mut self,
1186 or_replace: bool,
1187 materialized: bool,
1188 ) -> Result<CreateViewStatement> {
1189 let if_not_exists = if self.match_token(TokenType::If) {
1190 self.expect(TokenType::Not)?;
1191 self.expect(TokenType::Exists)?;
1192 true
1193 } else {
1194 false
1195 };
1196
1197 let name = self.parse_table_ref_no_alias()?;
1199
1200 let columns = if self.match_token(TokenType::LParen) {
1201 let mut cols = vec![self.expect_name()?];
1202 while self.match_token(TokenType::Comma) {
1203 cols.push(self.expect_name()?);
1204 }
1205 self.expect(TokenType::RParen)?;
1206 cols
1207 } else {
1208 vec![]
1209 };
1210
1211 self.expect(TokenType::As)?;
1212 let query = self.parse_statement_inner()?;
1213
1214 Ok(CreateViewStatement {
1215 name,
1216 columns,
1217 query: Box::new(query),
1218 or_replace,
1219 materialized,
1220 if_not_exists,
1221 })
1222 }
1223
1224 fn parse_table_constraint(&mut self) -> Result<TableConstraint> {
1225 let name = if self.match_token(TokenType::Constraint) {
1226 Some(self.expect_name()?)
1227 } else {
1228 None
1229 };
1230
1231 if self.match_token(TokenType::Primary) {
1232 self.expect(TokenType::Key)?;
1233 self.expect(TokenType::LParen)?;
1234 let columns = self.parse_name_list()?;
1235 self.expect(TokenType::RParen)?;
1236 Ok(TableConstraint::PrimaryKey { name, columns })
1237 } else if self.match_token(TokenType::Unique) {
1238 self.expect(TokenType::LParen)?;
1239 let columns = self.parse_name_list()?;
1240 self.expect(TokenType::RParen)?;
1241 Ok(TableConstraint::Unique { name, columns })
1242 } else if self.match_token(TokenType::Foreign) {
1243 self.expect(TokenType::Key)?;
1244 self.expect(TokenType::LParen)?;
1245 let columns = self.parse_name_list()?;
1246 self.expect(TokenType::RParen)?;
1247 self.expect(TokenType::References)?;
1248 let ref_table = self.parse_table_ref()?;
1249 self.expect(TokenType::LParen)?;
1250 let ref_columns = self.parse_name_list()?;
1251 self.expect(TokenType::RParen)?;
1252
1253 let on_delete =
1254 if self.match_token(TokenType::On) && self.match_token(TokenType::Delete) {
1255 Some(self.parse_referential_action()?)
1256 } else {
1257 None
1258 };
1259 let on_update =
1260 if self.match_token(TokenType::On) && self.match_token(TokenType::Update) {
1261 Some(self.parse_referential_action()?)
1262 } else {
1263 None
1264 };
1265
1266 Ok(TableConstraint::ForeignKey {
1267 name,
1268 columns,
1269 ref_table,
1270 ref_columns,
1271 on_delete,
1272 on_update,
1273 })
1274 } else if self.match_token(TokenType::Check) {
1275 self.expect(TokenType::LParen)?;
1276 let expr = self.parse_expr()?;
1277 self.expect(TokenType::RParen)?;
1278 Ok(TableConstraint::Check { name, expr })
1279 } else {
1280 Err(SqlglotError::ParserError {
1281 message: "Expected constraint type".into(),
1282 })
1283 }
1284 }
1285
1286 fn parse_referential_action(&mut self) -> Result<ReferentialAction> {
1287 if self.match_token(TokenType::Cascade) {
1288 Ok(ReferentialAction::Cascade)
1289 } else if self.match_token(TokenType::Restrict) {
1290 Ok(ReferentialAction::Restrict)
1291 } else if self.match_token(TokenType::Set) {
1292 if self.match_token(TokenType::Null) {
1293 Ok(ReferentialAction::SetNull)
1294 } else if self.match_token(TokenType::Default) {
1295 Ok(ReferentialAction::SetDefault)
1296 } else {
1297 Err(SqlglotError::ParserError {
1298 message: "Expected NULL or DEFAULT after SET".into(),
1299 })
1300 }
1301 } else if self.check_keyword("NO") {
1302 self.advance();
1303 self.expect(TokenType::Identifier)?; Ok(ReferentialAction::NoAction)
1305 } else {
1306 Err(SqlglotError::ParserError {
1307 message: "Expected referential action (CASCADE, RESTRICT, SET NULL, SET DEFAULT, NO ACTION)".into(),
1308 })
1309 }
1310 }
1311
1312 fn parse_name_list(&mut self) -> Result<Vec<String>> {
1313 let mut names = vec![self.expect_name()?];
1314 while self.match_token(TokenType::Comma) {
1315 names.push(self.expect_name()?);
1316 }
1317 Ok(names)
1318 }
1319
1320 fn parse_column_def(&mut self) -> Result<ColumnDef> {
1321 let name = self.expect_name()?;
1322 let data_type = self.parse_data_type()?;
1323
1324 let mut nullable = None;
1325 let mut default = None;
1326 let mut primary_key = false;
1327 let mut unique = false;
1328 let mut auto_increment = false;
1329 let mut collation = None;
1330 let mut comment = None;
1331
1332 loop {
1333 if self.match_token(TokenType::Not) {
1334 self.expect(TokenType::Null)?;
1335 nullable = Some(false);
1336 } else if self.peek_type() == &TokenType::Null {
1337 self.advance();
1338 nullable = Some(true);
1339 } else if self.match_token(TokenType::Default) {
1340 default = Some(self.parse_expr()?);
1341 } else if self.match_token(TokenType::Primary) {
1342 self.expect(TokenType::Key)?;
1343 primary_key = true;
1344 } else if self.match_token(TokenType::Unique) {
1345 unique = true;
1346 } else if self.match_token(TokenType::AutoIncrement) {
1347 auto_increment = true;
1348 } else if self.match_token(TokenType::Collate) {
1349 collation = Some(self.expect_name()?);
1350 } else if self.match_token(TokenType::Comment) {
1351 let tok = self.expect(TokenType::String)?;
1352 comment = Some(tok.value);
1353 } else if self.match_token(TokenType::References) {
1354 let _ = self.parse_table_ref()?;
1356 if self.match_token(TokenType::LParen) {
1357 while !self.match_token(TokenType::RParen) {
1358 self.advance();
1359 }
1360 }
1361 } else {
1362 break;
1363 }
1364 }
1365
1366 Ok(ColumnDef {
1367 name,
1368 data_type,
1369 nullable,
1370 default,
1371 primary_key,
1372 unique,
1373 auto_increment,
1374 collation,
1375 comment,
1376 })
1377 }
1378
1379 fn parse_data_type(&mut self) -> Result<DataType> {
1380 let token = self.peek().clone();
1381 let type_result = match &token.token_type {
1382 TokenType::Int | TokenType::Integer => {
1383 self.advance();
1384 Ok(DataType::Int)
1385 }
1386 TokenType::BigInt => {
1387 self.advance();
1388 Ok(DataType::BigInt)
1389 }
1390 TokenType::SmallInt => {
1391 self.advance();
1392 Ok(DataType::SmallInt)
1393 }
1394 TokenType::TinyInt => {
1395 self.advance();
1396 Ok(DataType::TinyInt)
1397 }
1398 TokenType::Float => {
1399 self.advance();
1400 Ok(DataType::Float)
1401 }
1402 TokenType::Double => {
1403 self.advance();
1404 let _ = self.match_keyword("PRECISION");
1405 Ok(DataType::Double)
1406 }
1407 TokenType::Real => {
1408 self.advance();
1409 Ok(DataType::Real)
1410 }
1411 TokenType::Decimal | TokenType::Numeric => {
1412 let is_numeric = token.token_type == TokenType::Numeric;
1413 self.advance();
1414 let (precision, scale) = self.parse_type_params()?;
1415 if is_numeric {
1416 Ok(DataType::Numeric { precision, scale })
1417 } else {
1418 Ok(DataType::Decimal { precision, scale })
1419 }
1420 }
1421 TokenType::Varchar => {
1422 self.advance();
1423 let len = self.parse_single_type_param()?;
1424 Ok(DataType::Varchar(len))
1425 }
1426 TokenType::Char => {
1427 self.advance();
1428 let len = self.parse_single_type_param()?;
1429 Ok(DataType::Char(len))
1430 }
1431 TokenType::Text => {
1432 self.advance();
1433 Ok(DataType::Text)
1434 }
1435 TokenType::Boolean => {
1436 self.advance();
1437 Ok(DataType::Boolean)
1438 }
1439 TokenType::Date => {
1440 self.advance();
1441 Ok(DataType::Date)
1442 }
1443 TokenType::Timestamp => {
1444 self.advance();
1445 let precision = self.parse_single_type_param()?;
1446 let with_tz = if self.match_keyword("WITH") {
1447 let _ = self.match_keyword("TIME");
1448 let _ = self.match_keyword("ZONE");
1449 true
1450 } else if self.match_keyword("WITHOUT") {
1451 let _ = self.match_keyword("TIME");
1452 let _ = self.match_keyword("ZONE");
1453 false
1454 } else {
1455 false
1456 };
1457 Ok(DataType::Timestamp { precision, with_tz })
1458 }
1459 TokenType::TimestampTz => {
1460 self.advance();
1461 let precision = self.parse_single_type_param()?;
1462 Ok(DataType::Timestamp {
1463 precision,
1464 with_tz: true,
1465 })
1466 }
1467 TokenType::Time => {
1468 self.advance();
1469 let precision = self.parse_single_type_param()?;
1470 Ok(DataType::Time { precision })
1471 }
1472 TokenType::Interval => {
1473 self.advance();
1474 Ok(DataType::Interval)
1475 }
1476 TokenType::Blob => {
1477 self.advance();
1478 Ok(DataType::Blob)
1479 }
1480 TokenType::Bytea => {
1481 self.advance();
1482 Ok(DataType::Bytea)
1483 }
1484 TokenType::Json => {
1485 self.advance();
1486 Ok(DataType::Json)
1487 }
1488 TokenType::Jsonb => {
1489 self.advance();
1490 Ok(DataType::Jsonb)
1491 }
1492 TokenType::Uuid => {
1493 self.advance();
1494 Ok(DataType::Uuid)
1495 }
1496 TokenType::Array => {
1497 self.advance();
1498 if self.match_token(TokenType::Lt) {
1499 let inner = self.parse_data_type()?;
1500 self.expect(TokenType::Gt)?;
1501 Ok(DataType::Array(Some(Box::new(inner))))
1502 } else {
1503 Ok(DataType::Array(None))
1504 }
1505 }
1506 TokenType::Identifier => {
1507 let name = token.value.to_uppercase();
1508 self.advance();
1509 match name.as_str() {
1510 "STRING" => Ok(DataType::String),
1511 "BINARY" => {
1512 let len = self.parse_single_type_param()?;
1513 Ok(DataType::Binary(len))
1514 }
1515 "VARBINARY" => {
1516 let len = self.parse_single_type_param()?;
1517 Ok(DataType::Varbinary(len))
1518 }
1519 "DATETIME" => Ok(DataType::DateTime),
1520 "BYTES" => Ok(DataType::Bytes),
1521 "VARIANT" => Ok(DataType::Variant),
1522 "OBJECT" => Ok(DataType::Object),
1523 "XML" => Ok(DataType::Xml),
1524 "INET" => Ok(DataType::Inet),
1525 "CIDR" => Ok(DataType::Cidr),
1526 "MACADDR" => Ok(DataType::Macaddr),
1527 "BIT" => {
1528 let len = self.parse_single_type_param()?;
1529 Ok(DataType::Bit(len))
1530 }
1531 "MONEY" => Ok(DataType::Money),
1532 "SERIAL" => Ok(DataType::Serial),
1533 "BIGSERIAL" => Ok(DataType::BigSerial),
1534 "SMALLSERIAL" => Ok(DataType::SmallSerial),
1535 "REGCLASS" => Ok(DataType::Regclass),
1536 "REGTYPE" => Ok(DataType::Regtype),
1537 "HSTORE" => Ok(DataType::Hstore),
1538 "GEOGRAPHY" => Ok(DataType::Geography),
1539 "GEOMETRY" => Ok(DataType::Geometry),
1540 "SUPER" => Ok(DataType::Super),
1541 _ => Ok(DataType::Unknown(name)),
1542 }
1543 }
1544 _ => Err(SqlglotError::ParserError {
1545 message: format!("Expected data type, got {:?}", token.token_type),
1546 }),
1547 };
1548 type_result
1549 }
1550
1551 fn parse_type_params(&mut self) -> Result<(Option<u32>, Option<u32>)> {
1552 if self.match_token(TokenType::LParen) {
1553 let p: Option<u32> = self.expect(TokenType::Number)?.value.parse().ok();
1554 let s = if self.match_token(TokenType::Comma) {
1555 self.expect(TokenType::Number)?.value.parse().ok()
1556 } else {
1557 None
1558 };
1559 self.expect(TokenType::RParen)?;
1560 Ok((p, s))
1561 } else {
1562 Ok((None, None))
1563 }
1564 }
1565
1566 fn parse_single_type_param(&mut self) -> Result<Option<u32>> {
1567 if self.match_token(TokenType::LParen) {
1568 let n: Option<u32> = self.expect(TokenType::Number)?.value.parse().ok();
1569 self.expect(TokenType::RParen)?;
1570 Ok(n)
1571 } else {
1572 Ok(None)
1573 }
1574 }
1575
1576 fn parse_drop(&mut self) -> Result<Statement> {
1579 self.expect(TokenType::Drop)?;
1580
1581 if self.match_token(TokenType::Materialized) {
1582 self.expect(TokenType::View)?;
1583 let if_exists = if self.match_token(TokenType::If) {
1584 self.expect(TokenType::Exists)?;
1585 true
1586 } else {
1587 false
1588 };
1589 let name = self.parse_table_ref()?;
1590 return Ok(Statement::DropView(DropViewStatement {
1591 name,
1592 if_exists,
1593 materialized: true,
1594 }));
1595 }
1596
1597 if self.match_token(TokenType::View) {
1598 let if_exists = if self.match_token(TokenType::If) {
1599 self.expect(TokenType::Exists)?;
1600 true
1601 } else {
1602 false
1603 };
1604 let name = self.parse_table_ref()?;
1605 return Ok(Statement::DropView(DropViewStatement {
1606 name,
1607 if_exists,
1608 materialized: false,
1609 }));
1610 }
1611
1612 self.expect(TokenType::Table)?;
1613
1614 let if_exists = if self.match_token(TokenType::If) {
1615 self.expect(TokenType::Exists)?;
1616 true
1617 } else {
1618 false
1619 };
1620
1621 let table = self.parse_table_ref()?;
1622 let cascade = self.match_token(TokenType::Cascade);
1623
1624 Ok(Statement::DropTable(DropTableStatement {
1625 if_exists,
1626 table,
1627 cascade,
1628 }))
1629 }
1630
1631 fn parse_alter_table(&mut self) -> Result<AlterTableStatement> {
1634 self.expect(TokenType::Alter)?;
1635 self.expect(TokenType::Table)?;
1636 let table = self.parse_table_ref_no_alias()?;
1637
1638 let mut actions = Vec::new();
1639 loop {
1640 let action = self.parse_alter_action()?;
1641 actions.push(action);
1642 if !self.match_token(TokenType::Comma) {
1643 break;
1644 }
1645 }
1646
1647 Ok(AlterTableStatement { table, actions })
1648 }
1649
1650 fn parse_alter_action(&mut self) -> Result<AlterTableAction> {
1651 if self.match_keyword("ADD") {
1652 if matches!(
1653 self.peek_type(),
1654 TokenType::Constraint
1655 | TokenType::Primary
1656 | TokenType::Unique
1657 | TokenType::Foreign
1658 | TokenType::Check
1659 ) {
1660 let constraint = self.parse_table_constraint()?;
1661 Ok(AlterTableAction::AddConstraint(constraint))
1662 } else {
1663 let _ = self.match_keyword("COLUMN");
1664 let col = self.parse_column_def()?;
1665 Ok(AlterTableAction::AddColumn(col))
1666 }
1667 } else if self.match_token(TokenType::Drop) {
1668 let _ = self.match_keyword("COLUMN");
1669 let if_exists = if self.match_token(TokenType::If) {
1670 self.expect(TokenType::Exists)?;
1671 true
1672 } else {
1673 false
1674 };
1675 let name = self.expect_name()?;
1676 Ok(AlterTableAction::DropColumn { name, if_exists })
1677 } else if self.match_keyword("RENAME") {
1678 if self.match_keyword("COLUMN") {
1679 let old_name = self.expect_name()?;
1680 self.expect(TokenType::Identifier)?; let new_name = self.expect_name()?;
1682 Ok(AlterTableAction::RenameColumn { old_name, new_name })
1683 } else if self.match_keyword("TO") {
1684 let new_name = self.expect_name()?;
1685 Ok(AlterTableAction::RenameTable { new_name })
1686 } else {
1687 Err(SqlglotError::ParserError {
1688 message: "Expected COLUMN or TO after RENAME".into(),
1689 })
1690 }
1691 } else {
1692 Err(SqlglotError::ParserError {
1693 message: "Expected ADD, DROP, or RENAME in ALTER TABLE".into(),
1694 })
1695 }
1696 }
1697
1698 fn parse_truncate(&mut self) -> Result<TruncateStatement> {
1701 self.expect(TokenType::Truncate)?;
1702 let _ = self.match_token(TokenType::Table);
1703 let table = self.parse_table_ref()?;
1704 Ok(TruncateStatement { table })
1705 }
1706
1707 fn parse_transaction(&mut self) -> Result<TransactionStatement> {
1710 match self.peek_type() {
1711 TokenType::Begin => {
1712 self.advance();
1713 let _ = self.match_token(TokenType::Transaction);
1714 Ok(TransactionStatement::Begin)
1715 }
1716 TokenType::Commit => {
1717 self.advance();
1718 let _ = self.match_token(TokenType::Transaction);
1719 Ok(TransactionStatement::Commit)
1720 }
1721 TokenType::Rollback => {
1722 self.advance();
1723 let _ = self.match_token(TokenType::Transaction);
1724 if self.match_keyword("TO") {
1725 let _ = self.match_token(TokenType::Savepoint);
1726 let name = self.expect_name()?;
1727 Ok(TransactionStatement::RollbackTo(name))
1728 } else {
1729 Ok(TransactionStatement::Rollback)
1730 }
1731 }
1732 TokenType::Savepoint => {
1733 self.advance();
1734 let name = self.expect_name()?;
1735 Ok(TransactionStatement::Savepoint(name))
1736 }
1737 _ => Err(SqlglotError::ParserError {
1738 message: "Expected transaction statement".into(),
1739 }),
1740 }
1741 }
1742
1743 fn parse_explain(&mut self) -> Result<ExplainStatement> {
1746 self.expect(TokenType::Explain)?;
1747 let analyze = self.match_token(TokenType::Analyze);
1748 let statement = self.parse_statement_inner()?;
1749 Ok(ExplainStatement {
1750 analyze,
1751 statement: Box::new(statement),
1752 })
1753 }
1754
1755 fn parse_use(&mut self) -> Result<UseStatement> {
1758 self.expect(TokenType::Use)?;
1759 let name = self.expect_name()?;
1760 Ok(UseStatement { name })
1761 }
1762
1763 fn parse_expr(&mut self) -> Result<Expr> {
1768 self.parse_or_expr()
1769 }
1770
1771 fn parse_or_expr(&mut self) -> Result<Expr> {
1772 let mut left = self.parse_and_expr()?;
1773 while self.match_token(TokenType::Or) {
1774 let right = self.parse_and_expr()?;
1775 left = Expr::BinaryOp {
1776 left: Box::new(left),
1777 op: BinaryOperator::Or,
1778 right: Box::new(right),
1779 };
1780 }
1781 Ok(left)
1782 }
1783
1784 fn parse_and_expr(&mut self) -> Result<Expr> {
1785 let mut left = self.parse_not_expr()?;
1786 while self.match_token(TokenType::And) {
1787 let right = self.parse_not_expr()?;
1788 left = Expr::BinaryOp {
1789 left: Box::new(left),
1790 op: BinaryOperator::And,
1791 right: Box::new(right),
1792 };
1793 }
1794 Ok(left)
1795 }
1796
1797 fn parse_not_expr(&mut self) -> Result<Expr> {
1798 if self.match_token(TokenType::Not) {
1799 let expr = self.parse_not_expr()?;
1800 Ok(Expr::UnaryOp {
1801 op: UnaryOperator::Not,
1802 expr: Box::new(expr),
1803 })
1804 } else {
1805 self.parse_comparison()
1806 }
1807 }
1808
1809 fn parse_comparison(&mut self) -> Result<Expr> {
1810 let mut left = self.parse_addition()?;
1811
1812 loop {
1813 let op = match self.peek_type() {
1814 TokenType::Eq => Some(BinaryOperator::Eq),
1815 TokenType::Neq => Some(BinaryOperator::Neq),
1816 TokenType::Lt => Some(BinaryOperator::Lt),
1817 TokenType::Gt => Some(BinaryOperator::Gt),
1818 TokenType::LtEq => Some(BinaryOperator::LtEq),
1819 TokenType::GtEq => Some(BinaryOperator::GtEq),
1820 _ => None,
1821 };
1822
1823 if let Some(op) = op {
1824 self.advance();
1825 if matches!(self.peek_type(), TokenType::Any | TokenType::Some) {
1826 self.advance();
1827 self.expect(TokenType::LParen)?;
1828 let right = if matches!(self.peek_type(), TokenType::Select | TokenType::With) {
1829 Expr::Subquery(Box::new(self.parse_statement_inner()?))
1830 } else {
1831 self.parse_expr()?
1832 };
1833 self.expect(TokenType::RParen)?;
1834 left = Expr::AnyOp {
1835 expr: Box::new(left),
1836 op,
1837 right: Box::new(right),
1838 };
1839 } else if self.peek_type() == &TokenType::All {
1840 self.advance();
1841 self.expect(TokenType::LParen)?;
1842 let right = if matches!(self.peek_type(), TokenType::Select | TokenType::With) {
1843 Expr::Subquery(Box::new(self.parse_statement_inner()?))
1844 } else {
1845 self.parse_expr()?
1846 };
1847 self.expect(TokenType::RParen)?;
1848 left = Expr::AllOp {
1849 expr: Box::new(left),
1850 op,
1851 right: Box::new(right),
1852 };
1853 } else {
1854 let right = self.parse_addition()?;
1855 left = Expr::BinaryOp {
1856 left: Box::new(left),
1857 op,
1858 right: Box::new(right),
1859 };
1860 }
1861 } else if self.peek_type() == &TokenType::Is {
1862 self.advance();
1863 let negated = self.match_token(TokenType::Not);
1864 if self.match_token(TokenType::True) {
1865 left = Expr::IsBool {
1866 expr: Box::new(left),
1867 value: true,
1868 negated,
1869 };
1870 } else if self.match_token(TokenType::False) {
1871 left = Expr::IsBool {
1872 expr: Box::new(left),
1873 value: false,
1874 negated,
1875 };
1876 } else {
1877 self.expect(TokenType::Null)?;
1878 left = Expr::IsNull {
1879 expr: Box::new(left),
1880 negated,
1881 };
1882 }
1883 } else if matches!(
1884 self.peek_type(),
1885 TokenType::Not
1886 | TokenType::In
1887 | TokenType::Like
1888 | TokenType::ILike
1889 | TokenType::Between
1890 ) {
1891 if self.peek_type() == &TokenType::Not {
1893 let saved_pos = self.pos;
1894 self.advance(); if !matches!(
1896 self.peek_type(),
1897 TokenType::In | TokenType::Like | TokenType::ILike | TokenType::Between
1898 ) {
1899 self.pos = saved_pos;
1901 break;
1902 }
1903 }
1905 let negated =
1906 self.pos > 0 && self.tokens[self.pos - 1].token_type == TokenType::Not;
1907
1908 if self.match_token(TokenType::In) {
1909 self.expect(TokenType::LParen)?;
1910 if matches!(self.peek_type(), TokenType::Select | TokenType::With) {
1912 let subquery = self.parse_statement_inner()?;
1913 self.expect(TokenType::RParen)?;
1914 left = Expr::InSubquery {
1915 expr: Box::new(left),
1916 subquery: Box::new(subquery),
1917 negated,
1918 };
1919 } else {
1920 let list = self.parse_expr_list()?;
1921 self.expect(TokenType::RParen)?;
1922 left = Expr::InList {
1923 expr: Box::new(left),
1924 list,
1925 negated,
1926 };
1927 }
1928 } else if self.match_token(TokenType::Like) {
1929 let pattern = self.parse_addition()?;
1930 let escape = if self.match_token(TokenType::Escape) {
1931 Some(Box::new(self.parse_primary()?))
1932 } else {
1933 None
1934 };
1935 left = Expr::Like {
1936 expr: Box::new(left),
1937 pattern: Box::new(pattern),
1938 negated,
1939 escape,
1940 };
1941 } else if self.match_token(TokenType::ILike) {
1942 let pattern = self.parse_addition()?;
1943 let escape = if self.match_token(TokenType::Escape) {
1944 Some(Box::new(self.parse_primary()?))
1945 } else {
1946 None
1947 };
1948 left = Expr::ILike {
1949 expr: Box::new(left),
1950 pattern: Box::new(pattern),
1951 negated,
1952 escape,
1953 };
1954 } else if self.match_token(TokenType::Between) {
1955 let low = self.parse_addition()?;
1956 self.expect(TokenType::And)?;
1957 let high = self.parse_addition()?;
1958 left = Expr::Between {
1959 expr: Box::new(left),
1960 low: Box::new(low),
1961 high: Box::new(high),
1962 negated,
1963 };
1964 } else {
1965 break;
1966 }
1967 } else {
1968 break;
1969 }
1970 }
1971
1972 Ok(left)
1973 }
1974
1975 fn parse_addition(&mut self) -> Result<Expr> {
1976 let mut left = self.parse_multiplication()?;
1977 loop {
1978 let op = match self.peek_type() {
1979 TokenType::Plus => Some(BinaryOperator::Plus),
1980 TokenType::Minus => Some(BinaryOperator::Minus),
1981 TokenType::Concat => Some(BinaryOperator::Concat),
1982 TokenType::BitwiseOr => Some(BinaryOperator::BitwiseOr),
1983 TokenType::BitwiseXor => Some(BinaryOperator::BitwiseXor),
1984 TokenType::ShiftLeft => Some(BinaryOperator::ShiftLeft),
1985 TokenType::ShiftRight => Some(BinaryOperator::ShiftRight),
1986 _ => None,
1987 };
1988 if let Some(op) = op {
1989 self.advance();
1990 let right = self.parse_multiplication()?;
1991 left = Expr::BinaryOp {
1992 left: Box::new(left),
1993 op,
1994 right: Box::new(right),
1995 };
1996 } else {
1997 break;
1998 }
1999 }
2000 Ok(left)
2001 }
2002
2003 fn parse_multiplication(&mut self) -> Result<Expr> {
2004 let mut left = self.parse_unary()?;
2005 loop {
2006 let op = match self.peek_type() {
2007 TokenType::Star => Some(BinaryOperator::Multiply),
2008 TokenType::Slash => Some(BinaryOperator::Divide),
2009 TokenType::Percent2 => Some(BinaryOperator::Modulo),
2010 TokenType::BitwiseAnd => Some(BinaryOperator::BitwiseAnd),
2011 _ => None,
2012 };
2013 if let Some(op) = op {
2014 self.advance();
2015 let right = self.parse_unary()?;
2016 left = Expr::BinaryOp {
2017 left: Box::new(left),
2018 op,
2019 right: Box::new(right),
2020 };
2021 } else {
2022 break;
2023 }
2024 }
2025 Ok(left)
2026 }
2027
2028 fn parse_unary(&mut self) -> Result<Expr> {
2029 match self.peek_type() {
2030 TokenType::Minus => {
2031 self.advance();
2032 let expr = self.parse_postfix()?;
2033 Ok(Expr::UnaryOp {
2034 op: UnaryOperator::Minus,
2035 expr: Box::new(expr),
2036 })
2037 }
2038 TokenType::Plus => {
2039 self.advance();
2040 let expr = self.parse_postfix()?;
2041 Ok(Expr::UnaryOp {
2042 op: UnaryOperator::Plus,
2043 expr: Box::new(expr),
2044 })
2045 }
2046 TokenType::BitwiseNot => {
2047 self.advance();
2048 let expr = self.parse_postfix()?;
2049 Ok(Expr::UnaryOp {
2050 op: UnaryOperator::BitwiseNot,
2051 expr: Box::new(expr),
2052 })
2053 }
2054 _ => self.parse_postfix(),
2055 }
2056 }
2057
2058 fn parse_postfix(&mut self) -> Result<Expr> {
2060 let mut expr = self.parse_primary()?;
2061
2062 loop {
2063 if self.match_token(TokenType::DoubleColon) {
2064 let data_type = self.parse_data_type()?;
2066 expr = Expr::Cast {
2067 expr: Box::new(expr),
2068 data_type,
2069 };
2070 } else if self.match_token(TokenType::LBracket) {
2071 let index = self.parse_expr()?;
2073 self.expect(TokenType::RBracket)?;
2074 expr = Expr::ArrayIndex {
2075 expr: Box::new(expr),
2076 index: Box::new(index),
2077 };
2078 } else if self.match_token(TokenType::Arrow) {
2079 let path = self.parse_primary()?;
2080 expr = Expr::JsonAccess {
2081 expr: Box::new(expr),
2082 path: Box::new(path),
2083 as_text: false,
2084 };
2085 } else if self.match_token(TokenType::DoubleArrow) {
2086 let path = self.parse_primary()?;
2087 expr = Expr::JsonAccess {
2088 expr: Box::new(expr),
2089 path: Box::new(path),
2090 as_text: true,
2091 };
2092 } else {
2093 break;
2094 }
2095 }
2096
2097 if self.match_token(TokenType::Over) {
2099 let spec = if self.match_token(TokenType::LParen) {
2100 let ws = self.parse_window_spec()?;
2101 self.expect(TokenType::RParen)?;
2102 ws
2103 } else {
2104 let wref = self.expect_name()?;
2106 WindowSpec {
2107 window_ref: Some(wref),
2108 partition_by: vec![],
2109 order_by: vec![],
2110 frame: None,
2111 }
2112 };
2113 match expr {
2114 Expr::Function {
2115 name,
2116 args,
2117 distinct,
2118 filter,
2119 ..
2120 } => {
2121 expr = Expr::Function {
2122 name,
2123 args,
2124 distinct,
2125 filter,
2126 over: Some(spec),
2127 };
2128 }
2129 Expr::TypedFunction { func, filter, .. } => {
2130 expr = Expr::TypedFunction {
2131 func,
2132 filter,
2133 over: Some(spec),
2134 };
2135 }
2136 _ => {}
2137 }
2138 }
2139
2140 if self.match_token(TokenType::Filter) {
2142 self.expect(TokenType::LParen)?;
2143 self.expect(TokenType::Where)?;
2144 let filter_expr = self.parse_expr()?;
2145 self.expect(TokenType::RParen)?;
2146 match expr {
2147 Expr::Function {
2148 name,
2149 args,
2150 distinct,
2151 over,
2152 ..
2153 } => {
2154 expr = Expr::Function {
2155 name,
2156 args,
2157 distinct,
2158 filter: Some(Box::new(filter_expr)),
2159 over,
2160 };
2161 }
2162 Expr::TypedFunction { func, over, .. } => {
2163 expr = Expr::TypedFunction {
2164 func,
2165 filter: Some(Box::new(filter_expr)),
2166 over,
2167 };
2168 }
2169 _ => {}
2170 }
2171 }
2172
2173 Ok(expr)
2174 }
2175
2176 fn parse_window_spec(&mut self) -> Result<WindowSpec> {
2177 let window_ref = if self.is_name_token()
2178 && !matches!(
2179 self.peek_type(),
2180 TokenType::Partition | TokenType::Order | TokenType::Rows | TokenType::Range
2181 ) {
2182 let saved = self.pos;
2183 let name = self.expect_name()?;
2184 if matches!(
2186 self.peek_type(),
2187 TokenType::RParen
2188 | TokenType::Partition
2189 | TokenType::Order
2190 | TokenType::Rows
2191 | TokenType::Range
2192 ) {
2193 Some(name)
2194 } else {
2195 self.pos = saved;
2196 None
2197 }
2198 } else {
2199 None
2200 };
2201
2202 let partition_by = if self.match_token(TokenType::Partition) {
2203 self.expect(TokenType::By)?;
2204 self.parse_expr_list()?
2205 } else {
2206 vec![]
2207 };
2208
2209 let order_by = if self.match_token(TokenType::Order) {
2210 self.expect(TokenType::By)?;
2211 self.parse_order_by_items()?
2212 } else {
2213 vec![]
2214 };
2215
2216 let frame = if matches!(self.peek_type(), TokenType::Rows | TokenType::Range) {
2217 Some(self.parse_window_frame()?)
2218 } else {
2219 None
2220 };
2221
2222 Ok(WindowSpec {
2223 window_ref,
2224 partition_by,
2225 order_by,
2226 frame,
2227 })
2228 }
2229
2230 fn parse_window_frame(&mut self) -> Result<WindowFrame> {
2231 let kind = if self.match_token(TokenType::Rows) {
2232 WindowFrameKind::Rows
2233 } else if self.match_token(TokenType::Range) {
2234 WindowFrameKind::Range
2235 } else {
2236 WindowFrameKind::Rows
2237 };
2238
2239 if self.match_keyword("BETWEEN") {
2240 let start = self.parse_window_frame_bound()?;
2241 self.expect(TokenType::And)?;
2242 let end = self.parse_window_frame_bound()?;
2243 Ok(WindowFrame {
2244 kind,
2245 start,
2246 end: Some(end),
2247 })
2248 } else {
2249 let start = self.parse_window_frame_bound()?;
2250 Ok(WindowFrame {
2251 kind,
2252 start,
2253 end: None,
2254 })
2255 }
2256 }
2257
2258 fn parse_window_frame_bound(&mut self) -> Result<WindowFrameBound> {
2259 if self.check_keyword("CURRENT") {
2260 self.advance();
2261 let _ = self.match_keyword("ROW");
2262 Ok(WindowFrameBound::CurrentRow)
2263 } else if self.match_token(TokenType::Unbounded) {
2264 if self.match_token(TokenType::Preceding) {
2265 Ok(WindowFrameBound::Preceding(None))
2266 } else {
2267 self.expect(TokenType::Following)?;
2268 Ok(WindowFrameBound::Following(None))
2269 }
2270 } else {
2271 let n = self.parse_expr()?;
2272 if self.match_token(TokenType::Preceding) {
2273 Ok(WindowFrameBound::Preceding(Some(Box::new(n))))
2274 } else {
2275 self.expect(TokenType::Following)?;
2276 Ok(WindowFrameBound::Following(Some(Box::new(n))))
2277 }
2278 }
2279 }
2280
2281 fn parse_primary(&mut self) -> Result<Expr> {
2282 let token = self.peek().clone();
2283
2284 match &token.token_type {
2285 TokenType::Number => {
2286 self.advance();
2287 Ok(Expr::Number(token.value))
2288 }
2289 TokenType::String => {
2290 self.advance();
2291 Ok(Expr::StringLiteral(token.value))
2292 }
2293 TokenType::True => {
2294 self.advance();
2295 Ok(Expr::Boolean(true))
2296 }
2297 TokenType::False => {
2298 self.advance();
2299 Ok(Expr::Boolean(false))
2300 }
2301 TokenType::Null => {
2302 self.advance();
2303 Ok(Expr::Null)
2304 }
2305 TokenType::Default => {
2306 self.advance();
2307 Ok(Expr::Default)
2308 }
2309 TokenType::Star => {
2310 self.advance();
2311 Ok(Expr::Wildcard)
2312 }
2313 TokenType::Parameter => {
2314 self.advance();
2315 Ok(Expr::Parameter(token.value))
2316 }
2317
2318 TokenType::Cast => {
2320 self.advance();
2321 self.expect(TokenType::LParen)?;
2322 let expr = self.parse_expr()?;
2323 self.expect(TokenType::As)?;
2324 let data_type = self.parse_data_type()?;
2325 self.expect(TokenType::RParen)?;
2326 Ok(Expr::Cast {
2327 expr: Box::new(expr),
2328 data_type,
2329 })
2330 }
2331
2332 TokenType::Extract => {
2334 self.advance();
2335 self.expect(TokenType::LParen)?;
2336 let field = self.parse_datetime_field()?;
2337 self.expect(TokenType::From)?;
2338 let expr = self.parse_expr()?;
2339 self.expect(TokenType::RParen)?;
2340 Ok(Expr::Extract {
2341 field,
2342 expr: Box::new(expr),
2343 })
2344 }
2345
2346 TokenType::Case => self.parse_case_expr(),
2348
2349 TokenType::Exists => {
2351 self.advance();
2352 self.expect(TokenType::LParen)?;
2353 let subquery = self.parse_statement_inner()?;
2354 self.expect(TokenType::RParen)?;
2355 Ok(Expr::Exists {
2356 subquery: Box::new(subquery),
2357 negated: false,
2358 })
2359 }
2360
2361 TokenType::Not
2363 if {
2364 let next_pos = self.pos + 1;
2365 next_pos < self.tokens.len()
2366 && self.tokens[next_pos].token_type == TokenType::Exists
2367 } =>
2368 {
2369 self.advance(); self.advance(); self.expect(TokenType::LParen)?;
2372 let subquery = self.parse_statement_inner()?;
2373 self.expect(TokenType::RParen)?;
2374 Ok(Expr::Exists {
2375 subquery: Box::new(subquery),
2376 negated: true,
2377 })
2378 }
2379
2380 TokenType::Interval => {
2382 self.advance();
2383 let value = self.parse_primary()?;
2384 let unit = self.try_parse_datetime_field();
2385 Ok(Expr::Interval {
2386 value: Box::new(value),
2387 unit,
2388 })
2389 }
2390
2391 TokenType::LParen => {
2393 self.advance();
2394 if matches!(self.peek_type(), TokenType::Select | TokenType::With) {
2396 let subquery = self.parse_statement_inner()?;
2397 self.expect(TokenType::RParen)?;
2398 Ok(Expr::Subquery(Box::new(subquery)))
2399 } else {
2400 let expr = self.parse_expr()?;
2401 if self.match_token(TokenType::Comma) {
2403 let mut items = vec![expr];
2404 items.push(self.parse_expr()?);
2405 while self.match_token(TokenType::Comma) {
2406 items.push(self.parse_expr()?);
2407 }
2408 self.expect(TokenType::RParen)?;
2409 Ok(Expr::Tuple(items))
2410 } else {
2411 self.expect(TokenType::RParen)?;
2412 Ok(Expr::Nested(Box::new(expr)))
2413 }
2414 }
2415 }
2416
2417 TokenType::Array => {
2419 self.advance();
2420 if self.match_token(TokenType::LBracket) {
2421 let items = if self.peek_type() != &TokenType::RBracket {
2422 self.parse_expr_list()?
2423 } else {
2424 vec![]
2425 };
2426 self.expect(TokenType::RBracket)?;
2427 Ok(Expr::ArrayLiteral(items))
2428 } else if self.match_token(TokenType::LParen) {
2429 let subquery = self.parse_statement_inner()?;
2431 self.expect(TokenType::RParen)?;
2432 Ok(Expr::Subquery(Box::new(subquery)))
2433 } else {
2434 Ok(Expr::Column {
2435 table: None,
2436 name: "ARRAY".to_string(),
2437 quote_style: QuoteStyle::None,
2438 table_quote_style: QuoteStyle::None,
2439 })
2440 }
2441 }
2442
2443 TokenType::LBracket => {
2445 self.advance();
2446 let items = if self.peek_type() != &TokenType::RBracket {
2447 self.parse_expr_list()?
2448 } else {
2449 vec![]
2450 };
2451 self.expect(TokenType::RBracket)?;
2452 Ok(Expr::ArrayLiteral(items))
2453 }
2454
2455 _ if self.is_name_token() || self.is_data_type_token() => {
2457 let name_token = self.advance().clone();
2458 let name = name_token.value.clone();
2459 let name_qs = quote_style_from_char(name_token.quote_char);
2460
2461 if self.peek_type() == &TokenType::LParen {
2463 self.advance();
2464
2465 let distinct = self.match_token(TokenType::Distinct);
2467
2468 let args = if self.peek_type() == &TokenType::RParen {
2469 vec![]
2470 } else if self.peek_type() == &TokenType::Star {
2471 self.advance();
2472 vec![Expr::Wildcard]
2473 } else {
2474 self.parse_expr_list()?
2475 };
2476 self.expect(TokenType::RParen)?;
2477
2478 if let Some(typed) = Self::try_typed_function(&name, args.clone(), distinct) {
2480 Ok(typed)
2481 } else {
2482 Ok(Expr::Function {
2483 name,
2484 args,
2485 distinct,
2486 filter: None,
2487 over: None,
2488 })
2489 }
2490 }
2491 else if self.match_token(TokenType::Dot) {
2493 if self.peek_type() == &TokenType::Star {
2494 self.advance();
2495 Ok(Expr::QualifiedWildcard { table: name })
2496 } else {
2497 let (col, col_qs) = self.expect_name_with_quote()?;
2498 Ok(Expr::Column {
2499 table: Some(name),
2500 name: col,
2501 quote_style: col_qs,
2502 table_quote_style: name_qs,
2503 })
2504 }
2505 } else {
2506 Ok(Expr::Column {
2507 table: None,
2508 name,
2509 quote_style: name_qs,
2510 table_quote_style: QuoteStyle::None,
2511 })
2512 }
2513 }
2514
2515 _ => Err(SqlglotError::UnexpectedToken { token }),
2516 }
2517 }
2518
2519 fn is_data_type_token(&self) -> bool {
2520 matches!(
2521 self.peek_type(),
2522 TokenType::Int
2523 | TokenType::Integer
2524 | TokenType::BigInt
2525 | TokenType::SmallInt
2526 | TokenType::TinyInt
2527 | TokenType::Float
2528 | TokenType::Double
2529 | TokenType::Decimal
2530 | TokenType::Numeric
2531 | TokenType::Real
2532 | TokenType::Varchar
2533 | TokenType::Char
2534 | TokenType::Text
2535 | TokenType::Boolean
2536 | TokenType::Date
2537 | TokenType::Timestamp
2538 | TokenType::TimestampTz
2539 | TokenType::Time
2540 | TokenType::Interval
2541 | TokenType::Blob
2542 | TokenType::Bytea
2543 | TokenType::Json
2544 | TokenType::Jsonb
2545 | TokenType::Uuid
2546 | TokenType::Array
2547 | TokenType::Map
2548 | TokenType::Struct
2549 )
2550 }
2551
2552 fn parse_datetime_field(&mut self) -> Result<DateTimeField> {
2553 let token = self.peek().clone();
2554 let field = match &token.token_type {
2555 TokenType::Year => DateTimeField::Year,
2556 TokenType::Month => DateTimeField::Month,
2557 TokenType::Day => DateTimeField::Day,
2558 TokenType::Hour => DateTimeField::Hour,
2559 TokenType::Minute => DateTimeField::Minute,
2560 TokenType::Second => DateTimeField::Second,
2561 TokenType::Epoch => DateTimeField::Epoch,
2562 _ => {
2563 let name = token.value.to_uppercase();
2564 match name.as_str() {
2565 "YEAR" => DateTimeField::Year,
2566 "QUARTER" => DateTimeField::Quarter,
2567 "MONTH" => DateTimeField::Month,
2568 "WEEK" => DateTimeField::Week,
2569 "DAY" => DateTimeField::Day,
2570 "DOW" | "DAYOFWEEK" => DateTimeField::DayOfWeek,
2571 "DOY" | "DAYOFYEAR" => DateTimeField::DayOfYear,
2572 "HOUR" => DateTimeField::Hour,
2573 "MINUTE" => DateTimeField::Minute,
2574 "SECOND" => DateTimeField::Second,
2575 "MILLISECOND" => DateTimeField::Millisecond,
2576 "MICROSECOND" => DateTimeField::Microsecond,
2577 "NANOSECOND" => DateTimeField::Nanosecond,
2578 "EPOCH" => DateTimeField::Epoch,
2579 "TIMEZONE" => DateTimeField::Timezone,
2580 "TIMEZONE_HOUR" => DateTimeField::TimezoneHour,
2581 "TIMEZONE_MINUTE" => DateTimeField::TimezoneMinute,
2582 _ => {
2583 return Err(SqlglotError::ParserError {
2584 message: format!("Unknown datetime field: {name}"),
2585 });
2586 }
2587 }
2588 }
2589 };
2590 self.advance();
2591 Ok(field)
2592 }
2593
2594 fn try_parse_datetime_field(&mut self) -> Option<DateTimeField> {
2595 let saved = self.pos;
2596 match self.parse_datetime_field() {
2597 Ok(field) => Some(field),
2598 Err(_) => {
2599 self.pos = saved;
2600 None
2601 }
2602 }
2603 }
2604
2605 fn try_typed_function(name: &str, args: Vec<Expr>, distinct: bool) -> Option<Expr> {
2609 let upper = name.to_uppercase();
2610 let tf = match upper.as_str() {
2611 "DATE_ADD" | "DATEADD" | "TIMESTAMPADD" => {
2613 let mut it = args.into_iter();
2614 let first = it.next()?;
2615 let second = it.next()?;
2616 let third = it.next();
2617 if upper == "DATEADD" {
2619 if let Some(third_arg) = third {
2620 let unit = Self::expr_to_datetime_field(&first);
2622 TypedFunction::DateAdd {
2623 expr: Box::new(third_arg),
2624 interval: Box::new(second),
2625 unit,
2626 }
2627 } else {
2628 TypedFunction::DateAdd {
2629 expr: Box::new(first),
2630 interval: Box::new(second),
2631 unit: None,
2632 }
2633 }
2634 } else {
2635 let unit = third.as_ref().and_then(Self::expr_to_datetime_field);
2637 TypedFunction::DateAdd {
2638 expr: Box::new(first),
2639 interval: Box::new(second),
2640 unit,
2641 }
2642 }
2643 }
2644 "DATE_DIFF" | "DATEDIFF" | "TIMESTAMPDIFF" => {
2645 let mut it = args.into_iter();
2646 let first = it.next()?;
2647 let second = it.next()?;
2648 let third = it.next();
2649 if let Some(third_arg) = third {
2650 if upper == "DATEDIFF" {
2651 let unit = Self::expr_to_datetime_field(&first);
2653 TypedFunction::DateDiff {
2654 start: Box::new(second),
2655 end: Box::new(third_arg),
2656 unit,
2657 }
2658 } else {
2659 let unit = Self::expr_to_datetime_field(&third_arg);
2660 TypedFunction::DateDiff {
2661 start: Box::new(first),
2662 end: Box::new(second),
2663 unit,
2664 }
2665 }
2666 } else {
2667 TypedFunction::DateDiff {
2668 start: Box::new(first),
2669 end: Box::new(second),
2670 unit: None,
2671 }
2672 }
2673 }
2674 "DATE_TRUNC" | "DATETRUNC" => {
2675 let mut it = args.into_iter();
2676 let first = it.next()?;
2677 let second = it.next()?;
2678 let (unit, expr) = if let Some(u) = Self::expr_to_datetime_field(&first) {
2680 (u, second)
2681 } else if let Some(u) = Self::expr_to_datetime_field(&second) {
2682 (u, first)
2683 } else {
2684 return None;
2686 };
2687 TypedFunction::DateTrunc {
2688 unit,
2689 expr: Box::new(expr),
2690 }
2691 }
2692 "DATE_SUB" | "DATESUB" => {
2693 let mut it = args.into_iter();
2694 let first = it.next()?;
2695 let second = it.next()?;
2696 let third = it.next();
2697 let unit = third.as_ref().and_then(Self::expr_to_datetime_field);
2698 TypedFunction::DateSub {
2699 expr: Box::new(first),
2700 interval: Box::new(second),
2701 unit,
2702 }
2703 }
2704 "CURRENT_DATE" => TypedFunction::CurrentDate,
2705 "CURRENT_TIMESTAMP" | "NOW" | "GETDATE" | "SYSDATE" => TypedFunction::CurrentTimestamp,
2706 "STR_TO_TIME" | "STR_TO_DATE" | "TO_TIMESTAMP" | "PARSE_TIMESTAMP"
2707 | "PARSE_DATETIME" => {
2708 let mut it = args.into_iter();
2709 let expr = it.next()?;
2710 let format = it.next()?;
2711 TypedFunction::StrToTime {
2712 expr: Box::new(expr),
2713 format: Box::new(format),
2714 }
2715 }
2716 "TIME_TO_STR" | "DATE_FORMAT" | "FORMAT_TIMESTAMP" | "FORMAT_DATETIME" | "TO_CHAR" => {
2717 let mut it = args.into_iter();
2718 let expr = it.next()?;
2719 let format = it.next()?;
2720 TypedFunction::TimeToStr {
2721 expr: Box::new(expr),
2722 format: Box::new(format),
2723 }
2724 }
2725 "TS_OR_DS_TO_DATE" => {
2726 let mut it = args.into_iter();
2727 TypedFunction::TsOrDsToDate {
2728 expr: Box::new(it.next()?),
2729 }
2730 }
2731 "YEAR" => {
2732 let mut it = args.into_iter();
2733 TypedFunction::Year {
2734 expr: Box::new(it.next()?),
2735 }
2736 }
2737 "MONTH" => {
2738 let mut it = args.into_iter();
2739 TypedFunction::Month {
2740 expr: Box::new(it.next()?),
2741 }
2742 }
2743 "DAY" | "DAYOFMONTH" => {
2744 let mut it = args.into_iter();
2745 TypedFunction::Day {
2746 expr: Box::new(it.next()?),
2747 }
2748 }
2749
2750 "TRIM" => {
2752 let mut it = args.into_iter();
2753 let expr = it.next()?;
2754 TypedFunction::Trim {
2755 expr: Box::new(expr),
2756 trim_type: TrimType::Both,
2757 trim_chars: None,
2758 }
2759 }
2760 "LTRIM" => {
2761 let mut it = args.into_iter();
2762 let expr = it.next()?;
2763 TypedFunction::Trim {
2764 expr: Box::new(expr),
2765 trim_type: TrimType::Leading,
2766 trim_chars: None,
2767 }
2768 }
2769 "RTRIM" => {
2770 let mut it = args.into_iter();
2771 let expr = it.next()?;
2772 TypedFunction::Trim {
2773 expr: Box::new(expr),
2774 trim_type: TrimType::Trailing,
2775 trim_chars: None,
2776 }
2777 }
2778 "SUBSTRING" | "SUBSTR" => {
2779 let mut it = args.into_iter();
2780 let expr = it.next()?;
2781 let start = it.next()?;
2782 let length = it.next();
2783 TypedFunction::Substring {
2784 expr: Box::new(expr),
2785 start: Box::new(start),
2786 length: length.map(Box::new),
2787 }
2788 }
2789 "UPPER" | "UCASE" => {
2790 let mut it = args.into_iter();
2791 TypedFunction::Upper {
2792 expr: Box::new(it.next()?),
2793 }
2794 }
2795 "LOWER" | "LCASE" => {
2796 let mut it = args.into_iter();
2797 TypedFunction::Lower {
2798 expr: Box::new(it.next()?),
2799 }
2800 }
2801 "REGEXP_LIKE" | "RLIKE" => {
2802 let mut it = args.into_iter();
2803 let expr = it.next()?;
2804 let pattern = it.next()?;
2805 let flags = it.next();
2806 TypedFunction::RegexpLike {
2807 expr: Box::new(expr),
2808 pattern: Box::new(pattern),
2809 flags: flags.map(Box::new),
2810 }
2811 }
2812 "REGEXP_EXTRACT" | "REGEXP_SUBSTR" => {
2813 let mut it = args.into_iter();
2814 let expr = it.next()?;
2815 let pattern = it.next()?;
2816 let group_index = it.next();
2817 TypedFunction::RegexpExtract {
2818 expr: Box::new(expr),
2819 pattern: Box::new(pattern),
2820 group_index: group_index.map(Box::new),
2821 }
2822 }
2823 "REGEXP_REPLACE" => {
2824 let mut it = args.into_iter();
2825 let expr = it.next()?;
2826 let pattern = it.next()?;
2827 let replacement = it.next()?;
2828 let flags = it.next();
2829 TypedFunction::RegexpReplace {
2830 expr: Box::new(expr),
2831 pattern: Box::new(pattern),
2832 replacement: Box::new(replacement),
2833 flags: flags.map(Box::new),
2834 }
2835 }
2836 "CONCAT_WS" => {
2837 let mut it = args.into_iter();
2838 let separator = it.next()?;
2839 let exprs: Vec<Expr> = it.collect();
2840 TypedFunction::ConcatWs {
2841 separator: Box::new(separator),
2842 exprs,
2843 }
2844 }
2845 "SPLIT" | "STRING_SPLIT" => {
2846 let mut it = args.into_iter();
2847 let expr = it.next()?;
2848 let delimiter = it.next()?;
2849 TypedFunction::Split {
2850 expr: Box::new(expr),
2851 delimiter: Box::new(delimiter),
2852 }
2853 }
2854 "INITCAP" => {
2855 let mut it = args.into_iter();
2856 TypedFunction::Initcap {
2857 expr: Box::new(it.next()?),
2858 }
2859 }
2860 "LENGTH" | "LEN" | "CHAR_LENGTH" | "CHARACTER_LENGTH" => {
2861 let mut it = args.into_iter();
2862 TypedFunction::Length {
2863 expr: Box::new(it.next()?),
2864 }
2865 }
2866 "REPLACE" => {
2867 let mut it = args.into_iter();
2868 let expr = it.next()?;
2869 let from = it.next()?;
2870 let to = it.next()?;
2871 TypedFunction::Replace {
2872 expr: Box::new(expr),
2873 from: Box::new(from),
2874 to: Box::new(to),
2875 }
2876 }
2877 "REVERSE" => {
2878 let mut it = args.into_iter();
2879 TypedFunction::Reverse {
2880 expr: Box::new(it.next()?),
2881 }
2882 }
2883 "LEFT" => {
2884 let mut it = args.into_iter();
2885 let expr = it.next()?;
2886 let n = it.next()?;
2887 TypedFunction::Left {
2888 expr: Box::new(expr),
2889 n: Box::new(n),
2890 }
2891 }
2892 "RIGHT" => {
2893 let mut it = args.into_iter();
2894 let expr = it.next()?;
2895 let n = it.next()?;
2896 TypedFunction::Right {
2897 expr: Box::new(expr),
2898 n: Box::new(n),
2899 }
2900 }
2901 "LPAD" => {
2902 let mut it = args.into_iter();
2903 let expr = it.next()?;
2904 let length = it.next()?;
2905 let pad = it.next();
2906 TypedFunction::Lpad {
2907 expr: Box::new(expr),
2908 length: Box::new(length),
2909 pad: pad.map(Box::new),
2910 }
2911 }
2912 "RPAD" => {
2913 let mut it = args.into_iter();
2914 let expr = it.next()?;
2915 let length = it.next()?;
2916 let pad = it.next();
2917 TypedFunction::Rpad {
2918 expr: Box::new(expr),
2919 length: Box::new(length),
2920 pad: pad.map(Box::new),
2921 }
2922 }
2923
2924 "COUNT" => {
2926 let mut it = args.into_iter();
2927 let expr = it.next().unwrap_or(Expr::Wildcard);
2928 TypedFunction::Count {
2929 expr: Box::new(expr),
2930 distinct,
2931 }
2932 }
2933 "SUM" => {
2934 let mut it = args.into_iter();
2935 TypedFunction::Sum {
2936 expr: Box::new(it.next()?),
2937 distinct,
2938 }
2939 }
2940 "AVG" => {
2941 let mut it = args.into_iter();
2942 TypedFunction::Avg {
2943 expr: Box::new(it.next()?),
2944 distinct,
2945 }
2946 }
2947 "MIN" => {
2948 let mut it = args.into_iter();
2949 TypedFunction::Min {
2950 expr: Box::new(it.next()?),
2951 }
2952 }
2953 "MAX" => {
2954 let mut it = args.into_iter();
2955 TypedFunction::Max {
2956 expr: Box::new(it.next()?),
2957 }
2958 }
2959 "ARRAY_AGG" | "LIST" | "COLLECT_LIST" => {
2960 let mut it = args.into_iter();
2961 TypedFunction::ArrayAgg {
2962 expr: Box::new(it.next()?),
2963 distinct,
2964 }
2965 }
2966 "APPROX_DISTINCT" | "APPROX_COUNT_DISTINCT" => {
2967 let mut it = args.into_iter();
2968 TypedFunction::ApproxDistinct {
2969 expr: Box::new(it.next()?),
2970 }
2971 }
2972 "VARIANCE" | "VAR_SAMP" | "VAR" => {
2973 let mut it = args.into_iter();
2974 TypedFunction::Variance {
2975 expr: Box::new(it.next()?),
2976 }
2977 }
2978 "STDDEV" | "STDDEV_SAMP" => {
2979 let mut it = args.into_iter();
2980 TypedFunction::Stddev {
2981 expr: Box::new(it.next()?),
2982 }
2983 }
2984
2985 "ARRAY_CONCAT" | "ARRAY_CAT" => TypedFunction::ArrayConcat { arrays: args },
2987 "ARRAY_CONTAINS" => {
2988 let mut it = args.into_iter();
2989 let array = it.next()?;
2990 let element = it.next()?;
2991 TypedFunction::ArrayContains {
2992 array: Box::new(array),
2993 element: Box::new(element),
2994 }
2995 }
2996 "ARRAY_SIZE" | "ARRAY_LENGTH" | "CARDINALITY" => {
2997 let mut it = args.into_iter();
2998 TypedFunction::ArraySize {
2999 expr: Box::new(it.next()?),
3000 }
3001 }
3002 "EXPLODE" => {
3003 let mut it = args.into_iter();
3004 TypedFunction::Explode {
3005 expr: Box::new(it.next()?),
3006 }
3007 }
3008 "GENERATE_SERIES" | "SEQUENCE" => {
3009 let mut it = args.into_iter();
3010 let start = it.next()?;
3011 let stop = it.next()?;
3012 let step = it.next();
3013 TypedFunction::GenerateSeries {
3014 start: Box::new(start),
3015 stop: Box::new(stop),
3016 step: step.map(Box::new),
3017 }
3018 }
3019 "FLATTEN" => {
3020 let mut it = args.into_iter();
3021 TypedFunction::Flatten {
3022 expr: Box::new(it.next()?),
3023 }
3024 }
3025
3026 "JSON_EXTRACT" | "JSON_VALUE" => {
3028 let mut it = args.into_iter();
3029 let expr = it.next()?;
3030 let path = it.next()?;
3031 TypedFunction::JSONExtract {
3032 expr: Box::new(expr),
3033 path: Box::new(path),
3034 }
3035 }
3036 "JSON_EXTRACT_SCALAR" => {
3037 let mut it = args.into_iter();
3038 let expr = it.next()?;
3039 let path = it.next()?;
3040 TypedFunction::JSONExtractScalar {
3041 expr: Box::new(expr),
3042 path: Box::new(path),
3043 }
3044 }
3045 "PARSE_JSON" | "JSON_PARSE" => {
3046 let mut it = args.into_iter();
3047 TypedFunction::ParseJSON {
3048 expr: Box::new(it.next()?),
3049 }
3050 }
3051 "JSON_FORMAT" | "TO_JSON" | "TO_JSON_STRING" => {
3052 let mut it = args.into_iter();
3053 TypedFunction::JSONFormat {
3054 expr: Box::new(it.next()?),
3055 }
3056 }
3057
3058 "ROW_NUMBER" => TypedFunction::RowNumber,
3060 "RANK" => TypedFunction::Rank,
3061 "DENSE_RANK" => TypedFunction::DenseRank,
3062 "NTILE" => {
3063 let mut it = args.into_iter();
3064 TypedFunction::NTile {
3065 n: Box::new(it.next()?),
3066 }
3067 }
3068 "LEAD" => {
3069 let mut it = args.into_iter();
3070 let expr = it.next()?;
3071 let offset = it.next();
3072 let default = it.next();
3073 TypedFunction::Lead {
3074 expr: Box::new(expr),
3075 offset: offset.map(Box::new),
3076 default: default.map(Box::new),
3077 }
3078 }
3079 "LAG" => {
3080 let mut it = args.into_iter();
3081 let expr = it.next()?;
3082 let offset = it.next();
3083 let default = it.next();
3084 TypedFunction::Lag {
3085 expr: Box::new(expr),
3086 offset: offset.map(Box::new),
3087 default: default.map(Box::new),
3088 }
3089 }
3090 "FIRST_VALUE" => {
3091 let mut it = args.into_iter();
3092 TypedFunction::FirstValue {
3093 expr: Box::new(it.next()?),
3094 }
3095 }
3096 "LAST_VALUE" => {
3097 let mut it = args.into_iter();
3098 TypedFunction::LastValue {
3099 expr: Box::new(it.next()?),
3100 }
3101 }
3102
3103 "ABS" => {
3105 let mut it = args.into_iter();
3106 TypedFunction::Abs {
3107 expr: Box::new(it.next()?),
3108 }
3109 }
3110 "CEIL" | "CEILING" => {
3111 let mut it = args.into_iter();
3112 TypedFunction::Ceil {
3113 expr: Box::new(it.next()?),
3114 }
3115 }
3116 "FLOOR" => {
3117 let mut it = args.into_iter();
3118 TypedFunction::Floor {
3119 expr: Box::new(it.next()?),
3120 }
3121 }
3122 "ROUND" => {
3123 let mut it = args.into_iter();
3124 let expr = it.next()?;
3125 let decimals = it.next();
3126 TypedFunction::Round {
3127 expr: Box::new(expr),
3128 decimals: decimals.map(Box::new),
3129 }
3130 }
3131 "LOG" => {
3132 let mut it = args.into_iter();
3133 let expr = it.next()?;
3134 let base = it.next();
3135 TypedFunction::Log {
3136 expr: Box::new(expr),
3137 base: base.map(Box::new),
3138 }
3139 }
3140 "LN" => {
3141 let mut it = args.into_iter();
3142 TypedFunction::Ln {
3143 expr: Box::new(it.next()?),
3144 }
3145 }
3146 "POW" | "POWER" => {
3147 let mut it = args.into_iter();
3148 let base = it.next()?;
3149 let exponent = it.next()?;
3150 TypedFunction::Pow {
3151 base: Box::new(base),
3152 exponent: Box::new(exponent),
3153 }
3154 }
3155 "SQRT" => {
3156 let mut it = args.into_iter();
3157 TypedFunction::Sqrt {
3158 expr: Box::new(it.next()?),
3159 }
3160 }
3161 "GREATEST" => TypedFunction::Greatest { exprs: args },
3162 "LEAST" => TypedFunction::Least { exprs: args },
3163 "MOD" => {
3164 let mut it = args.into_iter();
3165 let left = it.next()?;
3166 let right = it.next()?;
3167 TypedFunction::Mod {
3168 left: Box::new(left),
3169 right: Box::new(right),
3170 }
3171 }
3172
3173 "HEX" | "TO_HEX" => {
3175 let mut it = args.into_iter();
3176 TypedFunction::Hex {
3177 expr: Box::new(it.next()?),
3178 }
3179 }
3180 "UNHEX" | "FROM_HEX" => {
3181 let mut it = args.into_iter();
3182 TypedFunction::Unhex {
3183 expr: Box::new(it.next()?),
3184 }
3185 }
3186 "MD5" => {
3187 let mut it = args.into_iter();
3188 TypedFunction::Md5 {
3189 expr: Box::new(it.next()?),
3190 }
3191 }
3192 "SHA" | "SHA1" => {
3193 let mut it = args.into_iter();
3194 TypedFunction::Sha {
3195 expr: Box::new(it.next()?),
3196 }
3197 }
3198 "SHA2" | "SHA256" | "SHA512" => {
3199 let mut it = args.into_iter();
3200 let expr = it.next()?;
3201 let bit_length = it.next().unwrap_or(Expr::Number("256".to_string()));
3202 TypedFunction::Sha2 {
3203 expr: Box::new(expr),
3204 bit_length: Box::new(bit_length),
3205 }
3206 }
3207
3208 _ => return None,
3210 };
3211
3212 Some(Expr::TypedFunction {
3213 func: tf,
3214 filter: None,
3215 over: None,
3216 })
3217 }
3218
3219 fn expr_to_datetime_field(expr: &Expr) -> Option<DateTimeField> {
3221 match expr {
3222 Expr::Column {
3223 name, table: None, ..
3224 } => match name.to_uppercase().as_str() {
3225 "YEAR" => Some(DateTimeField::Year),
3226 "QUARTER" => Some(DateTimeField::Quarter),
3227 "MONTH" => Some(DateTimeField::Month),
3228 "WEEK" => Some(DateTimeField::Week),
3229 "DAY" => Some(DateTimeField::Day),
3230 "HOUR" => Some(DateTimeField::Hour),
3231 "MINUTE" => Some(DateTimeField::Minute),
3232 "SECOND" => Some(DateTimeField::Second),
3233 "MILLISECOND" => Some(DateTimeField::Millisecond),
3234 "MICROSECOND" => Some(DateTimeField::Microsecond),
3235 _ => None,
3236 },
3237 Expr::StringLiteral(s) => match s.to_uppercase().as_str() {
3238 "YEAR" => Some(DateTimeField::Year),
3239 "QUARTER" => Some(DateTimeField::Quarter),
3240 "MONTH" => Some(DateTimeField::Month),
3241 "WEEK" => Some(DateTimeField::Week),
3242 "DAY" => Some(DateTimeField::Day),
3243 "HOUR" => Some(DateTimeField::Hour),
3244 "MINUTE" => Some(DateTimeField::Minute),
3245 "SECOND" => Some(DateTimeField::Second),
3246 "MILLISECOND" => Some(DateTimeField::Millisecond),
3247 "MICROSECOND" => Some(DateTimeField::Microsecond),
3248 _ => None,
3249 },
3250 _ => None,
3251 }
3252 }
3253
3254 fn parse_case_expr(&mut self) -> Result<Expr> {
3255 self.expect(TokenType::Case)?;
3256
3257 let operand = if self.peek_type() != &TokenType::When {
3258 Some(Box::new(self.parse_expr()?))
3259 } else {
3260 None
3261 };
3262
3263 let mut when_clauses = Vec::new();
3264 while self.match_token(TokenType::When) {
3265 let condition = self.parse_expr()?;
3266 self.expect(TokenType::Then)?;
3267 let result = self.parse_expr()?;
3268 when_clauses.push((condition, result));
3269 }
3270
3271 let else_clause = if self.match_token(TokenType::Else) {
3272 Some(Box::new(self.parse_expr()?))
3273 } else {
3274 None
3275 };
3276
3277 self.expect(TokenType::End)?;
3278
3279 Ok(Expr::Case {
3280 operand,
3281 when_clauses,
3282 else_clause,
3283 })
3284 }
3285}
3286
3287#[cfg(test)]
3288mod tests {
3289 use super::*;
3290
3291 #[test]
3292 fn test_parse_simple_select() {
3293 let stmt = Parser::new("SELECT a, b FROM t")
3294 .unwrap()
3295 .parse_statement()
3296 .unwrap();
3297 match stmt {
3298 Statement::Select(sel) => {
3299 assert_eq!(sel.columns.len(), 2);
3300 assert!(sel.from.is_some());
3301 }
3302 _ => panic!("Expected SELECT"),
3303 }
3304 }
3305
3306 #[test]
3307 fn test_parse_select_with_where() {
3308 let stmt = Parser::new("SELECT x FROM t WHERE x > 10")
3309 .unwrap()
3310 .parse_statement()
3311 .unwrap();
3312 match stmt {
3313 Statement::Select(sel) => assert!(sel.where_clause.is_some()),
3314 _ => panic!("Expected SELECT"),
3315 }
3316 }
3317
3318 #[test]
3319 fn test_parse_select_wildcard() {
3320 let stmt = Parser::new("SELECT * FROM users")
3321 .unwrap()
3322 .parse_statement()
3323 .unwrap();
3324 match stmt {
3325 Statement::Select(sel) => {
3326 assert_eq!(sel.columns.len(), 1);
3327 assert!(matches!(sel.columns[0], SelectItem::Wildcard));
3328 }
3329 _ => panic!("Expected SELECT"),
3330 }
3331 }
3332
3333 #[test]
3334 fn test_parse_insert() {
3335 let stmt = Parser::new("INSERT INTO t (a, b) VALUES (1, 'hello')")
3336 .unwrap()
3337 .parse_statement()
3338 .unwrap();
3339 match stmt {
3340 Statement::Insert(ins) => {
3341 assert_eq!(ins.table.name, "t");
3342 assert_eq!(ins.columns, vec!["a", "b"]);
3343 match &ins.source {
3344 InsertSource::Values(rows) => {
3345 assert_eq!(rows.len(), 1);
3346 assert_eq!(rows[0].len(), 2);
3347 }
3348 _ => panic!("Expected VALUES"),
3349 }
3350 }
3351 _ => panic!("Expected INSERT"),
3352 }
3353 }
3354
3355 #[test]
3356 fn test_parse_delete() {
3357 let stmt = Parser::new("DELETE FROM users WHERE id = 1")
3358 .unwrap()
3359 .parse_statement()
3360 .unwrap();
3361 match stmt {
3362 Statement::Delete(del) => {
3363 assert_eq!(del.table.name, "users");
3364 assert!(del.where_clause.is_some());
3365 }
3366 _ => panic!("Expected DELETE"),
3367 }
3368 }
3369
3370 #[test]
3371 fn test_parse_join() {
3372 let stmt = Parser::new("SELECT a.id, b.name FROM a INNER JOIN b ON a.id = b.a_id")
3373 .unwrap()
3374 .parse_statement()
3375 .unwrap();
3376 match stmt {
3377 Statement::Select(sel) => {
3378 assert_eq!(sel.joins.len(), 1);
3379 assert_eq!(sel.joins[0].join_type, JoinType::Inner);
3380 }
3381 _ => panic!("Expected SELECT"),
3382 }
3383 }
3384
3385 #[test]
3386 fn test_parse_cte() {
3387 let stmt = Parser::new("WITH cte AS (SELECT 1 AS x) SELECT x FROM cte")
3388 .unwrap()
3389 .parse_statement()
3390 .unwrap();
3391 match stmt {
3392 Statement::Select(sel) => {
3393 assert_eq!(sel.ctes.len(), 1);
3394 assert_eq!(sel.ctes[0].name, "cte");
3395 }
3396 _ => panic!("Expected SELECT"),
3397 }
3398 }
3399
3400 #[test]
3401 fn test_parse_union() {
3402 let stmt = Parser::new("SELECT 1 UNION ALL SELECT 2")
3403 .unwrap()
3404 .parse_statement()
3405 .unwrap();
3406 match stmt {
3407 Statement::SetOperation(sop) => {
3408 assert_eq!(sop.op, SetOperationType::Union);
3409 assert!(sop.all);
3410 }
3411 _ => panic!("Expected SetOperation"),
3412 }
3413 }
3414
3415 #[test]
3416 fn test_parse_cast() {
3417 let stmt = Parser::new("SELECT CAST(x AS INT) FROM t")
3418 .unwrap()
3419 .parse_statement()
3420 .unwrap();
3421 match stmt {
3422 Statement::Select(sel) => {
3423 if let SelectItem::Expr { expr, .. } = &sel.columns[0] {
3424 assert!(matches!(expr, Expr::Cast { .. }));
3425 }
3426 }
3427 _ => panic!("Expected SELECT"),
3428 }
3429 }
3430
3431 #[test]
3432 fn test_parse_subquery() {
3433 let stmt = Parser::new("SELECT * FROM (SELECT 1 AS x) AS sub")
3434 .unwrap()
3435 .parse_statement()
3436 .unwrap();
3437 match stmt {
3438 Statement::Select(sel) => {
3439 if let Some(from) = &sel.from {
3440 assert!(matches!(from.source, TableSource::Subquery { .. }));
3441 }
3442 }
3443 _ => panic!("Expected SELECT"),
3444 }
3445 }
3446
3447 #[test]
3448 fn test_parse_exists() {
3449 let stmt = Parser::new("SELECT * FROM t WHERE EXISTS (SELECT 1 FROM t2)")
3450 .unwrap()
3451 .parse_statement()
3452 .unwrap();
3453 match stmt {
3454 Statement::Select(sel) => {
3455 assert!(sel.where_clause.is_some());
3456 }
3457 _ => panic!("Expected SELECT"),
3458 }
3459 }
3460
3461 #[test]
3462 fn test_parse_window_function() {
3463 let stmt = Parser::new(
3464 "SELECT ROW_NUMBER() OVER (PARTITION BY dept ORDER BY salary DESC) FROM emp",
3465 )
3466 .unwrap()
3467 .parse_statement()
3468 .unwrap();
3469 match stmt {
3470 Statement::Select(sel) => {
3471 if let SelectItem::Expr { expr, .. } = &sel.columns[0] {
3472 match expr {
3473 Expr::TypedFunction { over, .. } => {
3474 assert!(over.is_some());
3475 }
3476 Expr::Function { over, .. } => {
3477 assert!(over.is_some());
3478 }
3479 _ => panic!("Expected function"),
3480 }
3481 }
3482 }
3483 _ => panic!("Expected SELECT"),
3484 }
3485 }
3486
3487 #[test]
3488 fn test_parse_multiple_statements() {
3489 let stmts = Parser::new("SELECT 1; SELECT 2;")
3490 .unwrap()
3491 .parse_statements()
3492 .unwrap();
3493 assert_eq!(stmts.len(), 2);
3494 }
3495
3496 #[test]
3497 fn test_parse_insert_select() {
3498 let stmt = Parser::new("INSERT INTO t SELECT * FROM s")
3499 .unwrap()
3500 .parse_statement()
3501 .unwrap();
3502 match stmt {
3503 Statement::Insert(ins) => {
3504 assert!(matches!(ins.source, InsertSource::Query(_)));
3505 }
3506 _ => panic!("Expected INSERT"),
3507 }
3508 }
3509
3510 #[test]
3511 fn test_parse_create_table_constraints() {
3512 let stmt =
3513 Parser::new("CREATE TABLE t (id INT PRIMARY KEY, name VARCHAR(100) NOT NULL UNIQUE)")
3514 .unwrap()
3515 .parse_statement()
3516 .unwrap();
3517 match stmt {
3518 Statement::CreateTable(ct) => {
3519 assert_eq!(ct.columns.len(), 2);
3520 assert!(ct.columns[0].primary_key);
3521 assert!(ct.columns[1].unique);
3522 }
3523 _ => panic!("Expected CREATE TABLE"),
3524 }
3525 }
3526
3527 #[test]
3528 fn test_parse_extract() {
3529 let stmt = Parser::new("SELECT EXTRACT(YEAR FROM created_at) FROM t")
3530 .unwrap()
3531 .parse_statement()
3532 .unwrap();
3533 match stmt {
3534 Statement::Select(sel) => {
3535 if let SelectItem::Expr { expr, .. } = &sel.columns[0] {
3536 assert!(matches!(expr, Expr::Extract { .. }));
3537 }
3538 }
3539 _ => panic!("Expected SELECT"),
3540 }
3541 }
3542
3543 #[test]
3544 fn test_parse_postgres_cast() {
3545 let stmt = Parser::new("SELECT x::int FROM t")
3546 .unwrap()
3547 .parse_statement()
3548 .unwrap();
3549 match stmt {
3550 Statement::Select(sel) => {
3551 if let SelectItem::Expr { expr, .. } = &sel.columns[0] {
3552 assert!(matches!(expr, Expr::Cast { .. }));
3553 }
3554 }
3555 _ => panic!("Expected SELECT"),
3556 }
3557 }
3558}