ddb_core/parser/
parser.rs

1// SQL Parser - converts tokens into AST
2use crate::error::{DdbError, Result};
3use crate::lexer::{Token, TokenType};
4use super::ast::*;
5
6pub struct Parser {
7    tokens: Vec<Token>,
8    position: usize,
9}
10
11impl Parser {
12    pub fn new(tokens: Vec<Token>) -> Self {
13        Parser { tokens, position: 0 }
14    }
15
16    /// Parse tokens into a Statement
17    pub fn parse(&mut self) -> Result<Statement> {
18        let token = self.peek()?;
19
20        match &token.token_type {
21            TokenType::Select => self.parse_select(),
22            TokenType::Insert => self.parse_insert(),
23            TokenType::Update => self.parse_update(),
24            TokenType::Delete => self.parse_delete(),
25            TokenType::Upsert => self.parse_upsert(),
26            TokenType::Create => self.parse_create(),
27            TokenType::Drop => self.parse_drop(),
28            TokenType::Use => self.parse_use(),
29            TokenType::Show => self.parse_show(),
30            TokenType::Set => self.parse_set(),
31            TokenType::Begin => {
32                self.advance()?;
33                Ok(Statement::Begin)
34            }
35            TokenType::Commit => {
36                self.advance()?;
37                Ok(Statement::Commit)
38            }
39            TokenType::Rollback => {
40                self.advance()?;
41                Ok(Statement::Rollback)
42            }
43            _ => Err(DdbError::ParseError(format!(
44                "Unexpected token: {:?}",
45                token.token_type
46            ))),
47        }
48    }
49
50    /// Parse SELECT statement
51    fn parse_select(&mut self) -> Result<Statement> {
52        self.expect(TokenType::Select)?;
53
54        // Check for DISTINCT
55        let distinct = self.match_token(TokenType::Distinct);
56
57        // Parse columns
58        let columns = self.parse_select_columns()?;
59
60        // Parse FROM clause
61        let from = if self.match_token(TokenType::From) {
62            Some(self.expect_identifier()?)
63        } else {
64            None
65        };
66
67        // Parse JOINs (must come after FROM, before WHERE)
68        let joins = self.parse_joins()?;
69
70        // Parse WHERE clause
71        let where_clause = if self.match_token(TokenType::Where) {
72            Some(self.parse_expression()?)
73        } else {
74            None
75        };
76
77        // Parse GROUP BY (must come after WHERE, before ORDER BY)
78        let group_by = if self.match_token(TokenType::Group) {
79            self.expect(TokenType::By)?;
80            self.parse_group_by()?
81        } else if self.match_token(TokenType::GroupBy) {
82            self.parse_group_by()?
83        } else {
84            Vec::new()
85        };
86
87        // Parse HAVING (must come after GROUP BY)
88        let having = if self.match_token(TokenType::Having) {
89            Some(self.parse_expression()?)
90        } else {
91            None
92        };
93
94        // Parse ORDER BY
95        let order_by = if self.match_token(TokenType::OrderBy) {
96            self.parse_order_by()?
97        } else if self.match_token(TokenType::Order) {
98            self.expect(TokenType::By)?;
99            self.parse_order_by()?
100        } else {
101            Vec::new()
102        };
103
104        // Parse LIMIT
105        let limit = if self.match_token(TokenType::Limit) {
106            Some(self.parse_limit()?)
107        } else {
108            None
109        };
110
111        Ok(Statement::Select(SelectStatement {
112            distinct,
113            columns,
114            from,
115            joins,
116            where_clause,
117            group_by,
118            having,
119            order_by,
120            limit,
121        }))
122    }
123
124    /// Parse select columns (*, column names, functions)
125    fn parse_select_columns(&mut self) -> Result<Vec<SelectColumn>> {
126        let mut columns = Vec::new();
127
128        loop {
129            // Check for *
130            if self.match_token(TokenType::Star) {
131                columns.push(SelectColumn::Wildcard);
132            } else if matches!(self.peek()?.token_type, TokenType::Identifier(_)) {
133                let name = self.expect_identifier()?;
134
135                // Check for function call
136                if self.match_token(TokenType::LeftParen) {
137                    let args = self.parse_function_args()?;
138                    self.expect(TokenType::RightParen)?;
139
140                    let alias = if self.match_token(TokenType::As) {
141                        Some(self.expect_identifier()?)
142                    } else {
143                        None
144                    };
145
146                    columns.push(SelectColumn::Function { name, args, alias });
147                } else {
148                    // Regular column
149                    let alias = if self.match_token(TokenType::As) {
150                        Some(self.expect_identifier()?)
151                    } else {
152                        None
153                    };
154
155                    columns.push(SelectColumn::Column { name, alias });
156                }
157            } else {
158                return Err(DdbError::ParseError(
159                    "Expected column name or *".to_string()
160                ));
161            }
162
163            if !self.match_token(TokenType::Comma) {
164                break;
165            }
166        }
167
168        Ok(columns)
169    }
170
171    /// Parse ORDER BY clause
172    fn parse_order_by(&mut self) -> Result<Vec<OrderByColumn>> {
173        let mut order_by = Vec::new();
174
175        loop {
176            let column = self.expect_identifier()?;
177            let direction = if self.match_token(TokenType::Desc) {
178                OrderDirection::Desc
179            } else {
180                self.match_token(TokenType::Asc); // Optional ASC
181                OrderDirection::Asc
182            };
183
184            order_by.push(OrderByColumn { column, direction });
185
186            if !self.match_token(TokenType::Comma) {
187                break;
188            }
189        }
190
191        Ok(order_by)
192    }
193
194    /// Parse LIMIT clause
195    fn parse_limit(&mut self) -> Result<Limit> {
196        let first = self.expect_integer()?;
197
198        if self.match_token(TokenType::Comma) {
199            // LIMIT offset, count
200            let count = self.expect_integer()?;
201            Ok(Limit {
202                offset: Some(first as usize),
203                count: count as usize,
204            })
205        } else if self.match_token(TokenType::Offset) {
206            // LIMIT count OFFSET offset
207            let offset = self.expect_integer()?;
208            Ok(Limit {
209                offset: Some(offset as usize),
210                count: first as usize,
211            })
212        } else {
213            // LIMIT count
214            Ok(Limit {
215                offset: None,
216                count: first as usize,
217            })
218        }
219    }
220
221    /// Parse JOIN clauses
222    fn parse_joins(&mut self) -> Result<Vec<JoinClause>> {
223        let mut joins = Vec::new();
224
225        loop {
226            // Check for join type
227            let join_type = if self.match_token(TokenType::Inner) {
228                self.expect(TokenType::Join)?;
229                JoinType::Inner
230            } else if self.match_token(TokenType::Left) {
231                self.match_token(TokenType::Outer); // Optional OUTER keyword
232                self.expect(TokenType::Join)?;
233                JoinType::Left
234            } else if self.match_token(TokenType::Right) {
235                self.match_token(TokenType::Outer); // Optional OUTER keyword
236                self.expect(TokenType::Join)?;
237                JoinType::Right
238            } else if self.match_token(TokenType::Full) {
239                self.match_token(TokenType::Outer); // Optional OUTER keyword
240                self.expect(TokenType::Join)?;
241                JoinType::Full
242            } else if self.match_token(TokenType::Join) {
243                // Default to INNER JOIN
244                JoinType::Inner
245            } else {
246                // No more joins
247                break;
248            };
249
250            // Parse table name
251            let table = self.expect_identifier()?;
252
253            // Parse ON condition
254            self.expect(TokenType::On)?;
255            let on_condition = self.parse_expression()?;
256
257            joins.push(JoinClause {
258                join_type,
259                table,
260                on_condition,
261            });
262        }
263
264        Ok(joins)
265    }
266
267    /// Parse GROUP BY clause (column list)
268    fn parse_group_by(&mut self) -> Result<Vec<String>> {
269        let mut group_by = Vec::new();
270
271        loop {
272            group_by.push(self.expect_identifier()?);
273
274            if !self.match_token(TokenType::Comma) {
275                break;
276            }
277        }
278
279        Ok(group_by)
280    }
281
282    /// Parse INSERT statement
283    fn parse_insert(&mut self) -> Result<Statement> {
284        self.expect(TokenType::Insert)?;
285        self.expect(TokenType::Into)?;
286
287        let table = self.expect_identifier()?;
288
289        // Parse column list (optional)
290        let columns = if self.match_token(TokenType::LeftParen) {
291            let cols = self.parse_identifier_list()?;
292            self.expect(TokenType::RightParen)?;
293            cols
294        } else {
295            Vec::new()
296        };
297
298        self.expect(TokenType::Values)?;
299
300        // Parse values
301        let mut values = Vec::new();
302        loop {
303            self.expect(TokenType::LeftParen)?;
304            let value_row = self.parse_expression_list()?;
305            self.expect(TokenType::RightParen)?;
306            values.push(value_row);
307
308            if !self.match_token(TokenType::Comma) {
309                break;
310            }
311        }
312
313        Ok(Statement::Insert(InsertStatement {
314            table,
315            columns,
316            values,
317        }))
318    }
319
320    /// Parse UPSERT statement
321    /// Syntax: UPSERT INTO table (columns) VALUES (...) ON key_column
322    fn parse_upsert(&mut self) -> Result<Statement> {
323        self.expect(TokenType::Upsert)?;
324        self.expect(TokenType::Into)?;
325
326        let table = self.expect_identifier()?;
327
328        // Parse column list (required for UPSERT)
329        self.expect(TokenType::LeftParen)?;
330        let columns = self.parse_identifier_list()?;
331        self.expect(TokenType::RightParen)?;
332
333        self.expect(TokenType::Values)?;
334
335        // Parse values
336        let mut values = Vec::new();
337        loop {
338            self.expect(TokenType::LeftParen)?;
339            let value_row = self.parse_expression_list()?;
340            self.expect(TokenType::RightParen)?;
341            values.push(value_row);
342
343            if !self.match_token(TokenType::Comma) {
344                break;
345            }
346        }
347
348        // Parse ON key_column
349        self.expect(TokenType::On)?;
350        let key_column = self.expect_identifier()?;
351
352        Ok(Statement::Upsert(UpsertStatement {
353            table,
354            columns,
355            values,
356            key_column,
357        }))
358    }
359
360    /// Parse UPDATE statement
361    fn parse_update(&mut self) -> Result<Statement> {
362        self.expect(TokenType::Update)?;
363        let table = self.expect_identifier()?;
364        self.expect(TokenType::Set)?;
365
366        // Parse assignments
367        let mut assignments = Vec::new();
368        loop {
369            let column = self.expect_identifier()?;
370            self.expect(TokenType::Equal)?;
371            let value = self.parse_expression()?;
372            assignments.push((column, value));
373
374            if !self.match_token(TokenType::Comma) {
375                break;
376            }
377        }
378
379        // Parse WHERE clause
380        let where_clause = if self.match_token(TokenType::Where) {
381            Some(self.parse_expression()?)
382        } else {
383            None
384        };
385
386        Ok(Statement::Update(UpdateStatement {
387            table,
388            assignments,
389            where_clause,
390        }))
391    }
392
393    /// Parse DELETE statement
394    fn parse_delete(&mut self) -> Result<Statement> {
395        self.expect(TokenType::Delete)?;
396        self.expect(TokenType::From)?;
397        let table = self.expect_identifier()?;
398
399        let where_clause = if self.match_token(TokenType::Where) {
400            Some(self.parse_expression()?)
401        } else {
402            None
403        };
404
405        Ok(Statement::Delete(DeleteStatement {
406            table,
407            where_clause,
408        }))
409    }
410
411    /// Parse CREATE TABLE statement
412    fn parse_create(&mut self) -> Result<Statement> {
413        self.expect(TokenType::Create)?;
414        self.expect(TokenType::Table)?;
415
416        // Check for IF NOT EXISTS
417        let if_not_exists = if self.match_token(TokenType::If) {
418            self.expect(TokenType::Not)?;
419            self.expect(TokenType::Exists)?;
420            true
421        } else {
422            false
423        };
424
425        let name = self.expect_identifier()?;
426
427        self.expect(TokenType::LeftParen)?;
428        let columns = self.parse_column_definitions()?;
429        self.expect(TokenType::RightParen)?;
430
431        // Parse optional FILE and DELIMITER
432        let mut file_path = String::new();
433        let mut delimiter = None;
434        let mut data_starts_on = None;
435        let mut comment_char = None;
436        let mut quote_char = None;
437
438        if self.match_token(TokenType::File) {
439            file_path = self.expect_string()?;
440        }
441
442        if self.match_token(TokenType::Delimiter) {
443            let delim_str = self.expect_string()?;
444            delimiter = delim_str.chars().next();
445        }
446
447        // Parse additional options
448        while let Ok(token) = self.peek() {
449            if let TokenType::Identifier(ref id) = token.token_type {
450                match id.to_uppercase().as_str() {
451                    "DATA_STARTS_ON" => {
452                        self.advance()?;
453                        data_starts_on = Some(self.expect_integer()? as usize);
454                    }
455                    "COMMENT_CHAR" => {
456                        self.advance()?;
457                        let comment_str = self.expect_string()?;
458                        comment_char = comment_str.chars().next();
459                    }
460                    "QUOTE_CHAR" => {
461                        self.advance()?;
462                        let quote_str = self.expect_string()?;
463                        quote_char = quote_str.chars().next();
464                    }
465                    _ => break,
466                }
467            } else {
468                break;
469            }
470        }
471
472        Ok(Statement::CreateTable(CreateTableStatement {
473            name,
474            columns,
475            file_path,
476            delimiter,
477            data_starts_on,
478            comment_char,
479            quote_char,
480            if_not_exists,
481        }))
482    }
483
484    /// Parse column definitions with types
485    fn parse_column_definitions(&mut self) -> Result<Vec<ColumnDefinition>> {
486        let mut columns = Vec::new();
487
488        loop {
489            let col_name = self.expect_identifier()?;
490
491            // Parse column type
492            let type_str = self.expect_identifier()?;
493            let data_type = self.parse_column_type(&type_str)?;
494
495            // Check for NULL/NOT NULL
496            let nullable = if self.match_token(TokenType::Not) {
497                self.expect(TokenType::Null)?;
498                false
499            } else {
500                self.match_token(TokenType::Null); // Optional NULL keyword
501                true
502            };
503
504            columns.push(ColumnDefinition {
505                name: col_name,
506                data_type,
507                nullable,
508            });
509
510            if !self.match_token(TokenType::Comma) {
511                break;
512            }
513        }
514
515        Ok(columns)
516    }
517
518    /// Parse column type from string
519    fn parse_column_type(&self, type_str: &str) -> Result<ColumnType> {
520        match type_str.to_uppercase().as_str() {
521            "INTEGER" | "INT" => Ok(ColumnType::Integer),
522            "FLOAT" | "DOUBLE" | "REAL" => Ok(ColumnType::Float),
523            "STRING" | "VARCHAR" | "TEXT" | "CHAR" => Ok(ColumnType::String),
524            "BOOLEAN" | "BOOL" => Ok(ColumnType::Boolean),
525            "DATE" => Ok(ColumnType::Date),
526            "DATETIME" | "TIMESTAMP" => Ok(ColumnType::DateTime),
527            "TIME" => Ok(ColumnType::Time),
528            _ => Err(DdbError::ParseError(format!(
529                "Unknown column type: {}",
530                type_str
531            ))),
532        }
533    }
534
535    /// Parse DROP TABLE statement
536    fn parse_drop(&mut self) -> Result<Statement> {
537        self.expect(TokenType::Drop)?;
538        self.expect(TokenType::Table)?;
539
540        // Check for IF EXISTS
541        let if_exists = if self.match_token(TokenType::If) {
542            self.expect(TokenType::Exists)?;
543            true
544        } else {
545            false
546        };
547
548        let name = self.expect_identifier()?;
549
550        Ok(Statement::DropTable(DropTableStatement { name, if_exists }))
551    }
552
553    /// Parse USE statement
554    fn parse_use(&mut self) -> Result<Statement> {
555        self.expect(TokenType::Use)?;
556        let database = self.expect_identifier()?;
557
558        Ok(Statement::Use(UseStatement { database }))
559    }
560
561    /// Parse SHOW statement
562    fn parse_show(&mut self) -> Result<Statement> {
563        self.expect(TokenType::Show)?;
564
565        let token = self.peek()?;
566        let show_stmt = match &token.token_type {
567            TokenType::Tables => {
568                self.advance()?;
569                ShowStatement::Tables
570            }
571            TokenType::Columns => {
572                self.advance()?;
573                self.expect(TokenType::From)?;
574                let table = self.expect_identifier()?;
575                ShowStatement::Columns(table)
576            }
577            TokenType::Variables => {
578                self.advance()?;
579                ShowStatement::Variables
580            }
581            _ => {
582                return Err(DdbError::ParseError(format!(
583                    "Expected TABLES, COLUMNS, or VARIABLES after SHOW, got {:?}",
584                    token.token_type
585                )))
586            }
587        };
588
589        Ok(Statement::Show(show_stmt))
590    }
591
592    /// Parse SET statement
593    fn parse_set(&mut self) -> Result<Statement> {
594        self.expect(TokenType::Set)?;
595        let variable = self.expect_identifier()?;
596        self.expect(TokenType::Equal)?;
597        let value = self.parse_expression()?;
598
599        Ok(Statement::Set(SetStatement { variable, value }))
600    }
601
602    /// Parse expression with operator precedence
603    fn parse_expression(&mut self) -> Result<Expression> {
604        self.parse_or_expression()
605    }
606
607    /// Parse OR expression
608    fn parse_or_expression(&mut self) -> Result<Expression> {
609        let mut left = self.parse_and_expression()?;
610
611        while self.match_token(TokenType::Or) {
612            let right = self.parse_and_expression()?;
613            left = Expression::BinaryOp {
614                left: Box::new(left),
615                op: BinaryOperator::Or,
616                right: Box::new(right),
617            };
618        }
619
620        Ok(left)
621    }
622
623    /// Parse AND expression
624    fn parse_and_expression(&mut self) -> Result<Expression> {
625        let mut left = self.parse_comparison_expression()?;
626
627        while self.match_token(TokenType::And) {
628            let right = self.parse_comparison_expression()?;
629            left = Expression::BinaryOp {
630                left: Box::new(left),
631                op: BinaryOperator::And,
632                right: Box::new(right),
633            };
634        }
635
636        Ok(left)
637    }
638
639    /// Parse comparison expression (=, <>, >, >=, <, <=, LIKE)
640    fn parse_comparison_expression(&mut self) -> Result<Expression> {
641        let mut left = self.parse_primary_expression()?;
642
643        while let Some(op) = self.match_comparison_op() {
644            let right = self.parse_primary_expression()?;
645            left = Expression::BinaryOp {
646                left: Box::new(left),
647                op,
648                right: Box::new(right),
649            };
650        }
651
652        Ok(left)
653    }
654
655    /// Match comparison operators
656    fn match_comparison_op(&mut self) -> Option<BinaryOperator> {
657        let token = self.peek().ok()?;
658
659        let op = match &token.token_type {
660            TokenType::Equal => Some(BinaryOperator::Equal),
661            TokenType::NotEqual => Some(BinaryOperator::NotEqual),
662            TokenType::GreaterThan => Some(BinaryOperator::GreaterThan),
663            TokenType::GreaterEqual => Some(BinaryOperator::GreaterEqual),
664            TokenType::LessThan => Some(BinaryOperator::LessThan),
665            TokenType::LessEqual => Some(BinaryOperator::LessEqual),
666            TokenType::Like => Some(BinaryOperator::Like),
667            _ => None,
668        };
669
670        if op.is_some() {
671            self.advance().ok();
672        }
673
674        op
675    }
676
677    /// Parse primary expression (literals, columns, functions, parentheses)
678    fn parse_primary_expression(&mut self) -> Result<Expression> {
679        let token = self.peek()?;
680
681        match &token.token_type {
682            TokenType::Not => {
683                self.advance()?;
684                let operand = self.parse_primary_expression()?;
685                Ok(Expression::UnaryOp {
686                    op: UnaryOperator::Not,
687                    operand: Box::new(operand),
688                })
689            }
690            TokenType::String(s) => {
691                let s = s.clone();
692                self.advance()?;
693                Ok(Expression::Literal(Literal::String(s)))
694            }
695            TokenType::Number(n_str) => {
696                let n_str = n_str.clone();
697                self.advance()?;
698
699                // Parse the number string
700                if let Ok(i) = n_str.parse::<i64>() {
701                    Ok(Expression::Literal(Literal::Integer(i)))
702                } else if let Ok(f) = n_str.parse::<f64>() {
703                    Ok(Expression::Literal(Literal::Number(f)))
704                } else {
705                    Err(DdbError::ParseError(format!("Invalid number: {}", n_str)))
706                }
707            }
708            TokenType::True => {
709                self.advance()?;
710                Ok(Expression::Literal(Literal::Boolean(true)))
711            }
712            TokenType::False => {
713                self.advance()?;
714                Ok(Expression::Literal(Literal::Boolean(false)))
715            }
716            TokenType::Null => {
717                self.advance()?;
718                Ok(Expression::Literal(Literal::Null))
719            }
720            TokenType::Identifier(_) => {
721                let name = self.expect_identifier()?;
722
723                // Check for system variable (@@VARIABLE)
724                if name.starts_with("@@") {
725                    let var_name = name[2..].to_string();
726                    return Ok(Expression::SystemVariable(var_name));
727                }
728
729                // Check for function call
730                if self.match_token(TokenType::LeftParen) {
731                    let args = self.parse_function_args()?;
732                    self.expect(TokenType::RightParen)?;
733                    Ok(Expression::Function { name, args })
734                } else {
735                    // Check for IS NULL
736                    if self.match_token(TokenType::Is) {
737                        self.expect(TokenType::Null)?;
738                        Ok(Expression::UnaryOp {
739                            op: UnaryOperator::IsNull,
740                            operand: Box::new(Expression::Column(name)),
741                        })
742                    } else {
743                        Ok(Expression::Column(name))
744                    }
745                }
746            }
747            TokenType::LeftParen => {
748                self.advance()?;
749                let expr = self.parse_expression()?;
750                self.expect(TokenType::RightParen)?;
751                Ok(expr)
752            }
753            _ => Err(DdbError::ParseError(format!(
754                "Unexpected token in expression: {:?}",
755                token.token_type
756            ))),
757        }
758    }
759
760    /// Parse function arguments
761    fn parse_function_args(&mut self) -> Result<Vec<Expression>> {
762        let mut args = Vec::new();
763
764        // Check for empty argument list
765        if matches!(self.peek()?.token_type, TokenType::RightParen) {
766            return Ok(args);
767        }
768
769        // Special case for COUNT(*)
770        if self.match_token(TokenType::Star) {
771            args.push(Expression::Column("*".to_string()));
772            return Ok(args);
773        }
774
775        loop {
776            args.push(self.parse_expression()?);
777
778            if !self.match_token(TokenType::Comma) {
779                break;
780            }
781        }
782
783        Ok(args)
784    }
785
786    /// Parse comma-separated list of expressions
787    fn parse_expression_list(&mut self) -> Result<Vec<Expression>> {
788        let mut exprs = Vec::new();
789
790        loop {
791            exprs.push(self.parse_expression()?);
792
793            if !self.match_token(TokenType::Comma) {
794                break;
795            }
796        }
797
798        Ok(exprs)
799    }
800
801    /// Parse comma-separated list of identifiers
802    fn parse_identifier_list(&mut self) -> Result<Vec<String>> {
803        let mut identifiers = Vec::new();
804
805        loop {
806            identifiers.push(self.expect_identifier()?);
807
808            // Skip optional type specification (e.g., INTEGER, STRING, DATE, etc.)
809            if self.peek().ok().map(|t| matches!(t.token_type, TokenType::Identifier(_))).unwrap_or(false) {
810                self.advance()?;
811            }
812
813            if !self.match_token(TokenType::Comma) {
814                break;
815            }
816        }
817
818        Ok(identifiers)
819    }
820
821    // ========== Helper methods ==========
822
823    /// Get current token without advancing
824    fn peek(&self) -> Result<&Token> {
825        self.tokens.get(self.position).ok_or_else(|| {
826            DdbError::ParseError("Unexpected end of input".to_string())
827        })
828    }
829
830    /// Advance to next token
831    fn advance(&mut self) -> Result<&Token> {
832        let pos = self.position;
833        if pos >= self.tokens.len() {
834            return Err(DdbError::ParseError("Unexpected end of input".to_string()));
835        }
836        self.position += 1;
837        Ok(&self.tokens[pos])
838    }
839
840    /// Check if current token matches expected type, advance if it does
841    fn match_token(&mut self, expected: TokenType) -> bool {
842        if let Ok(token) = self.peek() {
843            if std::mem::discriminant(&token.token_type) == std::mem::discriminant(&expected) {
844                self.advance().ok();
845                return true;
846            }
847        }
848        false
849    }
850
851    /// Expect specific token type, return error if not found
852    fn expect(&mut self, expected: TokenType) -> Result<()> {
853        let token = self.peek()?;
854        if std::mem::discriminant(&token.token_type) == std::mem::discriminant(&expected) {
855            self.advance()?;
856            Ok(())
857        } else {
858            Err(DdbError::ParseError(format!(
859                "Expected {:?}, got {:?}",
860                expected, token.token_type
861            )))
862        }
863    }
864
865    /// Expect identifier token
866    fn expect_identifier(&mut self) -> Result<String> {
867        let token = self.advance()?;
868        match &token.token_type {
869            TokenType::Identifier(name) => Ok(name.clone()),
870            _ => Err(DdbError::ParseError(format!(
871                "Expected identifier, got {:?}",
872                token.token_type
873            ))),
874        }
875    }
876
877    /// Expect string literal
878    fn expect_string(&mut self) -> Result<String> {
879        let token = self.advance()?;
880        match &token.token_type {
881            TokenType::String(s) => Ok(s.clone()),
882            _ => Err(DdbError::ParseError(format!(
883                "Expected string, got {:?}",
884                token.token_type
885            ))),
886        }
887    }
888
889    /// Expect integer literal
890    fn expect_integer(&mut self) -> Result<i64> {
891        let token = self.advance()?;
892        match &token.token_type {
893            TokenType::Number(n_str) => {
894                n_str.parse::<i64>().map_err(|_| {
895                    DdbError::ParseError(format!("Expected integer, got: {}", n_str))
896                })
897            }
898            _ => Err(DdbError::ParseError(format!(
899                "Expected integer, got {:?}",
900                token.token_type
901            ))),
902        }
903    }
904}
905
906#[cfg(test)]
907mod tests {
908    use super::*;
909    use crate::lexer::Tokenizer;
910
911    fn parse_sql(sql: &str) -> Result<Statement> {
912        let mut tokenizer = Tokenizer::new();
913        let tokens = tokenizer.tokenize(sql)?;
914        let mut parser = Parser::new(tokens);
915        parser.parse()
916    }
917
918    #[test]
919    fn test_parse_simple_select() {
920        let stmt = parse_sql("SELECT * FROM users").unwrap();
921
922        match stmt {
923            Statement::Select(sel) => {
924                assert!(!sel.distinct);
925                assert_eq!(sel.columns.len(), 1);
926                assert!(matches!(sel.columns[0], SelectColumn::Wildcard));
927                assert_eq!(sel.from, Some("users".to_string()));
928                assert!(sel.where_clause.is_none());
929            }
930            _ => panic!("Expected SELECT statement"),
931        }
932    }
933
934    #[test]
935    fn test_parse_select_with_columns() {
936        let stmt = parse_sql("SELECT id, name, email FROM users").unwrap();
937
938        match stmt {
939            Statement::Select(sel) => {
940                assert_eq!(sel.columns.len(), 3);
941            }
942            _ => panic!("Expected SELECT statement"),
943        }
944    }
945
946    #[test]
947    fn test_parse_select_with_where() {
948        let stmt = parse_sql("SELECT * FROM users WHERE age > 18").unwrap();
949
950        match stmt {
951            Statement::Select(sel) => {
952                assert!(sel.where_clause.is_some());
953            }
954            _ => panic!("Expected SELECT statement"),
955        }
956    }
957
958    #[test]
959    fn test_parse_select_with_functions() {
960        let stmt = parse_sql("SELECT COUNT(*), AVG(age) FROM users").unwrap();
961
962        match stmt {
963            Statement::Select(sel) => {
964                assert_eq!(sel.columns.len(), 2);
965            }
966            _ => panic!("Expected SELECT statement"),
967        }
968    }
969
970    #[test]
971    fn test_parse_select_with_order_by() {
972        let stmt = parse_sql("SELECT * FROM users ORDER BY name ASC, age DESC").unwrap();
973
974        match stmt {
975            Statement::Select(sel) => {
976                assert_eq!(sel.order_by.len(), 2);
977                assert!(matches!(sel.order_by[0].direction, OrderDirection::Asc));
978                assert!(matches!(sel.order_by[1].direction, OrderDirection::Desc));
979            }
980            _ => panic!("Expected SELECT statement"),
981        }
982    }
983
984    #[test]
985    fn test_parse_select_with_limit() {
986        let stmt = parse_sql("SELECT * FROM users LIMIT 10").unwrap();
987
988        match stmt {
989            Statement::Select(sel) => {
990                assert!(sel.limit.is_some());
991                let limit = sel.limit.unwrap();
992                assert_eq!(limit.count, 10);
993                assert!(limit.offset.is_none());
994            }
995            _ => panic!("Expected SELECT statement"),
996        }
997    }
998
999    #[test]
1000    fn test_parse_insert() {
1001        let stmt = parse_sql("INSERT INTO users (name, email) VALUES ('John', 'john@test.com')").unwrap();
1002
1003        match stmt {
1004            Statement::Insert(ins) => {
1005                assert_eq!(ins.table, "users");
1006                assert_eq!(ins.columns.len(), 2);
1007                assert_eq!(ins.values.len(), 1);
1008            }
1009            _ => panic!("Expected INSERT statement"),
1010        }
1011    }
1012
1013    #[test]
1014    fn test_parse_update() {
1015        let stmt = parse_sql("UPDATE users SET name = 'Jane' WHERE id = 1").unwrap();
1016
1017        match stmt {
1018            Statement::Update(upd) => {
1019                assert_eq!(upd.table, "users");
1020                assert_eq!(upd.assignments.len(), 1);
1021                assert!(upd.where_clause.is_some());
1022            }
1023            _ => panic!("Expected UPDATE statement"),
1024        }
1025    }
1026
1027    #[test]
1028    fn test_parse_delete() {
1029        let stmt = parse_sql("DELETE FROM users WHERE id = 1").unwrap();
1030
1031        match stmt {
1032            Statement::Delete(del) => {
1033                assert_eq!(del.table, "users");
1034                assert!(del.where_clause.is_some());
1035            }
1036            _ => panic!("Expected DELETE statement"),
1037        }
1038    }
1039
1040    #[test]
1041    fn test_parse_create_table() {
1042        let stmt = parse_sql(
1043            "CREATE TABLE users (id INTEGER NOT NULL, name STRING, age INTEGER)"
1044        ).unwrap();
1045
1046        match stmt {
1047            Statement::CreateTable(create) => {
1048                assert_eq!(create.name, "users");
1049                assert_eq!(create.columns.len(), 3);
1050                assert_eq!(create.columns[0].name, "id");
1051                assert!(matches!(create.columns[0].data_type, ColumnType::Integer));
1052                assert!(!create.columns[0].nullable);
1053                assert_eq!(create.columns[1].name, "name");
1054                assert!(matches!(create.columns[1].data_type, ColumnType::String));
1055                assert!(create.columns[1].nullable);
1056                assert_eq!(create.columns[2].name, "age");
1057                assert!(matches!(create.columns[2].data_type, ColumnType::Integer));
1058                assert!(create.columns[2].nullable);
1059                assert!(!create.if_not_exists);
1060            }
1061            _ => panic!("Expected CREATE TABLE statement"),
1062        }
1063    }
1064
1065    #[test]
1066    fn test_parse_create_table_if_not_exists() {
1067        let stmt = parse_sql(
1068            "CREATE TABLE IF NOT EXISTS users (id INTEGER NOT NULL)"
1069        ).unwrap();
1070
1071        match stmt {
1072            Statement::CreateTable(create) => {
1073                assert_eq!(create.name, "users");
1074                assert!(create.if_not_exists);
1075                assert_eq!(create.columns.len(), 1);
1076            }
1077            _ => panic!("Expected CREATE TABLE statement"),
1078        }
1079    }
1080
1081    #[test]
1082    fn test_parse_create_table_with_options() {
1083        let stmt = parse_sql(
1084            "CREATE TABLE users (id INTEGER, name STRING) FILE '/path/to/file.csv' DELIMITER ',' DATA_STARTS_ON 2 COMMENT_CHAR '#' QUOTE_CHAR '\"'"
1085        ).unwrap();
1086
1087        match stmt {
1088            Statement::CreateTable(create) => {
1089                assert_eq!(create.name, "users");
1090                assert_eq!(create.file_path, "/path/to/file.csv");
1091                assert_eq!(create.delimiter, Some(','));
1092                assert_eq!(create.data_starts_on, Some(2));
1093                assert_eq!(create.comment_char, Some('#'));
1094                assert_eq!(create.quote_char, Some('"'));
1095            }
1096            _ => panic!("Expected CREATE TABLE statement"),
1097        }
1098    }
1099
1100    #[test]
1101    fn test_parse_drop_table() {
1102        let stmt = parse_sql("DROP TABLE users").unwrap();
1103
1104        match stmt {
1105            Statement::DropTable(drop) => {
1106                assert_eq!(drop.name, "users");
1107                assert!(!drop.if_exists);
1108            }
1109            _ => panic!("Expected DROP TABLE statement"),
1110        }
1111    }
1112
1113    #[test]
1114    fn test_parse_drop_table_if_exists() {
1115        let stmt = parse_sql("DROP TABLE IF EXISTS users").unwrap();
1116
1117        match stmt {
1118            Statement::DropTable(drop) => {
1119                assert_eq!(drop.name, "users");
1120                assert!(drop.if_exists);
1121            }
1122            _ => panic!("Expected DROP TABLE statement"),
1123        }
1124    }
1125
1126    #[test]
1127    fn test_parse_set() {
1128        let stmt = parse_sql("SET output_format = 'json'").unwrap();
1129
1130        match stmt {
1131            Statement::Set(set) => {
1132                assert_eq!(set.variable, "output_format");
1133                match set.value {
1134                    Expression::Literal(Literal::String(s)) => assert_eq!(s, "json"),
1135                    _ => panic!("Expected string literal"),
1136                }
1137            }
1138            _ => panic!("Expected SET statement"),
1139        }
1140    }
1141
1142    #[test]
1143    fn test_parse_set_with_number() {
1144        let stmt = parse_sql("SET max_rows = 100").unwrap();
1145
1146        match stmt {
1147            Statement::Set(set) => {
1148                assert_eq!(set.variable, "max_rows");
1149                match set.value {
1150                    Expression::Literal(Literal::Integer(i)) => assert_eq!(i, 100),
1151                    _ => panic!("Expected integer literal"),
1152                }
1153            }
1154            _ => panic!("Expected SET statement"),
1155        }
1156    }
1157}
ddb_core/parser/parser.rs

ddb_core/parser/
parser.rs
