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