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