Merge pull request #21 from lykia-rs/milestone/phase-1

Phase 1 / More test coverage

README.md

@@ -31,12 +31,16 @@ Lykia is a toy document database basically written for educational purposes. It
 
 - [x] Core scripting language
 - [x] A minimal standard library
-- [x] SQL "SELECT" statements parsing
-- [ ] Rest of the SQL syntax
+- [ ] SQL parsing
+    - [x] "SELECT" expressions (the most complex part of the SQL syntax)
+    - [ ] "INSERT" statements
+    - [ ] "UPDATE" statements
+    - [ ] "DELETE" statements
 - [ ] Query planning
 - [ ] Plan optimization
 - [ ] Async runtime/event loop
 - [ ] In-memory storage engine
+- [ ] Type checker
 - [ ] Persistent storage engine (Bitcask)
 - [ ] Transaction management with MVCC
 - [ ] B-Tree implementation for indexes

server/src/lang/ast/expr.rs

@@ -1,7 +1,26 @@
 use std::rc::Rc;
 
+use serde::{Deserialize, Serialize};
+
 use super::{sql::SqlSelect, stmt::StmtId, Literal};
-use crate::lang::token::{Span, Spanned, Token, TokenType};
+use crate::lang::token::{Span, Spanned, Token};
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
+pub enum Operation {
+    Add,
+    Subtract,
+    Multiply,
+    Divide,
+    IsEqual,
+    IsNotEqual,
+    Greater,
+    GreaterEqual,
+    Less,
+    LessEqual,
+    And,
+    Or,
+    Not,
+}
 
 #[derive(Debug, Eq, PartialEq)]
 pub enum Expr {
@@ -30,12 +49,12 @@ pub enum Expr {
     },
     Binary {
         left: ExprId,
-        symbol: TokenType,
+        operation: Operation,
         right: ExprId,
         span: Span,
     },
     Unary {
-        symbol: TokenType,
+        operation: Operation,
         expr: ExprId,
         span: Span,
     },
@@ -46,7 +65,7 @@ pub enum Expr {
     },
     Logical {
         left: ExprId,
-        symbol: TokenType,
+        operation: Operation,
         right: ExprId,
         span: Span,
     },
@@ -87,12 +106,12 @@ impl Spanned for Expr {
             }
             | Expr::Binary {
                 left: _,
-                symbol: _,
+                operation: _,
                 right: _,
                 span,
             }
             | Expr::Unary {
-                symbol: _,
+                operation: _,
                 expr: _,
                 span,
             }
@@ -103,7 +122,7 @@ impl Spanned for Expr {
             }
             | Expr::Logical {
                 left: _,
-                symbol: _,
+                operation: _,
                 right: _,
                 span,
             }

server/src/lang/ast/mod.rs

@@ -4,6 +4,7 @@ use rustc_hash::FxHashMap;
 
 use self::{
     expr::{Expr, ExprId},
+    sql::{SqlCollectionSubquery, SqlExpr, SqlSelect, SqlSelectCore},
     stmt::{Stmt, StmtId},
 };
 pub mod expr;
@@ -25,10 +26,29 @@ pub enum Literal {
 impl Eq for Literal {}
 
 pub trait Visitor<T, Q> {
+    fn visit_expr(&self, e: ExprId) -> Result<T, Q>;
+    fn visit_stmt(&self, e: StmtId) -> Result<T, Q>;
+}
+
+pub trait SqlVisitor<T, Q> {
+    fn visit_sql_select(&self, e: &SqlSelect) -> Result<T, Q>;
+    fn visit_sql_select_core(&self, core: &SqlSelectCore) -> Result<T, Q>;
+    fn visit_sql_subquery(&self, subquery: &SqlCollectionSubquery) -> Result<T, Q>;
+    fn visit_sql_expr(&self, sql_expr: &SqlExpr) -> Result<T, Q>;
+}
+
+pub trait VisitorMut<T, Q> {
     fn visit_expr(&mut self, e: ExprId) -> Result<T, Q>;
     fn visit_stmt(&mut self, e: StmtId) -> Result<T, Q>;
 }
 
+pub trait SqlVisitorMut<T, Q> {
+    fn visit_sql_select(&mut self, e: &SqlSelect) -> Result<T, Q>;
+    fn visit_sql_select_core(&mut self, core: &SqlSelectCore) -> Result<T, Q>;
+    fn visit_sql_subquery(&mut self, subquery: &SqlCollectionSubquery) -> Result<T, Q>;
+    fn visit_sql_expr(&mut self, sql_expr: &SqlExpr) -> Result<T, Q>;
+}
+
 pub struct ParserArena {
     expressions: Vec<Expr>,
     statements: Vec<Stmt>,

server/src/lang/ast/sql.rs

@@ -45,6 +45,24 @@ pub enum SqlProjection {
     Expr { expr: SqlExpr, alias: Option<Token> },
 }
 
+#[derive(Debug, Eq, PartialEq)]
+pub struct SqlLimitClause {
+    pub count: SqlExpr,
+    pub offset: Option<SqlExpr>,
+}
+
+#[derive(Debug, Eq, PartialEq)]
+pub struct SqlOrderByClause {
+    pub expr: SqlExpr,
+    pub ordering: SqlOrdering,
+}
+
+#[derive(Debug, Eq, PartialEq)]
+pub struct SqlSelectCompound {
+    pub operator: SqlCompoundOperator,
+    pub core: SqlSelectCore,
+}
+
 #[derive(Debug, Eq, PartialEq)]
 pub struct SqlJoin {
     pub join_type: SqlJoinType,
@@ -68,7 +86,7 @@ pub enum SqlCollectionSubquery {
 }
 
 #[derive(Debug, Eq, PartialEq)]
-pub struct SelectCore {
+pub struct SqlSelectCore {
     pub distinct: SqlDistinct,
     pub projection: Vec<SqlProjection>,
     pub from: Option<SqlCollectionSubquery>,
@@ -79,8 +97,8 @@ pub struct SelectCore {
 
 #[derive(Debug, Eq, PartialEq)]
 pub struct SqlSelect {
-    pub core: SelectCore,
-    pub compound: Vec<(SqlCompoundOperator, SelectCore)>,
-    pub order_by: Option<Vec<(SqlExpr, SqlOrdering)>>,
-    pub limit: Option<(SqlExpr, Option<SqlExpr>)>,
+    pub core: SqlSelectCore,
+    pub compound: Vec<SqlSelectCompound>,
+    pub order_by: Option<Vec<SqlOrderByClause>>,
+    pub limit: Option<SqlLimitClause>,
 }

server/src/lang/ast/stmt.rs

@@ -5,7 +5,7 @@ use super::expr::ExprId;
 #[derive(Debug, Eq, PartialEq)]
 pub enum Stmt {
     Program {
-        stmts: Vec<StmtId>,
+        body: Vec<StmtId>,
         span: Span,
     },
     Expression {
@@ -19,7 +19,7 @@ pub enum Stmt {
         span: Span,
     },
     Block {
-        stmts: Vec<StmtId>,
+        body: Vec<StmtId>,
         span: Span,
     },
     Declaration {
@@ -30,7 +30,7 @@ pub enum Stmt {
     If {
         condition: ExprId,
         body: StmtId,
-        r#else: Option<StmtId>,
+        r#else_body: Option<StmtId>,
         span: Span,
     },
     Loop {