sochdb_query/sql/
parser.rs

1// Copyright 2025 Sushanth (https://github.com/sushanthpy)
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15//! SQL Parser
16//!
17//! Recursive descent parser for SQL grammar.
18//! Produces AST from token stream.
19
20use super::ast::*;
21use super::lexer::Lexer;
22use super::token::{Span, Token, TokenKind};
23
24/// Parser errors
25#[derive(Debug, Clone)]
26pub struct ParseError {
27    pub message: String,
28    pub span: Span,
29    pub expected: Vec<String>,
30}
31
32impl ParseError {
33    pub fn new(message: impl Into<String>, span: Span) -> Self {
34        Self {
35            message: message.into(),
36            span,
37            expected: Vec::new(),
38        }
39    }
40
41    pub fn expected(mut self, expected: impl Into<String>) -> Self {
42        self.expected.push(expected.into());
43        self
44    }
45}
46
47impl std::fmt::Display for ParseError {
48    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
49        write!(
50            f,
51            "Parse error at line {}, column {}: {}",
52            self.span.line, self.span.column, self.message
53        )?;
54        if !self.expected.is_empty() {
55            write!(f, " (expected: {})", self.expected.join(", "))?;
56        }
57        Ok(())
58    }
59}
60
61impl std::error::Error for ParseError {}
62
63/// SQL Parser
64pub struct Parser {
65    tokens: Vec<Token>,
66    pos: usize,
67}
68
69impl Parser {
70    /// Create a new parser from tokens
71    pub fn new(tokens: Vec<Token>) -> Self {
72        Self { tokens, pos: 0 }
73    }
74
75    /// Parse a SQL string into a statement
76    pub fn parse(sql: &str) -> Result<Statement, Vec<ParseError>> {
77        let tokens = Lexer::new(sql).tokenize().map_err(|lex_errors| {
78            lex_errors
79                .into_iter()
80                .map(|e| ParseError::new(e.message, e.span))
81                .collect::<Vec<_>>()
82        })?;
83
84        let mut parser = Parser::new(tokens);
85        parser.parse_statement()
86    }
87
88    /// Parse multiple statements (semicolon-separated)
89    pub fn parse_statements(sql: &str) -> Result<Vec<Statement>, Vec<ParseError>> {
90        let tokens = Lexer::new(sql).tokenize().map_err(|lex_errors| {
91            lex_errors
92                .into_iter()
93                .map(|e| ParseError::new(e.message, e.span))
94                .collect::<Vec<_>>()
95        })?;
96
97        let mut parser = Parser::new(tokens);
98        let mut statements = Vec::new();
99
100        while !parser.is_at_end() {
101            match parser.parse_statement() {
102                Ok(stmt) => {
103                    statements.push(stmt);
104                    // Consume optional semicolon
105                    parser.match_token(&TokenKind::Semicolon);
106                }
107                Err(errors) => return Err(errors),
108            }
109        }
110
111        Ok(statements)
112    }
113
114    // ========== Helper Methods ==========
115
116    fn is_at_end(&self) -> bool {
117        matches!(self.peek().kind, TokenKind::Eof)
118    }
119
120    fn peek(&self) -> &Token {
121        self.tokens
122            .get(self.pos)
123            .unwrap_or(&self.tokens[self.tokens.len() - 1])
124    }
125
126    fn peek_nth(&self, n: usize) -> &Token {
127        self.tokens
128            .get(self.pos + n)
129            .unwrap_or(&self.tokens[self.tokens.len() - 1])
130    }
131
132    fn advance(&mut self) -> Token {
133        if !self.is_at_end() {
134            self.pos += 1;
135        }
136        self.tokens.get(self.pos - 1).cloned().unwrap()
137    }
138
139    fn check(&self, kind: &TokenKind) -> bool {
140        std::mem::discriminant(&self.peek().kind) == std::mem::discriminant(kind)
141    }
142
143    fn check_keyword(&self, kw: &TokenKind) -> bool {
144        self.peek().kind == *kw
145    }
146
147    fn match_token(&mut self, kind: &TokenKind) -> bool {
148        if self.check(kind) {
149            self.advance();
150            true
151        } else {
152            false
153        }
154    }
155
156    fn expect(&mut self, kind: &TokenKind, message: &str) -> Result<Token, ParseError> {
157        if self.check(kind) {
158            Ok(self.advance())
159        } else {
160            Err(ParseError::new(message, self.peek().span).expected(format!("{:?}", kind)))
161        }
162    }
163
164    fn expect_identifier(&mut self, message: &str) -> Result<String, ParseError> {
165        match &self.peek().kind {
166            TokenKind::Identifier(name) => {
167                let name = name.clone();
168                self.advance();
169                Ok(name)
170            }
171            TokenKind::QuotedIdentifier(name) => {
172                let name = name.clone();
173                self.advance();
174                Ok(name)
175            }
176            _ => Err(ParseError::new(message, self.peek().span).expected("identifier")),
177        }
178    }
179
180    fn current_span(&self) -> Span {
181        self.peek().span
182    }
183
184    // ========== Statement Parsing ==========
185
186    fn parse_statement(&mut self) -> Result<Statement, Vec<ParseError>> {
187        let result = match &self.peek().kind {
188            TokenKind::Select => self.parse_select().map(Statement::Select),
189            TokenKind::Insert => self.parse_insert().map(Statement::Insert),
190            TokenKind::Update => self.parse_update().map(Statement::Update),
191            TokenKind::Delete => self.parse_delete().map(Statement::Delete),
192            TokenKind::Create => self.parse_create(),
193            TokenKind::Drop => self.parse_drop(),
194            TokenKind::Alter => self.parse_alter(),
195            TokenKind::Begin => self.parse_begin().map(Statement::Begin),
196            TokenKind::Commit => {
197                self.advance();
198                Ok(Statement::Commit)
199            }
200            TokenKind::Rollback => self.parse_rollback(),
201            TokenKind::Savepoint => self.parse_savepoint(),
202            TokenKind::Release => self.parse_release(),
203            _ => Err(ParseError::new(
204                format!("Unexpected token: {:?}", self.peek().kind),
205                self.peek().span,
206            )),
207        };
208
209        result.map_err(|e| vec![e])
210    }
211
212    // ========== SELECT Parsing ==========
213
214    fn parse_select(&mut self) -> Result<SelectStmt, ParseError> {
215        let start_span = self.current_span();
216        self.expect(&TokenKind::Select, "Expected SELECT")?;
217
218        // DISTINCT?
219        let distinct = self.match_token(&TokenKind::Distinct);
220        if !distinct {
221            self.match_token(&TokenKind::All);
222        }
223
224        // Select list
225        let columns = self.parse_select_list()?;
226
227        // FROM clause (optional for SELECT 1+1 style queries)
228        let from = if self.match_token(&TokenKind::From) {
229            Some(self.parse_from_clause()?)
230        } else {
231            None
232        };
233
234        // WHERE clause
235        let where_clause = if self.match_token(&TokenKind::Where) {
236            Some(self.parse_expr()?)
237        } else {
238            None
239        };
240
241        // GROUP BY clause
242        let group_by = if self.check_keyword(&TokenKind::Group) {
243            self.advance();
244            self.expect(&TokenKind::By, "Expected BY after GROUP")?;
245            self.parse_expr_list()?
246        } else {
247            Vec::new()
248        };
249
250        // HAVING clause
251        let having = if self.match_token(&TokenKind::Having) {
252            Some(self.parse_expr()?)
253        } else {
254            None
255        };
256
257        // ORDER BY clause
258        let order_by = if self.check_keyword(&TokenKind::Order) {
259            self.advance();
260            self.expect(&TokenKind::By, "Expected BY after ORDER")?;
261            self.parse_order_by_list()?
262        } else {
263            Vec::new()
264        };
265
266        // LIMIT clause
267        let limit = if self.match_token(&TokenKind::Limit) {
268            Some(self.parse_expr()?)
269        } else {
270            None
271        };
272
273        // OFFSET clause
274        let offset = if self.match_token(&TokenKind::Offset) {
275            Some(self.parse_expr()?)
276        } else {
277            None
278        };
279
280        // Set operations (UNION, INTERSECT, EXCEPT)
281        let mut unions = Vec::new();
282        loop {
283            let set_op = if self.match_token(&TokenKind::Union) {
284                if self.match_token(&TokenKind::All) {
285                    SetOp::UnionAll
286                } else {
287                    SetOp::Union
288                }
289            } else if self.match_token(&TokenKind::Intersect) {
290                if self.match_token(&TokenKind::All) {
291                    SetOp::IntersectAll
292                } else {
293                    SetOp::Intersect
294                }
295            } else if self.match_token(&TokenKind::Except) {
296                if self.match_token(&TokenKind::All) {
297                    SetOp::ExceptAll
298                } else {
299                    SetOp::Except
300                }
301            } else {
302                break;
303            };
304
305            let right = self.parse_select()?;
306            unions.push((set_op, Box::new(right)));
307        }
308
309        Ok(SelectStmt {
310            span: start_span.merge(self.current_span()),
311            distinct,
312            columns,
313            from,
314            where_clause,
315            group_by,
316            having,
317            order_by,
318            limit,
319            offset,
320            unions,
321        })
322    }
323
324    fn parse_select_list(&mut self) -> Result<Vec<SelectItem>, ParseError> {
325        let mut items = Vec::new();
326
327        loop {
328            items.push(self.parse_select_item()?);
329
330            if !self.match_token(&TokenKind::Comma) {
331                break;
332            }
333        }
334
335        Ok(items)
336    }
337
338    fn parse_select_item(&mut self) -> Result<SelectItem, ParseError> {
339        // Check for *
340        if self.match_token(&TokenKind::Star) {
341            return Ok(SelectItem::Wildcard);
342        }
343
344        // Check for table.*
345        if let TokenKind::Identifier(name) = &self.peek().kind
346            && self.peek_nth(1).kind == TokenKind::Dot
347            && self.peek_nth(2).kind == TokenKind::Star
348        {
349            let table = name.clone();
350            self.advance(); // identifier
351            self.advance(); // .
352            self.advance(); // *
353            return Ok(SelectItem::QualifiedWildcard(table));
354        }
355
356        // Expression with optional alias
357        let expr = self.parse_expr()?;
358
359        let alias = if self.match_token(&TokenKind::As) {
360            Some(self.expect_identifier("Expected alias after AS")?)
361        } else if let TokenKind::Identifier(name) = &self.peek().kind {
362            // Implicit alias (without AS)
363            if !self.check_keyword(&TokenKind::From)
364                && !self.check_keyword(&TokenKind::Where)
365                && !self.check(&TokenKind::Comma)
366                && !self.check_keyword(&TokenKind::Order)
367                && !self.check_keyword(&TokenKind::Group)
368                && !self.check_keyword(&TokenKind::Limit)
369                && !self.is_at_end()
370            {
371                let name = name.clone();
372                self.advance();
373                Some(name)
374            } else {
375                None
376            }
377        } else {
378            None
379        };
380
381        Ok(SelectItem::Expr { expr, alias })
382    }
383
384    fn parse_from_clause(&mut self) -> Result<FromClause, ParseError> {
385        let mut tables = vec![self.parse_table_ref()?];
386
387        while self.match_token(&TokenKind::Comma) {
388            tables.push(self.parse_table_ref()?);
389        }
390
391        Ok(FromClause { tables })
392    }
393
394    fn parse_table_ref(&mut self) -> Result<TableRef, ParseError> {
395        let mut table = self.parse_table_primary()?;
396
397        // Parse joins
398        loop {
399            let join_type = if self.match_token(&TokenKind::Cross) {
400                self.expect(&TokenKind::Join, "Expected JOIN after CROSS")?;
401                JoinType::Cross
402            } else if self.match_token(&TokenKind::Inner) {
403                self.expect(&TokenKind::Join, "Expected JOIN after INNER")?;
404                JoinType::Inner
405            } else if self.match_token(&TokenKind::Left) {
406                self.match_token(&TokenKind::Outer);
407                self.expect(&TokenKind::Join, "Expected JOIN after LEFT")?;
408                JoinType::Left
409            } else if self.match_token(&TokenKind::Right) {
410                self.match_token(&TokenKind::Outer);
411                self.expect(&TokenKind::Join, "Expected JOIN after RIGHT")?;
412                JoinType::Right
413            } else if self.match_token(&TokenKind::Join) {
414                JoinType::Inner // Default join is INNER
415            } else {
416                break;
417            };
418
419            let right = self.parse_table_primary()?;
420
421            let condition = if join_type == JoinType::Cross {
422                None
423            } else if self.match_token(&TokenKind::On) {
424                Some(JoinCondition::On(self.parse_expr()?))
425            } else if self.match_token(&TokenKind::Using) {
426                self.expect(&TokenKind::LParen, "Expected '(' after USING")?;
427                let columns = self.parse_identifier_list()?;
428                self.expect(&TokenKind::RParen, "Expected ')' after USING columns")?;
429                Some(JoinCondition::Using(columns))
430            } else {
431                return Err(ParseError::new(
432                    "Expected ON or USING clause for JOIN",
433                    self.current_span(),
434                ));
435            };
436
437            table = TableRef::Join {
438                left: Box::new(table),
439                join_type,
440                right: Box::new(right),
441                condition,
442            };
443        }
444
445        Ok(table)
446    }
447
448    fn parse_table_primary(&mut self) -> Result<TableRef, ParseError> {
449        // Subquery: (SELECT ...)
450        if self.match_token(&TokenKind::LParen) {
451            let query = self.parse_select()?;
452            self.expect(&TokenKind::RParen, "Expected ')' after subquery")?;
453
454            self.match_token(&TokenKind::As);
455            let alias = self.expect_identifier("Subquery requires an alias")?;
456
457            return Ok(TableRef::Subquery {
458                query: Box::new(query),
459                alias,
460            });
461        }
462
463        // Table name
464        let name = self.parse_object_name()?;
465
466        // Optional alias
467        let alias = if self.match_token(&TokenKind::As) {
468            Some(self.expect_identifier("Expected alias after AS")?)
469        } else if let TokenKind::Identifier(id) = &self.peek().kind {
470            // Check it's not a keyword
471            if !self.peek().kind.is_keyword() {
472                let alias = id.clone();
473                self.advance();
474                Some(alias)
475            } else {
476                None
477            }
478        } else {
479            None
480        };
481
482        Ok(TableRef::Table { name, alias })
483    }
484
485    // ========== INSERT Parsing ==========
486
487    fn parse_insert(&mut self) -> Result<InsertStmt, ParseError> {
488        let start_span = self.current_span();
489        self.expect(&TokenKind::Insert, "Expected INSERT")?;
490
491        // Check for MySQL-style INSERT IGNORE
492        let mysql_ignore = self.match_token(&TokenKind::Ignore);
493
494        // Check for SQLite-style INSERT OR {IGNORE|REPLACE|ABORT|FAIL}
495        let sqlite_conflict_action = if self.match_token(&TokenKind::Or) {
496            if self.match_token(&TokenKind::Ignore) {
497                Some(ConflictAction::DoNothing)
498            } else if self.match_token(&TokenKind::Replace) {
499                Some(ConflictAction::DoReplace)
500            } else if self.match_token(&TokenKind::Abort) {
501                Some(ConflictAction::DoAbort)
502            } else if self.match_token(&TokenKind::Fail) {
503                Some(ConflictAction::DoFail)
504            } else {
505                return Err(ParseError::new(
506                    "Expected IGNORE, REPLACE, ABORT, or FAIL after OR",
507                    self.current_span(),
508                ));
509            }
510        } else {
511            None
512        };
513
514        self.expect(&TokenKind::Into, "Expected INTO")?;
515
516        let table = self.parse_object_name()?;
517
518        // Optional column list
519        let columns = if self.match_token(&TokenKind::LParen) {
520            let cols = self.parse_identifier_list()?;
521            self.expect(&TokenKind::RParen, "Expected ')' after column list")?;
522            Some(cols)
523        } else {
524            None
525        };
526
527        // VALUES or SELECT
528        let source = if self.match_token(&TokenKind::Values) {
529            InsertSource::Values(self.parse_values_list()?)
530        } else if self.check_keyword(&TokenKind::Select) {
531            InsertSource::Query(Box::new(self.parse_select()?))
532        } else if self.match_token(&TokenKind::Default) {
533            self.expect(&TokenKind::Values, "Expected VALUES after DEFAULT")?;
534            InsertSource::Default
535        } else {
536            return Err(ParseError::new(
537                "Expected VALUES or SELECT",
538                self.current_span(),
539            ));
540        };
541
542        // Parse ON CONFLICT (PostgreSQL) or ON DUPLICATE KEY UPDATE (MySQL)
543        let on_conflict = if self.match_token(&TokenKind::On) {
544            if self.match_token(&TokenKind::Conflict) {
545                // PostgreSQL: ON CONFLICT [target] DO {NOTHING | UPDATE SET ...}
546                Some(self.parse_on_conflict()?)
547            } else if self.match_token(&TokenKind::Duplicate) {
548                // MySQL: ON DUPLICATE KEY UPDATE ...
549                self.expect(&TokenKind::Key, "Expected KEY after DUPLICATE")?;
550                self.expect(&TokenKind::Update, "Expected UPDATE after KEY")?;
551                let assignments = self.parse_assignments()?;
552                Some(OnConflict {
553                    target: None,
554                    action: ConflictAction::DoUpdate(assignments),
555                })
556            } else {
557                return Err(ParseError::new(
558                    "Expected CONFLICT or DUPLICATE after ON",
559                    self.current_span(),
560                ));
561            }
562        } else if mysql_ignore {
563            // MySQL INSERT IGNORE normalizes to DoNothing
564            Some(OnConflict {
565                target: None,
566                action: ConflictAction::DoNothing,
567            })
568        } else {
569            // SQLite conflict action from OR clause
570            sqlite_conflict_action.map(|action| OnConflict {
571                target: None,
572                action,
573            })
574        };
575
576        // RETURNING clause (PostgreSQL/SQLite)
577        let returning = if self.match_token(&TokenKind::Returning) {
578            Some(self.parse_select_list()?)
579        } else {
580            None
581        };
582
583        Ok(InsertStmt {
584            span: start_span.merge(self.current_span()),
585            table,
586            columns,
587            source,
588            on_conflict,
589            returning,
590        })
591    }
592
593    /// Parse ON CONFLICT clause (PostgreSQL style)
594    fn parse_on_conflict(&mut self) -> Result<OnConflict, ParseError> {
595        // Optional conflict target: (columns) or ON CONSTRAINT name
596        let target = if self.match_token(&TokenKind::LParen) {
597            let cols = self.parse_identifier_list()?;
598            self.expect(&TokenKind::RParen, "Expected ')' after conflict columns")?;
599            Some(ConflictTarget::Columns(cols))
600        } else if self.match_token(&TokenKind::On) {
601            // ON CONSTRAINT name (though this is a bit unusual syntax)
602            // Actually PostgreSQL uses just ON CONFLICT ON CONSTRAINT name
603            // Let's handle the standard case
604            None
605        } else {
606            None
607        };
608
609        // DO {NOTHING | UPDATE SET ...}
610        self.expect(&TokenKind::Do, "Expected DO after ON CONFLICT")?;
611
612        let action = if self.match_token(&TokenKind::Nothing) {
613            ConflictAction::DoNothing
614        } else if self.match_token(&TokenKind::Update) {
615            self.expect(&TokenKind::Set, "Expected SET after UPDATE")?;
616            let assignments = self.parse_assignments()?;
617            ConflictAction::DoUpdate(assignments)
618        } else {
619            return Err(ParseError::new(
620                "Expected NOTHING or UPDATE after DO",
621                self.current_span(),
622            ));
623        };
624
625        Ok(OnConflict { target, action })
626    }
627
628    fn parse_values_list(&mut self) -> Result<Vec<Vec<Expr>>, ParseError> {
629        let mut rows = Vec::new();
630
631        loop {
632            self.expect(&TokenKind::LParen, "Expected '(' for VALUES row")?;
633            let row = self.parse_expr_list()?;
634            self.expect(&TokenKind::RParen, "Expected ')' after VALUES row")?;
635            rows.push(row);
636
637            if !self.match_token(&TokenKind::Comma) {
638                break;
639            }
640        }
641
642        Ok(rows)
643    }
644
645    // ========== UPDATE Parsing ==========
646
647    fn parse_update(&mut self) -> Result<UpdateStmt, ParseError> {
648        let start_span = self.current_span();
649        self.expect(&TokenKind::Update, "Expected UPDATE")?;
650
651        let table = self.parse_object_name()?;
652
653        let alias = if self.match_token(&TokenKind::As) {
654            Some(self.expect_identifier("Expected alias after AS")?)
655        } else {
656            None
657        };
658
659        self.expect(&TokenKind::Set, "Expected SET")?;
660
661        let assignments = self.parse_assignments()?;
662
663        let from = if self.match_token(&TokenKind::From) {
664            Some(self.parse_from_clause()?)
665        } else {
666            None
667        };
668
669        let where_clause = if self.match_token(&TokenKind::Where) {
670            Some(self.parse_expr()?)
671        } else {
672            None
673        };
674
675        let returning = None; // TODO
676
677        Ok(UpdateStmt {
678            span: start_span.merge(self.current_span()),
679            table,
680            alias,
681            assignments,
682            from,
683            where_clause,
684            returning,
685        })
686    }
687
688    fn parse_assignments(&mut self) -> Result<Vec<Assignment>, ParseError> {
689        let mut assignments = Vec::new();
690
691        loop {
692            let column = self.expect_identifier("Expected column name")?;
693            self.expect(&TokenKind::Eq, "Expected '=' after column name")?;
694            let value = self.parse_expr()?;
695
696            assignments.push(Assignment { column, value });
697
698            if !self.match_token(&TokenKind::Comma) {
699                break;
700            }
701        }
702
703        Ok(assignments)
704    }
705
706    // ========== DELETE Parsing ==========
707
708    fn parse_delete(&mut self) -> Result<DeleteStmt, ParseError> {
709        let start_span = self.current_span();
710        self.expect(&TokenKind::Delete, "Expected DELETE")?;
711        self.expect(&TokenKind::From, "Expected FROM")?;
712
713        let table = self.parse_object_name()?;
714
715        let alias = if self.match_token(&TokenKind::As) {
716            Some(self.expect_identifier("Expected alias after AS")?)
717        } else {
718            None
719        };
720
721        let using = None; // TODO: Parse USING clause
722
723        let where_clause = if self.match_token(&TokenKind::Where) {
724            Some(self.parse_expr()?)
725        } else {
726            None
727        };
728
729        Ok(DeleteStmt {
730            span: start_span.merge(self.current_span()),
731            table,
732            alias,
733            using,
734            where_clause,
735            returning: None,
736        })
737    }
738
739    // ========== DDL Parsing ==========
740
741    fn parse_create(&mut self) -> Result<Statement, ParseError> {
742        self.expect(&TokenKind::Create, "Expected CREATE")?;
743
744        // Check for CREATE UNIQUE INDEX
745        let unique = self.match_token(&TokenKind::Unique);
746
747        if self.match_token(&TokenKind::Table) {
748            self.parse_create_table().map(Statement::CreateTable)
749        } else if self.match_token(&TokenKind::Index) {
750            self.parse_create_index(unique).map(Statement::CreateIndex)
751        } else if unique {
752            // After UNIQUE, must be INDEX
753            Err(ParseError::new(
754                "Expected INDEX after UNIQUE",
755                self.current_span(),
756            ))
757        } else {
758            Err(ParseError::new(
759                "Expected TABLE or INDEX after CREATE",
760                self.current_span(),
761            ))
762        }
763    }
764
765    fn parse_create_index(&mut self, unique: bool) -> Result<CreateIndexStmt, ParseError> {
766        let start_span = self.current_span();
767
768        // IF NOT EXISTS
769        let if_not_exists = if self.match_token(&TokenKind::If) {
770            self.expect(&TokenKind::Not, "Expected NOT after IF")?;
771            self.expect(&TokenKind::Exists, "Expected EXISTS after IF NOT")?;
772            true
773        } else {
774            false
775        };
776
777        // Index name
778        let name = self.expect_identifier("Expected index name")?;
779
780        self.expect(&TokenKind::On, "Expected ON after index name")?;
781
782        // Table name
783        let table = self.parse_object_name()?;
784
785        // Column list
786        self.expect(&TokenKind::LParen, "Expected '(' after table name")?;
787        let mut columns = Vec::new();
788        loop {
789            let col_name = self.expect_identifier("Expected column name")?;
790            
791            // Optional ASC/DESC
792            let asc = if self.match_token(&TokenKind::Desc) {
793                false
794            } else {
795                self.match_token(&TokenKind::Asc);
796                true
797            };
798
799            columns.push(IndexColumn {
800                name: col_name,
801                asc,
802                nulls_first: None,
803            });
804
805            if !self.match_token(&TokenKind::Comma) {
806                break;
807            }
808        }
809        self.expect(&TokenKind::RParen, "Expected ')' after column list")?;
810
811        // Optional WHERE clause for partial indexes
812        let where_clause = if self.match_token(&TokenKind::Where) {
813            Some(self.parse_expr()?)
814        } else {
815            None
816        };
817
818        Ok(CreateIndexStmt {
819            span: start_span.merge(self.current_span()),
820            unique,
821            if_not_exists,
822            name,
823            table,
824            columns,
825            where_clause,
826            index_type: None,
827        })
828    }
829
830    fn parse_create_table(&mut self) -> Result<CreateTableStmt, ParseError> {
831        let start_span = self.current_span();
832
833        let if_not_exists = if self.match_token(&TokenKind::If) {
834            self.expect(&TokenKind::Not, "Expected NOT after IF")?;
835            self.expect(&TokenKind::Exists, "Expected EXISTS after IF NOT")?;
836            true
837        } else {
838            false
839        };
840
841        let name = self.parse_object_name()?;
842
843        self.expect(&TokenKind::LParen, "Expected '(' after table name")?;
844
845        let mut columns = Vec::new();
846        let constraints = Vec::new();
847
848        loop {
849            // Check for table constraint keywords
850            if self.check_keyword(&TokenKind::Primary)
851                || self.check_keyword(&TokenKind::Foreign)
852                || self.check_keyword(&TokenKind::Unique)
853            {
854                // TODO: Parse table constraints
855                break;
856            }
857
858            // Check for end of column list
859            if self.check(&TokenKind::RParen) {
860                break;
861            }
862
863            // Parse column definition
864            columns.push(self.parse_column_def()?);
865
866            if !self.match_token(&TokenKind::Comma) {
867                break;
868            }
869        }
870
871        self.expect(&TokenKind::RParen, "Expected ')' after column definitions")?;
872
873        Ok(CreateTableStmt {
874            span: start_span.merge(self.current_span()),
875            if_not_exists,
876            name,
877            columns,
878            constraints,
879            options: Vec::new(),
880        })
881    }
882
883    fn parse_column_def(&mut self) -> Result<ColumnDef, ParseError> {
884        let name = self.expect_identifier("Expected column name")?;
885        let data_type = self.parse_data_type()?;
886
887        let mut constraints = Vec::new();
888
889        // Parse column constraints
890        loop {
891            if self.match_token(&TokenKind::Primary) {
892                self.expect(&TokenKind::Key, "Expected KEY after PRIMARY")?;
893                constraints.push(ColumnConstraint::PrimaryKey);
894            } else if self.match_token(&TokenKind::Not) {
895                self.expect(&TokenKind::Null, "Expected NULL after NOT")?;
896                constraints.push(ColumnConstraint::NotNull);
897            } else if self.match_token(&TokenKind::Null) {
898                constraints.push(ColumnConstraint::Null);
899            } else if self.match_token(&TokenKind::Unique) {
900                constraints.push(ColumnConstraint::Unique);
901            } else if self.match_token(&TokenKind::Default) {
902                constraints.push(ColumnConstraint::Default(self.parse_expr()?));
903            } else if self.match_token(&TokenKind::AutoIncrement) {
904                constraints.push(ColumnConstraint::AutoIncrement);
905            } else {
906                break;
907            }
908        }
909
910        Ok(ColumnDef {
911            name,
912            data_type,
913            constraints,
914        })
915    }
916
917    fn parse_data_type(&mut self) -> Result<DataType, ParseError> {
918        let type_name = match &self.peek().kind {
919            TokenKind::Int | TokenKind::IntegerKw => {
920                self.advance();
921                DataType::Int
922            }
923            TokenKind::Bigint => {
924                self.advance();
925                DataType::BigInt
926            }
927            TokenKind::Smallint => {
928                self.advance();
929                DataType::SmallInt
930            }
931            TokenKind::Tinyint => {
932                self.advance();
933                DataType::TinyInt
934            }
935            TokenKind::FloatKw | TokenKind::Real => {
936                self.advance();
937                DataType::Float
938            }
939            TokenKind::Double => {
940                self.advance();
941                DataType::Double
942            }
943            TokenKind::Varchar => {
944                self.advance();
945                let len = self.parse_type_length()?;
946                DataType::Varchar(len)
947            }
948            TokenKind::Char => {
949                self.advance();
950                let len = self.parse_type_length()?;
951                DataType::Char(len)
952            }
953            TokenKind::Text => {
954                self.advance();
955                DataType::Text
956            }
957            TokenKind::BlobKw => {
958                self.advance();
959                DataType::Blob
960            }
961            TokenKind::Boolean | TokenKind::Bool => {
962                self.advance();
963                DataType::Boolean
964            }
965            TokenKind::Date => {
966                self.advance();
967                DataType::Date
968            }
969            TokenKind::Time => {
970                self.advance();
971                DataType::Time
972            }
973            TokenKind::Timestamp | TokenKind::Datetime => {
974                self.advance();
975                DataType::Timestamp
976            }
977            TokenKind::Vector => {
978                self.advance();
979                let dims = self.parse_type_length()?.unwrap_or(128);
980                DataType::Vector(dims)
981            }
982            TokenKind::Embedding => {
983                self.advance();
984                let dims = self.parse_type_length()?.unwrap_or(1536);
985                DataType::Embedding(dims)
986            }
987            TokenKind::Identifier(name) => {
988                let name = name.clone();
989                self.advance();
990                DataType::Custom(name)
991            }
992            _ => {
993                return Err(ParseError::new(
994                    format!("Expected data type, got {:?}", self.peek().kind),
995                    self.current_span(),
996                ));
997            }
998        };
999
1000        Ok(type_name)
1001    }
1002
1003    fn parse_type_length(&mut self) -> Result<Option<u32>, ParseError> {
1004        if self.match_token(&TokenKind::LParen) {
1005            let len = match &self.peek().kind {
1006                TokenKind::Integer(n) => {
1007                    let n = *n as u32;
1008                    self.advance();
1009                    n
1010                }
1011                _ => return Err(ParseError::new("Expected integer", self.current_span())),
1012            };
1013            self.expect(&TokenKind::RParen, "Expected ')'")?;
1014            Ok(Some(len))
1015        } else {
1016            Ok(None)
1017        }
1018    }
1019
1020    fn parse_drop(&mut self) -> Result<Statement, ParseError> {
1021        let start_span = self.current_span();
1022        self.expect(&TokenKind::Drop, "Expected DROP")?;
1023
1024        if self.match_token(&TokenKind::Table) {
1025            let if_exists = if self.match_token(&TokenKind::If) {
1026                self.expect(&TokenKind::Exists, "Expected EXISTS after IF")?;
1027                true
1028            } else {
1029                false
1030            };
1031
1032            let name = self.parse_object_name()?;
1033            let cascade = false; // TODO: Parse CASCADE
1034
1035            Ok(Statement::DropTable(DropTableStmt {
1036                span: start_span.merge(self.current_span()),
1037                if_exists,
1038                names: vec![name],
1039                cascade,
1040            }))
1041        } else if self.match_token(&TokenKind::Index) {
1042            let if_exists = if self.match_token(&TokenKind::If) {
1043                self.expect(&TokenKind::Exists, "Expected EXISTS after IF")?;
1044                true
1045            } else {
1046                false
1047            };
1048
1049            let name = self.expect_identifier("Expected index name")?;
1050
1051            // Optional ON table_name (PostgreSQL style)
1052            let table = if self.match_token(&TokenKind::On) {
1053                Some(self.parse_object_name()?)
1054            } else {
1055                None
1056            };
1057
1058            Ok(Statement::DropIndex(DropIndexStmt {
1059                span: start_span.merge(self.current_span()),
1060                if_exists,
1061                name,
1062                table,
1063                cascade: false,
1064            }))
1065        } else {
1066            Err(ParseError::new(
1067                "Expected TABLE or INDEX after DROP",
1068                self.current_span(),
1069            ))
1070        }
1071    }
1072
1073    fn parse_alter(&mut self) -> Result<Statement, ParseError> {
1074        // TODO: Implement ALTER TABLE
1075        Err(ParseError::new(
1076            "ALTER not yet implemented",
1077            self.current_span(),
1078        ))
1079    }
1080
1081    // ========== Transaction Parsing ==========
1082
1083    fn parse_begin(&mut self) -> Result<BeginStmt, ParseError> {
1084        self.expect(&TokenKind::Begin, "Expected BEGIN")?;
1085        self.match_token(&TokenKind::Transaction);
1086
1087        // TODO: Parse isolation level
1088        Ok(BeginStmt {
1089            read_only: false,
1090            isolation_level: None,
1091        })
1092    }
1093
1094    fn parse_rollback(&mut self) -> Result<Statement, ParseError> {
1095        self.expect(&TokenKind::Rollback, "Expected ROLLBACK")?;
1096        self.match_token(&TokenKind::Transaction);
1097
1098        // Check for ROLLBACK TO SAVEPOINT
1099        // TODO
1100
1101        Ok(Statement::Rollback(None))
1102    }
1103
1104    fn parse_savepoint(&mut self) -> Result<Statement, ParseError> {
1105        self.expect(&TokenKind::Savepoint, "Expected SAVEPOINT")?;
1106        let name = self.expect_identifier("Expected savepoint name")?;
1107        Ok(Statement::Savepoint(name))
1108    }
1109
1110    fn parse_release(&mut self) -> Result<Statement, ParseError> {
1111        self.expect(&TokenKind::Release, "Expected RELEASE")?;
1112        self.match_token(&TokenKind::Savepoint);
1113        let name = self.expect_identifier("Expected savepoint name")?;
1114        Ok(Statement::Release(name))
1115    }
1116
1117    // ========== Expression Parsing ==========
1118
1119    fn parse_expr(&mut self) -> Result<Expr, ParseError> {
1120        self.parse_or_expr()
1121    }
1122
1123    fn parse_or_expr(&mut self) -> Result<Expr, ParseError> {
1124        let mut left = self.parse_and_expr()?;
1125
1126        while self.match_token(&TokenKind::Or) {
1127            let right = self.parse_and_expr()?;
1128            left = Expr::BinaryOp {
1129                left: Box::new(left),
1130                op: BinaryOperator::Or,
1131                right: Box::new(right),
1132            };
1133        }
1134
1135        Ok(left)
1136    }
1137
1138    fn parse_and_expr(&mut self) -> Result<Expr, ParseError> {
1139        let mut left = self.parse_not_expr()?;
1140
1141        while self.match_token(&TokenKind::And) {
1142            let right = self.parse_not_expr()?;
1143            left = Expr::BinaryOp {
1144                left: Box::new(left),
1145                op: BinaryOperator::And,
1146                right: Box::new(right),
1147            };
1148        }
1149
1150        Ok(left)
1151    }
1152
1153    fn parse_not_expr(&mut self) -> Result<Expr, ParseError> {
1154        if self.match_token(&TokenKind::Not) {
1155            let expr = self.parse_not_expr()?;
1156            Ok(Expr::UnaryOp {
1157                op: UnaryOperator::Not,
1158                expr: Box::new(expr),
1159            })
1160        } else {
1161            self.parse_comparison_expr()
1162        }
1163    }
1164
1165    fn parse_comparison_expr(&mut self) -> Result<Expr, ParseError> {
1166        let mut left = self.parse_additive_expr()?;
1167
1168        // IS NULL / IS NOT NULL
1169        if self.match_token(&TokenKind::Is) {
1170            let negated = self.match_token(&TokenKind::Not);
1171            self.expect(&TokenKind::Null, "Expected NULL after IS")?;
1172            return Ok(Expr::IsNull {
1173                expr: Box::new(left),
1174                negated,
1175            });
1176        }
1177
1178        // IN / NOT IN
1179        let negated = self.match_token(&TokenKind::Not);
1180        if self.match_token(&TokenKind::In) {
1181            self.expect(&TokenKind::LParen, "Expected '(' after IN")?;
1182
1183            if self.check_keyword(&TokenKind::Select) {
1184                let subquery = self.parse_select()?;
1185                self.expect(&TokenKind::RParen, "Expected ')'")?;
1186                return Ok(Expr::InSubquery {
1187                    expr: Box::new(left),
1188                    subquery: Box::new(subquery),
1189                    negated,
1190                });
1191            } else {
1192                let list = self.parse_expr_list()?;
1193                self.expect(&TokenKind::RParen, "Expected ')'")?;
1194                return Ok(Expr::InList {
1195                    expr: Box::new(left),
1196                    list,
1197                    negated,
1198                });
1199            }
1200        }
1201
1202        // BETWEEN
1203        if self.match_token(&TokenKind::Between) {
1204            let low = self.parse_additive_expr()?;
1205            self.expect(&TokenKind::And, "Expected AND in BETWEEN")?;
1206            let high = self.parse_additive_expr()?;
1207            return Ok(Expr::Between {
1208                expr: Box::new(left),
1209                low: Box::new(low),
1210                high: Box::new(high),
1211                negated,
1212            });
1213        }
1214
1215        // LIKE
1216        if self.match_token(&TokenKind::Like) {
1217            let pattern = self.parse_additive_expr()?;
1218            let escape = if self.match_token(&TokenKind::Escape) {
1219                Some(Box::new(self.parse_additive_expr()?))
1220            } else {
1221                None
1222            };
1223            return Ok(Expr::Like {
1224                expr: Box::new(left),
1225                pattern: Box::new(pattern),
1226                escape,
1227                negated,
1228            });
1229        }
1230
1231        // If we consumed NOT but didn't find IN/BETWEEN/LIKE, error
1232        if negated {
1233            return Err(ParseError::new(
1234                "Expected IN, BETWEEN, or LIKE after NOT",
1235                self.current_span(),
1236            ));
1237        }
1238
1239        // Comparison operators
1240        let op = match &self.peek().kind {
1241            TokenKind::Eq => Some(BinaryOperator::Eq),
1242            TokenKind::Ne => Some(BinaryOperator::Ne),
1243            TokenKind::Lt => Some(BinaryOperator::Lt),
1244            TokenKind::Le => Some(BinaryOperator::Le),
1245            TokenKind::Gt => Some(BinaryOperator::Gt),
1246            TokenKind::Ge => Some(BinaryOperator::Ge),
1247            _ => None,
1248        };
1249
1250        if let Some(op) = op {
1251            self.advance();
1252            let right = self.parse_additive_expr()?;
1253            left = Expr::BinaryOp {
1254                left: Box::new(left),
1255                op,
1256                right: Box::new(right),
1257            };
1258        }
1259
1260        Ok(left)
1261    }
1262
1263    fn parse_additive_expr(&mut self) -> Result<Expr, ParseError> {
1264        let mut left = self.parse_multiplicative_expr()?;
1265
1266        loop {
1267            let op = match &self.peek().kind {
1268                TokenKind::Plus => BinaryOperator::Plus,
1269                TokenKind::Minus => BinaryOperator::Minus,
1270                TokenKind::Concat => BinaryOperator::Concat,
1271                _ => break,
1272            };
1273            self.advance();
1274
1275            let right = self.parse_multiplicative_expr()?;
1276            left = Expr::BinaryOp {
1277                left: Box::new(left),
1278                op,
1279                right: Box::new(right),
1280            };
1281        }
1282
1283        Ok(left)
1284    }
1285
1286    fn parse_multiplicative_expr(&mut self) -> Result<Expr, ParseError> {
1287        let mut left = self.parse_unary_expr()?;
1288
1289        loop {
1290            let op = match &self.peek().kind {
1291                TokenKind::Star => BinaryOperator::Multiply,
1292                TokenKind::Slash => BinaryOperator::Divide,
1293                TokenKind::Percent => BinaryOperator::Modulo,
1294                _ => break,
1295            };
1296            self.advance();
1297
1298            let right = self.parse_unary_expr()?;
1299            left = Expr::BinaryOp {
1300                left: Box::new(left),
1301                op,
1302                right: Box::new(right),
1303            };
1304        }
1305
1306        Ok(left)
1307    }
1308
1309    fn parse_unary_expr(&mut self) -> Result<Expr, ParseError> {
1310        match &self.peek().kind {
1311            TokenKind::Minus => {
1312                self.advance();
1313                let expr = self.parse_unary_expr()?;
1314                Ok(Expr::UnaryOp {
1315                    op: UnaryOperator::Minus,
1316                    expr: Box::new(expr),
1317                })
1318            }
1319            TokenKind::Plus => {
1320                self.advance();
1321                let expr = self.parse_unary_expr()?;
1322                Ok(Expr::UnaryOp {
1323                    op: UnaryOperator::Plus,
1324                    expr: Box::new(expr),
1325                })
1326            }
1327            TokenKind::BitNot => {
1328                self.advance();
1329                let expr = self.parse_unary_expr()?;
1330                Ok(Expr::UnaryOp {
1331                    op: UnaryOperator::BitNot,
1332                    expr: Box::new(expr),
1333                })
1334            }
1335            _ => self.parse_primary_expr(),
1336        }
1337    }
1338
1339    fn parse_primary_expr(&mut self) -> Result<Expr, ParseError> {
1340        let expr = match self.peek().kind.clone() {
1341            // Literals
1342            TokenKind::Integer(n) => {
1343                self.advance();
1344                Expr::Literal(Literal::Integer(n))
1345            }
1346            TokenKind::Float(n) => {
1347                self.advance();
1348                Expr::Literal(Literal::Float(n))
1349            }
1350            TokenKind::String(s) => {
1351                self.advance();
1352                Expr::Literal(Literal::String(s))
1353            }
1354            TokenKind::Blob(b) => {
1355                self.advance();
1356                Expr::Literal(Literal::Blob(b))
1357            }
1358            TokenKind::True => {
1359                self.advance();
1360                Expr::Literal(Literal::Boolean(true))
1361            }
1362            TokenKind::False => {
1363                self.advance();
1364                Expr::Literal(Literal::Boolean(false))
1365            }
1366            TokenKind::Null => {
1367                self.advance();
1368                Expr::Literal(Literal::Null)
1369            }
1370
1371            // Placeholder
1372            TokenKind::Placeholder(n) => {
1373                self.advance();
1374                Expr::Placeholder(n)
1375            }
1376
1377            // Parenthesized expression or subquery
1378            TokenKind::LParen => {
1379                self.advance();
1380                if self.check_keyword(&TokenKind::Select) {
1381                    let query = self.parse_select()?;
1382                    self.expect(&TokenKind::RParen, "Expected ')'")?;
1383                    Expr::Subquery(Box::new(query))
1384                } else {
1385                    let expr = self.parse_expr()?;
1386
1387                    // Check for tuple
1388                    if self.match_token(&TokenKind::Comma) {
1389                        let mut exprs = vec![expr];
1390                        exprs.push(self.parse_expr()?);
1391                        while self.match_token(&TokenKind::Comma) {
1392                            exprs.push(self.parse_expr()?);
1393                        }
1394                        self.expect(&TokenKind::RParen, "Expected ')'")?;
1395                        Expr::Tuple(exprs)
1396                    } else {
1397                        self.expect(&TokenKind::RParen, "Expected ')'")?;
1398                        expr
1399                    }
1400                }
1401            }
1402
1403            // CASE expression
1404            TokenKind::Case => {
1405                self.advance();
1406                self.parse_case_expr()?
1407            }
1408
1409            // EXISTS
1410            TokenKind::Exists => {
1411                self.advance();
1412                self.expect(&TokenKind::LParen, "Expected '(' after EXISTS")?;
1413                let query = self.parse_select()?;
1414                self.expect(&TokenKind::RParen, "Expected ')'")?;
1415                Expr::Exists(Box::new(query))
1416            }
1417
1418            // CAST
1419            TokenKind::Cast => {
1420                self.advance();
1421                self.expect(&TokenKind::LParen, "Expected '(' after CAST")?;
1422                let expr = self.parse_expr()?;
1423                self.expect(&TokenKind::As, "Expected AS in CAST")?;
1424                let data_type = self.parse_data_type()?;
1425                self.expect(&TokenKind::RParen, "Expected ')'")?;
1426                Expr::Cast {
1427                    expr: Box::new(expr),
1428                    data_type,
1429                }
1430            }
1431
1432            // SochDB Extensions
1433            TokenKind::VectorSearch => {
1434                self.advance();
1435                self.parse_vector_search()?
1436            }
1437            TokenKind::ContextWindow => {
1438                self.advance();
1439                self.parse_context_window()?
1440            }
1441
1442            // Aggregate functions
1443            TokenKind::Count
1444            | TokenKind::Sum
1445            | TokenKind::Avg
1446            | TokenKind::Min
1447            | TokenKind::Max => self.parse_aggregate_function()?,
1448
1449            // Function call or column reference
1450            TokenKind::Identifier(_) | TokenKind::QuotedIdentifier(_) => {
1451                self.parse_identifier_or_function()?
1452            }
1453
1454            // Type keywords used as column names
1455            TokenKind::Vector | TokenKind::Embedding | TokenKind::Text | TokenKind::BlobKw => {
1456                // Convert keyword to identifier
1457                let name = match &self.peek().kind {
1458                    TokenKind::Vector => "vector".to_string(),
1459                    TokenKind::Embedding => "embedding".to_string(),
1460                    TokenKind::Text => "text".to_string(),
1461                    TokenKind::BlobKw => "blob".to_string(),
1462                    _ => unreachable!(),
1463                };
1464                self.advance();
1465                Expr::Column(ColumnRef::new(name))
1466            }
1467
1468            _ => {
1469                return Err(ParseError::new(
1470                    format!("Unexpected token in expression: {:?}", self.peek().kind),
1471                    self.current_span(),
1472                ));
1473            }
1474        };
1475
1476        // Handle postfix operators
1477        self.parse_postfix_expr(expr)
1478    }
1479
1480    fn parse_postfix_expr(&mut self, mut expr: Expr) -> Result<Expr, ParseError> {
1481        loop {
1482            if self.match_token(&TokenKind::LBracket) {
1483                // Array subscript
1484                let index = self.parse_expr()?;
1485                self.expect(&TokenKind::RBracket, "Expected ']'")?;
1486                expr = Expr::Subscript {
1487                    expr: Box::new(expr),
1488                    index: Box::new(index),
1489                };
1490            } else if self.match_token(&TokenKind::Arrow) {
1491                // JSON access: ->
1492                let path = self.parse_primary_expr()?;
1493                expr = Expr::JsonAccess {
1494                    expr: Box::new(expr),
1495                    path: Box::new(path),
1496                    return_text: false,
1497                };
1498            } else if self.match_token(&TokenKind::DoubleArrow) {
1499                // JSON access returning text: ->>
1500                let path = self.parse_primary_expr()?;
1501                expr = Expr::JsonAccess {
1502                    expr: Box::new(expr),
1503                    path: Box::new(path),
1504                    return_text: true,
1505                };
1506            } else if self.match_token(&TokenKind::DoubleColon) {
1507                // Type cast: ::type
1508                let data_type = self.parse_data_type()?;
1509                expr = Expr::Cast {
1510                    expr: Box::new(expr),
1511                    data_type,
1512                };
1513            } else {
1514                break;
1515            }
1516        }
1517
1518        Ok(expr)
1519    }
1520
1521    fn parse_case_expr(&mut self) -> Result<Expr, ParseError> {
1522        // Simple CASE: CASE expr WHEN val THEN result ...
1523        // Searched CASE: CASE WHEN cond THEN result ...
1524
1525        let operand = if !self.check_keyword(&TokenKind::When) {
1526            Some(Box::new(self.parse_expr()?))
1527        } else {
1528            None
1529        };
1530
1531        let mut conditions = Vec::new();
1532
1533        while self.match_token(&TokenKind::When) {
1534            let when_expr = self.parse_expr()?;
1535            self.expect(&TokenKind::Then, "Expected THEN")?;
1536            let then_expr = self.parse_expr()?;
1537            conditions.push((when_expr, then_expr));
1538        }
1539
1540        let else_result = if self.match_token(&TokenKind::Else) {
1541            Some(Box::new(self.parse_expr()?))
1542        } else {
1543            None
1544        };
1545
1546        self.expect(&TokenKind::End, "Expected END")?;
1547
1548        Ok(Expr::Case {
1549            operand,
1550            conditions,
1551            else_result,
1552        })
1553    }
1554
1555    fn parse_identifier_or_function(&mut self) -> Result<Expr, ParseError> {
1556        let name = self.parse_object_name()?;
1557
1558        // Check for function call
1559        if self.match_token(&TokenKind::LParen) {
1560            let args = if self.check(&TokenKind::RParen) {
1561                Vec::new()
1562            } else {
1563                self.parse_expr_list()?
1564            };
1565            self.expect(&TokenKind::RParen, "Expected ')'")?;
1566
1567            Ok(Expr::Function(FunctionCall {
1568                name,
1569                args,
1570                distinct: false,
1571                filter: None,
1572                over: None,
1573            }))
1574        } else {
1575            // Column reference
1576            let parts = name.parts;
1577            if parts.len() == 1 {
1578                Ok(Expr::Column(ColumnRef::new(
1579                    parts.into_iter().next().unwrap(),
1580                )))
1581            } else if parts.len() == 2 {
1582                let mut iter = parts.into_iter();
1583                let table = iter.next().unwrap();
1584                let column = iter.next().unwrap();
1585                Ok(Expr::Column(ColumnRef::qualified(table, column)))
1586            } else {
1587                Err(ParseError::new(
1588                    "Invalid column reference",
1589                    self.current_span(),
1590                ))
1591            }
1592        }
1593    }
1594
1595    fn parse_aggregate_function(&mut self) -> Result<Expr, ParseError> {
1596        let name = match &self.peek().kind {
1597            TokenKind::Count => "COUNT",
1598            TokenKind::Sum => "SUM",
1599            TokenKind::Avg => "AVG",
1600            TokenKind::Min => "MIN",
1601            TokenKind::Max => "MAX",
1602            _ => {
1603                return Err(ParseError::new(
1604                    "Expected aggregate function",
1605                    self.current_span(),
1606                ));
1607            }
1608        };
1609        self.advance();
1610
1611        self.expect(&TokenKind::LParen, "Expected '(' after aggregate function")?;
1612
1613        let distinct = self.match_token(&TokenKind::Distinct);
1614
1615        let args = if self.match_token(&TokenKind::Star) {
1616            vec![Expr::Column(ColumnRef::new("*"))]
1617        } else {
1618            self.parse_expr_list()?
1619        };
1620
1621        self.expect(&TokenKind::RParen, "Expected ')'")?;
1622
1623        Ok(Expr::Function(FunctionCall {
1624            name: ObjectName::new(name),
1625            args,
1626            distinct,
1627            filter: None,
1628            over: None,
1629        }))
1630    }
1631
1632    fn parse_vector_search(&mut self) -> Result<Expr, ParseError> {
1633        self.expect(&TokenKind::LParen, "Expected '(' after VECTOR_SEARCH")?;
1634
1635        let column = self.parse_expr()?;
1636        self.expect(&TokenKind::Comma, "Expected ','")?;
1637
1638        let query = self.parse_expr()?;
1639        self.expect(&TokenKind::Comma, "Expected ','")?;
1640
1641        let k = match &self.peek().kind {
1642            TokenKind::Integer(n) => *n as u32,
1643            _ => return Err(ParseError::new("Expected integer k", self.current_span())),
1644        };
1645        self.advance();
1646
1647        let metric = if self.match_token(&TokenKind::Comma) {
1648            match &self.peek().kind {
1649                TokenKind::Cosine => {
1650                    self.advance();
1651                    VectorMetric::Cosine
1652                }
1653                TokenKind::Euclidean => {
1654                    self.advance();
1655                    VectorMetric::Euclidean
1656                }
1657                TokenKind::DotProduct => {
1658                    self.advance();
1659                    VectorMetric::DotProduct
1660                }
1661                _ => VectorMetric::Cosine,
1662            }
1663        } else {
1664            VectorMetric::Cosine
1665        };
1666
1667        self.expect(&TokenKind::RParen, "Expected ')'")?;
1668
1669        Ok(Expr::VectorSearch {
1670            column: Box::new(column),
1671            query: Box::new(query),
1672            k,
1673            metric,
1674        })
1675    }
1676
1677    fn parse_context_window(&mut self) -> Result<Expr, ParseError> {
1678        self.expect(&TokenKind::LParen, "Expected '(' after CONTEXT_WINDOW")?;
1679
1680        let source = self.parse_expr()?;
1681        self.expect(&TokenKind::Comma, "Expected ','")?;
1682
1683        let max_tokens = match &self.peek().kind {
1684            TokenKind::Integer(n) => *n as u32,
1685            _ => {
1686                return Err(ParseError::new(
1687                    "Expected integer max_tokens",
1688                    self.current_span(),
1689                ));
1690            }
1691        };
1692        self.advance();
1693
1694        let priority = if self.match_token(&TokenKind::Comma) {
1695            Some(Box::new(self.parse_expr()?))
1696        } else {
1697            None
1698        };
1699
1700        self.expect(&TokenKind::RParen, "Expected ')'")?;
1701
1702        Ok(Expr::ContextWindow {
1703            source: Box::new(source),
1704            max_tokens,
1705            priority,
1706        })
1707    }
1708
1709    // ========== Helper Parsers ==========
1710
1711    fn parse_object_name(&mut self) -> Result<ObjectName, ParseError> {
1712        let mut parts = Vec::new();
1713        parts.push(self.expect_identifier("Expected identifier")?);
1714
1715        while self.match_token(&TokenKind::Dot) {
1716            // Check for wildcard after dot (table.*)
1717            if self.check(&TokenKind::Star) {
1718                // Don't consume star, let caller handle it
1719                break;
1720            }
1721            parts.push(self.expect_identifier("Expected identifier after '.'")?);
1722        }
1723
1724        Ok(ObjectName { parts })
1725    }
1726
1727    fn parse_identifier_list(&mut self) -> Result<Vec<String>, ParseError> {
1728        let mut list = vec![self.expect_identifier("Expected identifier")?];
1729
1730        while self.match_token(&TokenKind::Comma) {
1731            list.push(self.expect_identifier("Expected identifier")?);
1732        }
1733
1734        Ok(list)
1735    }
1736
1737    fn parse_expr_list(&mut self) -> Result<Vec<Expr>, ParseError> {
1738        let mut list = vec![self.parse_expr()?];
1739
1740        while self.match_token(&TokenKind::Comma) {
1741            list.push(self.parse_expr()?);
1742        }
1743
1744        Ok(list)
1745    }
1746
1747    fn parse_order_by_list(&mut self) -> Result<Vec<OrderByItem>, ParseError> {
1748        let mut list = Vec::new();
1749
1750        loop {
1751            let expr = self.parse_expr()?;
1752
1753            let asc = if self.match_token(&TokenKind::Desc) {
1754                false
1755            } else {
1756                self.match_token(&TokenKind::Asc);
1757                true
1758            };
1759
1760            let nulls_first = if self.match_token(&TokenKind::Nulls) {
1761                if self.match_token(&TokenKind::First) {
1762                    Some(true)
1763                } else if self.match_token(&TokenKind::Last) {
1764                    Some(false)
1765                } else {
1766                    return Err(ParseError::new(
1767                        "Expected FIRST or LAST after NULLS",
1768                        self.current_span(),
1769                    ));
1770                }
1771            } else {
1772                None
1773            };
1774
1775            list.push(OrderByItem {
1776                expr,
1777                asc,
1778                nulls_first,
1779            });
1780
1781            if !self.match_token(&TokenKind::Comma) {
1782                break;
1783            }
1784        }
1785
1786        Ok(list)
1787    }
1788}
1789
1790#[cfg(test)]
1791mod tests {
1792    use super::*;
1793
1794    #[test]
1795    fn test_simple_select() {
1796        let stmt = Parser::parse("SELECT * FROM users").unwrap();
1797        assert!(matches!(stmt, Statement::Select(_)));
1798    }
1799
1800    #[test]
1801    fn test_select_with_where() {
1802        let stmt = Parser::parse("SELECT id, name FROM users WHERE id = 1").unwrap();
1803        if let Statement::Select(select) = stmt {
1804            assert_eq!(select.columns.len(), 2);
1805            assert!(select.where_clause.is_some());
1806        } else {
1807            panic!("Expected SELECT statement");
1808        }
1809    }
1810
1811    #[test]
1812    fn test_insert() {
1813        let stmt = Parser::parse("INSERT INTO users (id, name) VALUES (1, 'Alice')").unwrap();
1814        assert!(matches!(stmt, Statement::Insert(_)));
1815    }
1816
1817    #[test]
1818    fn test_create_table() {
1819        let stmt = Parser::parse(
1820            "CREATE TABLE users (id INTEGER PRIMARY KEY, name VARCHAR(100) NOT NULL)",
1821        )
1822        .unwrap();
1823        if let Statement::CreateTable(create) = stmt {
1824            assert_eq!(create.columns.len(), 2);
1825        } else {
1826            panic!("Expected CREATE TABLE statement");
1827        }
1828    }
1829
1830    #[test]
1831    fn test_vector_search() {
1832        let stmt = Parser::parse(
1833            "SELECT * FROM docs WHERE VECTOR_SEARCH(embedding, $1, 10, COSINE) > 0.8",
1834        )
1835        .unwrap();
1836        assert!(matches!(stmt, Statement::Select(_)));
1837    }
1838
1839    #[test]
1840    fn test_join() {
1841        let stmt = Parser::parse(
1842            "SELECT u.name, o.total FROM users u INNER JOIN orders o ON u.id = o.user_id",
1843        )
1844        .unwrap();
1845        assert!(matches!(stmt, Statement::Select(_)));
1846    }
1847
1848    #[test]
1849    fn test_subquery() {
1850        let stmt =
1851            Parser::parse("SELECT * FROM users WHERE id IN (SELECT user_id FROM orders)").unwrap();
1852        assert!(matches!(stmt, Statement::Select(_)));
1853    }
1854
1855    #[test]
1856    fn test_update() {
1857        let stmt = Parser::parse("UPDATE users SET name = 'Bob', age = 30 WHERE id = 1").unwrap();
1858        assert!(matches!(stmt, Statement::Update(_)));
1859    }
1860
1861    #[test]
1862    fn test_delete() {
1863        let stmt = Parser::parse("DELETE FROM users WHERE id = 1").unwrap();
1864        assert!(matches!(stmt, Statement::Delete(_)));
1865    }
1866
1867    #[test]
1868    fn test_group_by() {
1869        let stmt = Parser::parse(
1870            "SELECT category, COUNT(*) FROM products GROUP BY category HAVING COUNT(*) > 5",
1871        )
1872        .unwrap();
1873        if let Statement::Select(select) = stmt {
1874            assert!(!select.group_by.is_empty());
1875            assert!(select.having.is_some());
1876        } else {
1877            panic!("Expected SELECT statement");
1878        }
1879    }
1880
1881    #[test]
1882    fn test_order_by() {
1883        let stmt =
1884            Parser::parse("SELECT * FROM users ORDER BY name ASC, age DESC NULLS LAST").unwrap();
1885        if let Statement::Select(select) = stmt {
1886            assert_eq!(select.order_by.len(), 2);
1887        } else {
1888            panic!("Expected SELECT statement");
1889        }
1890    }
1891
1892    #[test]
1893    fn test_between() {
1894        let stmt = Parser::parse("SELECT * FROM products WHERE price BETWEEN 10 AND 100").unwrap();
1895        assert!(matches!(stmt, Statement::Select(_)));
1896    }
1897
1898    #[test]
1899    fn test_like() {
1900        let stmt = Parser::parse("SELECT * FROM users WHERE name LIKE '%Alice%'").unwrap();
1901        assert!(matches!(stmt, Statement::Select(_)));
1902    }
1903
1904    #[test]
1905    fn test_case() {
1906        let stmt =
1907            Parser::parse("SELECT CASE WHEN x > 0 THEN 'positive' ELSE 'non-positive' END FROM t")
1908                .unwrap();
1909        assert!(matches!(stmt, Statement::Select(_)));
1910    }
1911
1912    #[test]
1913    fn test_transactions() {
1914        let stmts = Parser::parse_statements("BEGIN; COMMIT; ROLLBACK").unwrap();
1915        assert_eq!(stmts.len(), 3);
1916        assert!(matches!(stmts[0], Statement::Begin(_)));
1917        assert!(matches!(stmts[1], Statement::Commit));
1918        assert!(matches!(stmts[2], Statement::Rollback(_)));
1919    }
1920
1921    // ===== Dialect-Specific Insert Tests =====
1922
1923    #[test]
1924    fn test_insert_on_conflict_do_nothing() {
1925        let stmt = Parser::parse(
1926            "INSERT INTO users (id, name) VALUES (1, 'Alice') ON CONFLICT DO NOTHING",
1927        )
1928        .unwrap();
1929        if let Statement::Insert(insert) = stmt {
1930            assert!(insert.on_conflict.is_some());
1931            let on_conflict = insert.on_conflict.unwrap();
1932            assert!(matches!(on_conflict.action, ConflictAction::DoNothing));
1933        } else {
1934            panic!("Expected INSERT statement");
1935        }
1936    }
1937
1938    #[test]
1939    fn test_insert_on_conflict_do_update() {
1940        let stmt = Parser::parse(
1941            "INSERT INTO users (id, name) VALUES (1, 'Alice') ON CONFLICT (id) DO UPDATE SET name = 'Bob'",
1942        )
1943        .unwrap();
1944        if let Statement::Insert(insert) = stmt {
1945            assert!(insert.on_conflict.is_some());
1946            let on_conflict = insert.on_conflict.unwrap();
1947            assert!(matches!(on_conflict.target, Some(ConflictTarget::Columns(_))));
1948            assert!(matches!(on_conflict.action, ConflictAction::DoUpdate(_)));
1949        } else {
1950            panic!("Expected INSERT statement");
1951        }
1952    }
1953
1954    #[test]
1955    fn test_insert_ignore_mysql() {
1956        let stmt = Parser::parse("INSERT IGNORE INTO users (id, name) VALUES (1, 'Alice')").unwrap();
1957        if let Statement::Insert(insert) = stmt {
1958            assert!(insert.on_conflict.is_some());
1959            let on_conflict = insert.on_conflict.unwrap();
1960            assert!(matches!(on_conflict.action, ConflictAction::DoNothing));
1961        } else {
1962            panic!("Expected INSERT statement");
1963        }
1964    }
1965
1966    #[test]
1967    fn test_insert_or_ignore_sqlite() {
1968        let stmt =
1969            Parser::parse("INSERT OR IGNORE INTO users (id, name) VALUES (1, 'Alice')").unwrap();
1970        if let Statement::Insert(insert) = stmt {
1971            assert!(insert.on_conflict.is_some());
1972            let on_conflict = insert.on_conflict.unwrap();
1973            assert!(matches!(on_conflict.action, ConflictAction::DoNothing));
1974        } else {
1975            panic!("Expected INSERT statement");
1976        }
1977    }
1978
1979    #[test]
1980    fn test_insert_or_replace_sqlite() {
1981        let stmt =
1982            Parser::parse("INSERT OR REPLACE INTO users (id, name) VALUES (1, 'Alice')").unwrap();
1983        if let Statement::Insert(insert) = stmt {
1984            assert!(insert.on_conflict.is_some());
1985            let on_conflict = insert.on_conflict.unwrap();
1986            assert!(matches!(on_conflict.action, ConflictAction::DoReplace));
1987        } else {
1988            panic!("Expected INSERT statement");
1989        }
1990    }
1991
1992    #[test]
1993    fn test_on_duplicate_key_update_mysql() {
1994        let stmt = Parser::parse(
1995            "INSERT INTO users (id, name) VALUES (1, 'Alice') ON DUPLICATE KEY UPDATE name = 'Bob'",
1996        )
1997        .unwrap();
1998        if let Statement::Insert(insert) = stmt {
1999            assert!(insert.on_conflict.is_some());
2000            let on_conflict = insert.on_conflict.unwrap();
2001            assert!(matches!(on_conflict.action, ConflictAction::DoUpdate(_)));
2002        } else {
2003            panic!("Expected INSERT statement");
2004        }
2005    }
2006
2007    // ===== Idempotent DDL Tests =====
2008
2009    #[test]
2010    fn test_create_table_if_not_exists() {
2011        let stmt = Parser::parse("CREATE TABLE IF NOT EXISTS users (id INT PRIMARY KEY)").unwrap();
2012        if let Statement::CreateTable(create) = stmt {
2013            assert!(create.if_not_exists);
2014        } else {
2015            panic!("Expected CREATE TABLE statement");
2016        }
2017    }
2018
2019    #[test]
2020    fn test_drop_table_if_exists() {
2021        let stmt = Parser::parse("DROP TABLE IF EXISTS users").unwrap();
2022        if let Statement::DropTable(drop) = stmt {
2023            assert!(drop.if_exists);
2024        } else {
2025            panic!("Expected DROP TABLE statement");
2026        }
2027    }
2028
2029    #[test]
2030    fn test_create_index() {
2031        let stmt = Parser::parse("CREATE INDEX idx_users_name ON users (name)").unwrap();
2032        if let Statement::CreateIndex(create) = stmt {
2033            assert_eq!(create.name, "idx_users_name");
2034            assert_eq!(create.table.name(), "users");
2035            assert!(!create.unique);
2036            assert!(!create.if_not_exists);
2037        } else {
2038            panic!("Expected CREATE INDEX statement");
2039        }
2040    }
2041
2042    #[test]
2043    fn test_create_unique_index() {
2044        let stmt = Parser::parse("CREATE UNIQUE INDEX idx_users_email ON users (email)").unwrap();
2045        if let Statement::CreateIndex(create) = stmt {
2046            assert!(create.unique);
2047        } else {
2048            panic!("Expected CREATE INDEX statement");
2049        }
2050    }
2051
2052    #[test]
2053    fn test_create_index_if_not_exists() {
2054        let stmt =
2055            Parser::parse("CREATE INDEX IF NOT EXISTS idx_users_name ON users (name)").unwrap();
2056        if let Statement::CreateIndex(create) = stmt {
2057            assert!(create.if_not_exists);
2058        } else {
2059            panic!("Expected CREATE INDEX statement");
2060        }
2061    }
2062
2063    #[test]
2064    fn test_drop_index() {
2065        let stmt = Parser::parse("DROP INDEX idx_users_name").unwrap();
2066        if let Statement::DropIndex(drop) = stmt {
2067            assert_eq!(drop.name, "idx_users_name");
2068            assert!(!drop.if_exists);
2069        } else {
2070            panic!("Expected DROP INDEX statement");
2071        }
2072    }
2073
2074    #[test]
2075    fn test_drop_index_if_exists() {
2076        let stmt = Parser::parse("DROP INDEX IF EXISTS idx_users_name").unwrap();
2077        if let Statement::DropIndex(drop) = stmt {
2078            assert!(drop.if_exists);
2079        } else {
2080            panic!("Expected DROP INDEX statement");
2081        }
2082    }
2083
2084    // ===== RETURNING clause tests =====
2085
2086    #[test]
2087    fn test_insert_returning() {
2088        let stmt = Parser::parse(
2089            "INSERT INTO users (id, name) VALUES (1, 'Alice') RETURNING id, name",
2090        )
2091        .unwrap();
2092        if let Statement::Insert(insert) = stmt {
2093            assert!(insert.returning.is_some());
2094            let returning = insert.returning.unwrap();
2095            assert_eq!(returning.len(), 2);
2096        } else {
2097            panic!("Expected INSERT statement");
2098        }
2099    }
2100}
sochdb_query/sql/parser.rs

sochdb_query/sql/
parser.rs
