rook_parser/
parser.rs

1/// Syntactic Parser - Builds an Abstract Syntax Tree (AST) from tokens
2use crate::{LexicalToken, TokenType};
3use crate::ast::*;
4
5/// Parser errors
6#[derive(Debug, Clone, PartialEq)]
7pub struct ParseError {
8    pub message: String,
9    pub position: usize,
10}
11
12impl std::fmt::Display for ParseError {
13    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14        write!(f, "Parse Error at position {}: {}", self.position, self.message)
15    }
16}
17
18/// Syntactic Parser for SQL
19pub struct SyntacticParser {
20    tokens: Vec<LexicalToken>,
21    current: usize,
22}
23
24impl SyntacticParser {
25    /// Creates a new syntactic parser
26    pub fn new(tokens: Vec<LexicalToken>) -> Self {
27        SyntacticParser {
28            tokens,
29            current: 0,
30        }
31    }
32    
33    /// Parses tokens into a Statement
34    pub fn parse(&mut self) -> Result<Statement, ParseError> {
35        self.skip_whitespace();
36        
37        if self.current >= self.tokens.len() {
38            return Err(ParseError {
39                message: "Empty input".to_string(),
40                position: 0,
41            });
42        }
43        
44        let token = &self.tokens[self.current];
45        
46        match &token.token_type {
47            TokenType::Select => self.parse_select(),
48            TokenType::Insert => self.parse_insert(),
49            TokenType::Update => self.parse_update(),
50            TokenType::Delete => self.parse_delete(),
51            TokenType::Create => self.parse_create(),
52            TokenType::Drop => self.parse_drop(),
53            TokenType::Alter => self.parse_alter(),
54            _ => Err(ParseError {
55                message: format!("Unexpected token: {:?}", token.token_type),
56                position: self.current,
57            }),
58        }
59    }
60    
61    /// Parse SELECT statement
62    fn parse_select(&mut self) -> Result<Statement, ParseError> {
63        self.expect(TokenType::Select)?;
64        
65        // Check for DISTINCT
66        self.skip_whitespace();
67        let distinct = if self.check(&TokenType::Distinct) {
68            self.advance();
69            true
70        } else {
71            false
72        };
73        
74        // Parse SELECT list
75        self.skip_whitespace();
76        let select_list = self.parse_select_list()?;
77        
78        // Parse FROM clause
79        self.skip_whitespace();
80        let from_clause = if self.check(&TokenType::From) {
81            self.advance();
82            Some(self.parse_from_clause()?)
83        } else {
84            None
85        };
86        
87        // Parse WHERE clause
88        self.skip_whitespace();
89        let where_clause = if self.check(&TokenType::Where) {
90            self.advance();
91            Some(self.parse_expression()?)
92        } else {
93            None
94        };
95        
96        // Parse GROUP BY clause
97        self.skip_whitespace();
98        let group_by_clause = if self.check(&TokenType::Group) {
99            self.advance();
100            self.expect(TokenType::By)?;
101            Some(self.parse_expression_list()?)
102        } else {
103            None
104        };
105        
106        // Parse HAVING clause
107        self.skip_whitespace();
108        let having_clause = if self.check(&TokenType::Having) {
109            self.advance();
110            Some(self.parse_expression()?)
111        } else {
112            None
113        };
114        
115        // Parse ORDER BY clause
116        self.skip_whitespace();
117        let order_by_clause = if self.check(&TokenType::Order) {
118            self.advance();
119            self.skip_whitespace();
120            self.expect(TokenType::By)?;
121            Some(self.parse_order_by()?)
122        } else {
123            None
124        };
125        
126        // Parse LIMIT clause
127        self.skip_whitespace();
128        let limit_clause = if self.check(&TokenType::Limit) {
129            self.advance();
130            Some(self.parse_limit()?)
131        } else {
132            None
133        };
134        
135        Ok(Statement::Select(SelectStatement {
136            distinct,
137            select_list,
138            from_clause,
139            where_clause,
140            group_by_clause,
141            having_clause,
142            order_by_clause,
143            limit_clause,
144        }))
145    }
146    
147    /// Parse SELECT list
148    fn parse_select_list(&mut self) -> Result<Vec<SelectItem>, ParseError> {
149        let mut items = Vec::new();
150        
151        loop {
152            self.skip_whitespace();
153            
154            // Check for *
155            if self.check(&TokenType::Star) {
156                self.advance();
157                items.push(SelectItem::AllColumns);
158            } else {
159                let expr = self.parse_expression()?;
160                
161                // Check for alias
162                self.skip_whitespace();
163                let alias = if self.check(&TokenType::As) {
164                    self.advance();
165                    self.skip_whitespace();
166                    if let TokenType::Identifier(name) = &self.peek().token_type {
167                        let name = name.clone();
168                        self.advance();
169                        Some(name)
170                    } else {
171                        return Err(ParseError {
172                            message: "Expected identifier after AS".to_string(),
173                            position: self.current,
174                        });
175                    }
176                } else {
177                    None
178                };
179                
180                items.push(SelectItem::Column { expr, alias });
181            }
182            
183            self.skip_whitespace();
184            if !self.check(&TokenType::Comma) {
185                break;
186            }
187            self.advance(); // consume comma
188        }
189        
190        Ok(items)
191    }
192    
193    /// Parse FROM clause
194    fn parse_from_clause(&mut self) -> Result<FromClause, ParseError> {
195        self.skip_whitespace();
196        
197        // Parse table name
198        let table_name = if let TokenType::Identifier(name) = &self.peek().token_type {
199            let name = name.clone();
200            self.advance();
201            name
202        } else {
203            return Err(ParseError {
204                message: "Expected table name in FROM clause".to_string(),
205                position: self.current,
206            });
207        };
208        
209        // Check for alias
210        self.skip_whitespace();
211        let alias = if self.check(&TokenType::As) || self.is_alias_identifier_candidate() {
212            if self.check(&TokenType::As) {
213                self.advance();
214            }
215            self.skip_whitespace();
216            if let TokenType::Identifier(a) = &self.peek().token_type {
217                let a = a.clone();
218                self.advance();
219                Some(a)
220            } else {
221                None
222            }
223        } else {
224            None
225        };
226        
227        let table = TableReference {
228            name: table_name,
229            alias,
230        };
231        
232        // Parse JOINs
233        let mut joins = Vec::new();
234        loop {
235            self.skip_whitespace();
236            
237            if self.check(&TokenType::Inner) {
238                self.advance();
239                self.expect(TokenType::Join)?;
240                let (table, on_condition) = self.parse_join_target()?;
241                joins.push(Join {
242                    join_type: JoinType::Inner,
243                    table,
244                    on_condition,
245                });
246            } else if self.check(&TokenType::Left) {
247                self.advance();
248                self.skip_whitespace();
249                let _ = self.check(&TokenType::Outer); // OUTER is optional
250                if self.check(&TokenType::Outer) {
251                    self.advance();
252                }
253                self.expect(TokenType::Join)?;
254                let (table, on_condition) = self.parse_join_target()?;
255                joins.push(Join {
256                    join_type: JoinType::Left,
257                    table,
258                    on_condition,
259                });
260            } else if self.check(&TokenType::Right) {
261                self.advance();
262                self.skip_whitespace();
263                let _ = self.check(&TokenType::Outer);
264                if self.check(&TokenType::Outer) {
265                    self.advance();
266                }
267                self.expect(TokenType::Join)?;
268                let (table, on_condition) = self.parse_join_target()?;
269                joins.push(Join {
270                    join_type: JoinType::Right,
271                    table,
272                    on_condition,
273                });
274            } else if self.check(&TokenType::Join) {
275                self.advance();
276                let (table, on_condition) = self.parse_join_target()?;
277                joins.push(Join {
278                    join_type: JoinType::Inner,
279                    table,
280                    on_condition,
281                });
282            } else if self.check_identifier_keyword("FULL") {
283                self.advance();
284                self.skip_whitespace();
285                if self.check(&TokenType::Outer) {
286                    self.advance();
287                }
288                self.expect(TokenType::Join)?;
289                let (table, on_condition) = self.parse_join_target()?;
290                joins.push(Join {
291                    join_type: JoinType::Full,
292                    table,
293                    on_condition,
294                });
295            } else if self.check_identifier_keyword("CROSS") {
296                self.advance();
297                self.expect(TokenType::Join)?;
298                let (table, on_condition) = self.parse_join_target()?;
299                joins.push(Join {
300                    join_type: JoinType::Cross,
301                    table,
302                    on_condition,
303                });
304            } else {
305                break;
306            }
307        }
308        
309        Ok(FromClause { table, joins })
310    }
311    
312    /// Parse JOIN target (table and ON condition)
313    fn parse_join_target(&mut self) -> Result<(TableReference, Option<Expression>), ParseError> {
314        self.skip_whitespace();
315        
316        let table_name = if let TokenType::Identifier(name) = &self.peek().token_type {
317            let name = name.clone();
318            self.advance();
319            name
320        } else {
321            return Err(ParseError {
322                message: "Expected table name in JOIN".to_string(),
323                position: self.current,
324            });
325        };
326        
327        // Check for alias
328        self.skip_whitespace();
329        let alias = if self.check(&TokenType::As) {
330            self.advance();
331            self.skip_whitespace();
332            if let TokenType::Identifier(a) = &self.peek().token_type {
333                let a = a.clone();
334                self.advance();
335                Some(a)
336            } else {
337                None
338            }
339        } else {
340            None
341        };
342        
343        let table = TableReference {
344            name: table_name,
345            alias,
346        };
347        
348        // Parse ON condition
349        self.skip_whitespace();
350        let on_condition = if self.check(&TokenType::On) {
351            self.advance();
352            Some(self.parse_expression()?)
353        } else {
354            None
355        };
356        
357        Ok((table, on_condition))
358    }
359    
360    /// Parse ORDER BY clause
361    fn parse_order_by(&mut self) -> Result<Vec<OrderByItem>, ParseError> {
362        let mut items = Vec::new();
363        
364        loop {
365            self.skip_whitespace();
366            let expr = self.parse_expression()?;
367            
368            self.skip_whitespace();
369            let direction = if self.check(&TokenType::Asc) {
370                self.advance();
371                SortDirection::Asc
372            } else if self.check(&TokenType::Desc) {
373                self.advance();
374                SortDirection::Desc
375            } else {
376                SortDirection::Asc
377            };
378            
379            items.push(OrderByItem { expr, direction });
380            
381            self.skip_whitespace();
382            if !self.check(&TokenType::Comma) {
383                break;
384            }
385            self.advance();
386        }
387        
388        Ok(items)
389    }
390    
391    /// Parse LIMIT clause
392    fn parse_limit(&mut self) -> Result<LimitClause, ParseError> {
393        self.skip_whitespace();
394        
395        let limit = if let TokenType::Number(n) = &self.peek().token_type {
396            n.parse::<i64>().map_err(|_| ParseError {
397                message: "Invalid LIMIT value".to_string(),
398                position: self.current,
399            })?
400        } else {
401            return Err(ParseError {
402                message: "Expected number after LIMIT".to_string(),
403                position: self.current,
404            });
405        };
406        self.advance();
407        
408        // Check for OFFSET
409        self.skip_whitespace();
410        let offset = if self.check(&TokenType::Offset) {
411            self.advance();
412            self.skip_whitespace();
413            if let TokenType::Number(n) = &self.peek().token_type {
414                let offset = n.parse::<i64>().map_err(|_| ParseError {
415                    message: "Invalid OFFSET value".to_string(),
416                    position: self.current,
417                })?;
418                self.advance();
419                Some(offset)
420            } else {
421                return Err(ParseError {
422                    message: "Expected number after OFFSET".to_string(),
423                    position: self.current,
424                });
425            }
426        } else {
427            None
428        };
429        
430        Ok(LimitClause { limit, offset })
431    }
432    
433    /// Parse INSERT statement
434    fn parse_insert(&mut self) -> Result<Statement, ParseError> {
435        self.expect(TokenType::Insert)?;
436        self.skip_whitespace();
437        self.expect(TokenType::Into)?;
438        self.skip_whitespace();
439        
440        let table = if let TokenType::Identifier(name) = &self.peek().token_type {
441            let name = name.clone();
442            self.advance();
443            name
444        } else {
445            return Err(ParseError {
446                message: "Expected table name after INSERT INTO".to_string(),
447                position: self.current,
448            });
449        };
450        
451        // Parse column list (optional)
452        self.skip_whitespace();
453        let columns = if self.check(&TokenType::LeftParen) {
454            self.advance();
455            let cols = self.parse_identifier_list()?;
456            self.expect(TokenType::RightParen)?;
457            Some(cols)
458        } else {
459            None
460        };
461        
462        // Parse VALUES
463        self.skip_whitespace();
464        self.expect(TokenType::Values)?;
465        
466        let mut values = Vec::new();
467        loop {
468            self.skip_whitespace();
469            self.expect(TokenType::LeftParen)?;
470            let row = self.parse_expression_list()?;
471            self.expect(TokenType::RightParen)?;
472            values.push(row);
473            
474            self.skip_whitespace();
475            if !self.check(&TokenType::Comma) {
476                break;
477            }
478            self.advance();
479        }
480        
481        Ok(Statement::Insert(InsertStatement {
482            table,
483            columns,
484            values,
485        }))
486    }
487    
488    /// Parse UPDATE statement
489    fn parse_update(&mut self) -> Result<Statement, ParseError> {
490        self.expect(TokenType::Update)?;
491        self.skip_whitespace();
492        
493        let table = if let TokenType::Identifier(name) = &self.peek().token_type {
494            let name = name.clone();
495            self.advance();
496            name
497        } else {
498            return Err(ParseError {
499                message: "Expected table name after UPDATE".to_string(),
500                position: self.current,
501            });
502        };
503        
504        self.skip_whitespace();
505        self.expect(TokenType::Set)?;
506        self.skip_whitespace();
507        
508        let mut assignments = Vec::new();
509        loop {
510            self.skip_whitespace();
511            
512            let col = if let TokenType::Identifier(name) = &self.peek().token_type {
513                let name = name.clone();
514                self.advance();
515                name
516            } else {
517                return Err(ParseError {
518                    message: "Expected column name".to_string(),
519                    position: self.current,
520                });
521            };
522            
523            self.skip_whitespace();
524            self.expect(TokenType::Equal)?;
525            self.skip_whitespace();
526            let expr = self.parse_expression()?;
527            
528            assignments.push((col, expr));
529            
530            self.skip_whitespace();
531            if !self.check(&TokenType::Comma) {
532                break;
533            }
534            self.advance();
535        }
536        
537        // Parse WHERE clause
538        self.skip_whitespace();
539        let where_clause = if self.check(&TokenType::Where) {
540            self.advance();
541            Some(self.parse_expression()?)
542        } else {
543            None
544        };
545        
546        Ok(Statement::Update(UpdateStatement {
547            table,
548            assignments,
549            where_clause,
550        }))
551    }
552    
553    /// Parse DELETE statement
554    fn parse_delete(&mut self) -> Result<Statement, ParseError> {
555        self.expect(TokenType::Delete)?;
556        self.skip_whitespace();
557        self.expect(TokenType::From)?;
558        self.skip_whitespace();
559        
560        let table = if let TokenType::Identifier(name) = &self.peek().token_type {
561            let name = name.clone();
562            self.advance();
563            name
564        } else {
565            return Err(ParseError {
566                message: "Expected table name after DELETE FROM".to_string(),
567                position: self.current,
568            });
569        };
570        
571        self.skip_whitespace();
572        let where_clause = if self.check(&TokenType::Where) {
573            self.advance();
574            Some(self.parse_expression()?)
575        } else {
576            None
577        };
578        
579        Ok(Statement::Delete(DeleteStatement { table, where_clause }))
580    }
581    
582    /// Parse CREATE statement
583    fn parse_create(&mut self) -> Result<Statement, ParseError> {
584        self.expect(TokenType::Create)?;
585        self.expect(TokenType::Table)?;
586        self.skip_whitespace();
587        
588        let name = if let TokenType::Identifier(n) = &self.peek().token_type {
589            let n = n.clone();
590            self.advance();
591            n
592        } else {
593            return Err(ParseError {
594                message: "Expected table name after CREATE TABLE".to_string(),
595                position: self.current,
596            });
597        };
598        
599        self.expect(TokenType::LeftParen)?;
600        
601        let mut columns = Vec::new();
602        loop {
603            self.skip_whitespace();
604            
605            let col_name = if let TokenType::Identifier(n) = &self.peek().token_type {
606                let n = n.clone();
607                self.advance();
608                n
609            } else {
610                return Err(ParseError {
611                    message: "Expected column name".to_string(),
612                    position: self.current,
613                });
614            };
615            
616            self.skip_whitespace();
617            let data_type = if let TokenType::Identifier(dt) = &self.peek().token_type {
618                let dt = dt.clone();
619                self.advance();
620                dt
621            } else {
622                return Err(ParseError {
623                    message: "Expected data type".to_string(),
624                    position: self.current,
625                });
626            };
627            
628            // Parse constraints (simplified)
629            let mut constraints = Vec::new();
630            self.skip_whitespace();
631            loop {
632                match &self.peek().token_type {
633                    TokenType::Identifier(keyword)
634                        if keyword.eq_ignore_ascii_case("PRIMARY")
635                            || keyword.eq_ignore_ascii_case("UNIQUE") =>
636                    {
637                        constraints.push(keyword.clone());
638                        self.advance();
639                        self.skip_whitespace();
640                        if let TokenType::Identifier(kw2) = &self.peek().token_type {
641                            if kw2.eq_ignore_ascii_case("KEY") || kw2.eq_ignore_ascii_case("NULL") {
642                                constraints.push(kw2.clone());
643                                self.advance();
644                                self.skip_whitespace();
645                            }
646                        }
647                    }
648                    TokenType::Not => {
649                        constraints.push("NOT".to_string());
650                        self.advance();
651                        self.skip_whitespace();
652                        if let TokenType::Identifier(kw2) = &self.peek().token_type {
653                            if kw2.eq_ignore_ascii_case("NULL") {
654                                constraints.push(kw2.clone());
655                                self.advance();
656                                self.skip_whitespace();
657                            }
658                        }
659                    }
660                    _ => break,
661                }
662            }
663            
664            columns.push(ColumnDefinition {
665                name: col_name,
666                data_type,
667                constraints,
668            });
669            
670            self.skip_whitespace();
671            if !self.check(&TokenType::Comma) {
672                break;
673            }
674            self.advance();
675        }
676        
677        self.expect(TokenType::RightParen)?;
678        
679        Ok(Statement::Create(CreateStatement { name, columns }))
680    }
681    
682    /// Parse DROP statement
683    fn parse_drop(&mut self) -> Result<Statement, ParseError> {
684        self.expect(TokenType::Drop)?;
685        self.skip_whitespace();
686        
687        let object_type = if let TokenType::Identifier(t) = &self.peek().token_type {
688            let t = t.clone();
689            self.advance();
690            t
691        } else if self.check(&TokenType::Table) {
692            self.advance();
693            "TABLE".to_string()
694        } else {
695            return Err(ParseError {
696                message: "Expected object type after DROP".to_string(),
697                position: self.current,
698            });
699        };
700        
701        // Check for IF EXISTS
702        self.skip_whitespace();
703        let if_exists = if self.check(&TokenType::Identifier("IF".to_string())) 
704            || (self.current + 1 < self.tokens.len() 
705                && matches!(self.peek().token_type, TokenType::Identifier(ref s) if s.to_uppercase() == "IF"))
706        {
707            // Simplified check for IF EXISTS
708            false
709        } else {
710            false
711        };
712        
713        let name = if let TokenType::Identifier(n) = &self.peek().token_type {
714            let n = n.clone();
715            self.advance();
716            n
717        } else {
718            return Err(ParseError {
719                message: "Expected name after DROP".to_string(),
720                position: self.current,
721            });
722        };
723        
724        Ok(Statement::Drop(DropStatement {
725            object_type,
726            name,
727            if_exists,
728        }))
729    }
730    
731    /// Parse ALTER statement
732    fn parse_alter(&mut self) -> Result<Statement, ParseError> {
733        self.expect(TokenType::Alter)?;
734        self.expect(TokenType::Table)?;
735        self.skip_whitespace();
736        
737        let table = if let TokenType::Identifier(n) = &self.peek().token_type {
738            let n = n.clone();
739            self.advance();
740            n
741        } else {
742            return Err(ParseError {
743                message: "Expected table name after ALTER TABLE".to_string(),
744                position: self.current,
745            });
746        };
747        
748        // Parse action (ADD COLUMN, DROP COLUMN, etc.)
749        self.skip_whitespace();
750        let action = if self.check(&TokenType::Add) {
751            self.advance();
752            self.expect(TokenType::Column)?;
753            self.skip_whitespace();
754            
755            let col_name = if let TokenType::Identifier(n) = &self.peek().token_type {
756                let n = n.clone();
757                self.advance();
758                n
759            } else {
760                return Err(ParseError {
761                    message: "Expected column name".to_string(),
762                    position: self.current,
763                });
764            };
765            
766            self.skip_whitespace();
767            let data_type = if let TokenType::Identifier(dt) = &self.peek().token_type {
768                let dt = dt.clone();
769                self.advance();
770                dt
771            } else {
772                return Err(ParseError {
773                    message: "Expected data type".to_string(),
774                    position: self.current,
775                });
776            };
777            
778            AlterAction::Add(ColumnDefinition {
779                name: col_name,
780                data_type,
781                constraints: Vec::new(),
782            })
783        } else if self.check(&TokenType::Drop) {
784            self.advance();
785            self.expect(TokenType::Column)?;
786            self.skip_whitespace();
787            
788            let col_name = if let TokenType::Identifier(n) = &self.peek().token_type {
789                let n = n.clone();
790                self.advance();
791                n
792            } else {
793                return Err(ParseError {
794                    message: "Expected column name".to_string(),
795                    position: self.current,
796                });
797            };
798            
799            AlterAction::Drop(col_name)
800        } else if self.check_identifier_keyword("RENAME") {
801            self.advance();
802            self.skip_whitespace();
803
804            if self.check(&TokenType::Column) || self.check_identifier_keyword("COLUMN") {
805                self.advance();
806            }
807
808            self.skip_whitespace();
809            let old_name = if let TokenType::Identifier(n) = &self.peek().token_type {
810                let n = n.clone();
811                self.advance();
812                n
813            } else {
814                return Err(ParseError {
815                    message: "Expected old column name after RENAME COLUMN".to_string(),
816                    position: self.current,
817                });
818            };
819
820            self.skip_whitespace();
821            if self.check_identifier_keyword("TO") {
822                self.advance();
823            } else {
824                return Err(ParseError {
825                    message: "Expected TO in RENAME COLUMN clause".to_string(),
826                    position: self.current,
827                });
828            }
829
830            self.skip_whitespace();
831            let new_name = if let TokenType::Identifier(n) = &self.peek().token_type {
832                let n = n.clone();
833                self.advance();
834                n
835            } else {
836                return Err(ParseError {
837                    message: "Expected new column name after TO".to_string(),
838                    position: self.current,
839                });
840            };
841
842            AlterAction::Rename { old_name, new_name }
843        } else {
844            return Err(ParseError {
845                message: "Expected ALTER action (ADD, DROP, RENAME)".to_string(),
846                position: self.current,
847            });
848        };
849        
850        Ok(Statement::Alter(AlterStatement { table, action }))
851    }
852    
853    /// Parse expression with operators
854    fn parse_expression(&mut self) -> Result<Expression, ParseError> {
855        self.parse_or_expression()
856    }
857    
858    fn parse_or_expression(&mut self) -> Result<Expression, ParseError> {
859        let mut left = self.parse_and_expression()?;
860        
861        loop {
862            self.skip_whitespace();
863            if self.check(&TokenType::Or) {
864                self.advance();
865                let right = self.parse_and_expression()?;
866                left = Expression::BinaryOp {
867                    left: Box::new(left),
868                    op: BinaryOperator::Or,
869                    right: Box::new(right),
870                };
871            } else {
872                break;
873            }
874        }
875        
876        Ok(left)
877    }
878    
879    fn parse_and_expression(&mut self) -> Result<Expression, ParseError> {
880        let mut left = self.parse_comparison_expression()?;
881        
882        loop {
883            self.skip_whitespace();
884            if self.check(&TokenType::And) {
885                self.advance();
886                let right = self.parse_comparison_expression()?;
887                left = Expression::BinaryOp {
888                    left: Box::new(left),
889                    op: BinaryOperator::And,
890                    right: Box::new(right),
891                };
892            } else {
893                break;
894            }
895        }
896        
897        Ok(left)
898    }
899    
900    fn parse_comparison_expression(&mut self) -> Result<Expression, ParseError> {
901        let mut left = self.parse_additive_expression()?;
902        
903        loop {
904            self.skip_whitespace();
905            let op = if self.check(&TokenType::Equal) {
906                self.advance();
907                BinaryOperator::Equal
908            } else if self.check(&TokenType::NotEqual) {
909                self.advance();
910                BinaryOperator::NotEqual
911            } else if self.check(&TokenType::LessThan) {
912                self.advance();
913                BinaryOperator::LessThan
914            } else if self.check(&TokenType::LessThanOrEqual) {
915                self.advance();
916                BinaryOperator::LessThanOrEqual
917            } else if self.check(&TokenType::GreaterThan) {
918                self.advance();
919                BinaryOperator::GreaterThan
920            } else if self.check(&TokenType::GreaterThanOrEqual) {
921                self.advance();
922                BinaryOperator::GreaterThanOrEqual
923            } else if self.check(&TokenType::Like) {
924                self.advance();
925                BinaryOperator::Like
926            } else if self.check(&TokenType::In) {
927                self.advance();
928                BinaryOperator::In
929            } else if self.check(&TokenType::Between) {
930                self.advance();
931                BinaryOperator::Between
932            } else if self.check_identifier_keyword("IS") {
933                self.advance();
934                BinaryOperator::Is
935            } else {
936                break;
937            };
938            
939            let right = self.parse_additive_expression()?;
940            left = Expression::BinaryOp {
941                left: Box::new(left),
942                op,
943                right: Box::new(right),
944            };
945        }
946        
947        Ok(left)
948    }
949    
950    fn parse_additive_expression(&mut self) -> Result<Expression, ParseError> {
951        let mut left = self.parse_multiplicative_expression()?;
952        
953        loop {
954            self.skip_whitespace();
955            let op = if self.check(&TokenType::Plus) {
956                self.advance();
957                BinaryOperator::Plus
958            } else if self.check(&TokenType::Minus) {
959                self.advance();
960                BinaryOperator::Minus
961            } else {
962                break;
963            };
964            
965            let right = self.parse_multiplicative_expression()?;
966            left = Expression::BinaryOp {
967                left: Box::new(left),
968                op,
969                right: Box::new(right),
970            };
971        }
972        
973        Ok(left)
974    }
975    
976    fn parse_multiplicative_expression(&mut self) -> Result<Expression, ParseError> {
977        let mut left = self.parse_primary_expression()?;
978        
979        loop {
980            self.skip_whitespace();
981            let op = if self.check(&TokenType::Star) {
982                self.advance();
983                BinaryOperator::Multiply
984            } else if self.check(&TokenType::Slash) {
985                self.advance();
986                BinaryOperator::Divide
987            } else if self.check(&TokenType::Percent) {
988                self.advance();
989                BinaryOperator::Modulo
990            } else {
991                break;
992            };
993            
994            let right = self.parse_primary_expression()?;
995            left = Expression::BinaryOp {
996                left: Box::new(left),
997                op,
998                right: Box::new(right),
999            };
1000        }
1001        
1002        Ok(left)
1003    }
1004    
1005    fn parse_primary_expression(&mut self) -> Result<Expression, ParseError> {
1006        self.skip_whitespace();
1007        
1008        match &self.peek().token_type {
1009            TokenType::Number(n) => {
1010                let n = n.clone();
1011                self.advance();
1012                Ok(Expression::Number(n))
1013            }
1014            TokenType::String(s) => {
1015                let s = s.clone();
1016                self.advance();
1017                Ok(Expression::String(s))
1018            }
1019            TokenType::Star => {
1020                self.advance();
1021                Ok(Expression::Star)
1022            }
1023            TokenType::Identifier(id) => {
1024                let id = id.clone();
1025
1026                if id.eq_ignore_ascii_case("NULL") {
1027                    self.advance();
1028                    return Ok(Expression::Null);
1029                }
1030
1031                self.advance();
1032                
1033                // Check for function call or table.column
1034                self.skip_whitespace();
1035                if self.check(&TokenType::LeftParen) {
1036                    self.advance();
1037                    let args = if self.check(&TokenType::RightParen) {
1038                        Vec::new()
1039                    } else {
1040                        self.parse_expression_list()?
1041                    };
1042                    self.expect(TokenType::RightParen)?;
1043                    Ok(Expression::FunctionCall { name: id, args })
1044                } else if self.check(&TokenType::Dot) {
1045                    self.advance();
1046                    if let TokenType::Identifier(col) = &self.peek().token_type {
1047                        let col = col.clone();
1048                        self.advance();
1049                        Ok(Expression::Column {
1050                            table: Some(id),
1051                            name: col,
1052                        })
1053                    } else {
1054                        Err(ParseError {
1055                            message: "Expected column name after .".to_string(),
1056                            position: self.current,
1057                        })
1058                    }
1059                } else {
1060                    Ok(Expression::Column {
1061                        table: None,
1062                        name: id,
1063                    })
1064                }
1065            }
1066            TokenType::LeftParen => {
1067                self.advance();
1068                let expr = self.parse_expression()?;
1069                self.expect(TokenType::RightParen)?;
1070                Ok(Expression::Parenthesized(Box::new(expr)))
1071            }
1072            TokenType::Not => {
1073                self.advance();
1074                let expr = self.parse_primary_expression()?;
1075                Ok(Expression::UnaryOp {
1076                    op: UnaryOperator::Not,
1077                    expr: Box::new(expr),
1078                })
1079            }
1080            TokenType::Minus => {
1081                self.advance();
1082                let expr = self.parse_primary_expression()?;
1083                Ok(Expression::UnaryOp {
1084                    op: UnaryOperator::Minus,
1085                    expr: Box::new(expr),
1086                })
1087            }
1088            TokenType::Plus => {
1089                self.advance();
1090                let expr = self.parse_primary_expression()?;
1091                Ok(Expression::UnaryOp {
1092                    op: UnaryOperator::Plus,
1093                    expr: Box::new(expr),
1094                })
1095            }
1096            _ => Err(ParseError {
1097                message: format!("Unexpected token: {:?}", self.peek().token_type),
1098                position: self.current,
1099            }),
1100        }
1101    }
1102    
1103    /// Parse expression list (comma-separated expressions)
1104    fn parse_expression_list(&mut self) -> Result<Vec<Expression>, ParseError> {
1105        let mut exprs = Vec::new();
1106        
1107        loop {
1108            self.skip_whitespace();
1109            exprs.push(self.parse_expression()?);
1110            
1111            self.skip_whitespace();
1112            if !self.check(&TokenType::Comma) {
1113                break;
1114            }
1115            self.advance();
1116        }
1117        
1118        Ok(exprs)
1119    }
1120    
1121    /// Parse identifier list (comma-separated identifiers)
1122    fn parse_identifier_list(&mut self) -> Result<Vec<String>, ParseError> {
1123        let mut identifiers = Vec::new();
1124        
1125        loop {
1126            self.skip_whitespace();
1127            if let TokenType::Identifier(id) = &self.peek().token_type {
1128                identifiers.push(id.clone());
1129                self.advance();
1130            } else {
1131                return Err(ParseError {
1132                    message: "Expected identifier".to_string(),
1133                    position: self.current,
1134                });
1135            }
1136            
1137            self.skip_whitespace();
1138            if !self.check(&TokenType::Comma) {
1139                break;
1140            }
1141            self.advance();
1142        }
1143        
1144        Ok(identifiers)
1145    }
1146    
1147    // Helper methods
1148    
1149    fn peek(&self) -> LexicalToken {
1150        self.tokens.get(self.current).cloned().unwrap_or_else(|| LexicalToken {
1151            token_type: TokenType::Eof,
1152            value: String::new(),
1153            position: self.current,
1154        })
1155    }
1156    
1157    fn advance(&mut self) {
1158        self.current += 1;
1159    }
1160    
1161    fn check(&self, token_type: &TokenType) -> bool {
1162        let current = &self.peek().token_type;
1163        std::mem::discriminant(current) == std::mem::discriminant(token_type)
1164    }
1165
1166    fn check_identifier_keyword(&self, keyword: &str) -> bool {
1167        matches!(self.peek().token_type, TokenType::Identifier(ref value) if value.eq_ignore_ascii_case(keyword))
1168    }
1169
1170    fn is_alias_identifier_candidate(&self) -> bool {
1171        if let TokenType::Identifier(value) = &self.peek().token_type {
1172            !matches!(
1173                value.to_ascii_uppercase().as_str(),
1174                "JOIN"
1175                    | "INNER"
1176                    | "LEFT"
1177                    | "RIGHT"
1178                    | "FULL"
1179                    | "CROSS"
1180                    | "WHERE"
1181                    | "GROUP"
1182                    | "HAVING"
1183                    | "ORDER"
1184                    | "LIMIT"
1185                    | "OFFSET"
1186                    | "ON"
1187            )
1188        } else {
1189            false
1190        }
1191    }
1192    
1193    fn expect(&mut self, token_type: TokenType) -> Result<(), ParseError> {
1194        self.skip_whitespace();
1195        let current_token = self.peek();
1196        
1197        if std::mem::discriminant(&current_token.token_type) == std::mem::discriminant(&token_type) {
1198            self.advance();
1199            Ok(())
1200        } else {
1201            Err(ParseError {
1202                message: format!("Expected {:?}, got {:?}", token_type, current_token.token_type),
1203                position: self.current,
1204            })
1205        }
1206    }
1207    
1208    fn skip_whitespace(&mut self) {
1209        while self.current < self.tokens.len() {
1210            let token = &self.tokens[self.current];
1211            if token.token_type == TokenType::Whitespace 
1212                || (token.token_type == TokenType::Unknown && token.value.trim().is_empty()) {
1213                self.current += 1;
1214            } else {
1215                break;
1216            }
1217        }
1218    }
1219}
rook_parser/parser.rs

rook_parser/
parser.rs
