Add create index statement parser.

Author: gtnao

src/lexer.rs

@@ -33,6 +33,7 @@ pub enum Token {
 pub enum Keyword {
     Create,
     Table,
+    Index,
     Insert,
     Into,
     Values,
@@ -73,6 +74,7 @@ impl TryFrom<&str> for Keyword {
         match &*s.to_uppercase() {
             "CREATE" => Ok(Keyword::Create),
             "TABLE" => Ok(Keyword::Table),
+            "INDEX" => Ok(Keyword::Index),
             "INSERT" => Ok(Keyword::Insert),
             "INTO" => Ok(Keyword::Into),
             "VALUES" => Ok(Keyword::Values),
@@ -306,7 +308,7 @@ mod tests {
     #[test]
     fn test_all_keywords() -> Result<()> {
         let text = r#"
-            CREATE table Insert INTO VALUES DELETE FROM WHERE UPDATE SET
+            CREATE table Index INSERT INTO VALUES DELETE FROM WHERE UPDATE SET
             SELECT INNER LEFT JOIN ON GROUP BY HAVING ORDER ASC
             DESC LIMIT OFFSET INT INTEGER VARCHAR BOOLEAN BEGIN
             COMMIT ROLLBACK AS AND OR NOT IS
@@ -318,6 +320,7 @@ mod tests {
             vec![
                 Token::Keyword(Keyword::Create),
                 Token::Keyword(Keyword::Table),
+                Token::Keyword(Keyword::Index),
                 Token::Keyword(Keyword::Insert),
                 Token::Keyword(Keyword::Into),
                 Token::Keyword(Keyword::Values),

src/parser.rs

@@ -9,6 +9,7 @@ use crate::{
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub enum StatementAST {
     CreateTable(CreateTableStatementAST),
+    CreateIndex(CreateIndexStatementAST),
     Select(SelectStatementAST),
     Insert(InsertStatementAST),
     Delete(DeleteStatementAST),
@@ -28,6 +29,12 @@ pub struct TableElementAST {
     pub data_type: DataType,
 }
 #[derive(Debug, PartialEq, Eq, Clone)]
+pub struct CreateIndexStatementAST {
+    pub index_name: String,
+    pub table_name: String,
+    pub column_names: Vec<String>,
+}
+#[derive(Debug, PartialEq, Eq, Clone)]
 pub struct SelectStatementAST {
     pub select_elements: Vec<SelectElementAST>,
     pub table_reference: Option<TableReferenceAST>,
@@ -186,6 +193,11 @@ impl Parser {
         {
             return Ok(StatementAST::CreateTable(self.create_table_statement()?));
         }
+        if self.match_token(Token::Keyword(Keyword::Create))
+            && self.match_look_ahead(Token::Keyword(Keyword::Index))
+        {
+            return Ok(StatementAST::CreateIndex(self.create_index_statement()?));
+        }
         if self.match_token(Token::Keyword(Keyword::Select)) {
             return Ok(StatementAST::Select(self.select_statement()?));
         }
@@ -259,6 +271,27 @@ impl Parser {
             _ => Err(anyhow!("invalid data type")),
         }
     }
+    fn create_index_statement(&mut self) -> Result<CreateIndexStatementAST> {
+        self.consume_token_or_error(Token::Keyword(Keyword::Create))?;
+        self.consume_token_or_error(Token::Keyword(Keyword::Index))?;
+        let index_name = self.identifier()?;
+        self.consume_token_or_error(Token::Keyword(Keyword::On))?;
+        let table_name = self.identifier()?;
+        self.consume_token_or_error(Token::LeftParen)?;
+        let mut column_names = Vec::new();
+        loop {
+            column_names.push(self.identifier()?);
+            if !self.consume_token(Token::Comma) {
+                break;
+            }
+        }
+        self.consume_token_or_error(Token::RightParen)?;
+        Ok(CreateIndexStatementAST {
+            index_name,
+            table_name,
+            column_names,
+        })
+    }
     fn select_statement(&mut self) -> Result<SelectStatementAST> {
         self.consume_token_or_error(Token::Keyword(Keyword::Select))?;
         let select_elements = if self.consume_token(Token::Asterisk) {
@@ -746,6 +779,25 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn test_parse_create_index() -> Result<()> {
+        let sql = r#"
+            CREATE INDEX id_name_index ON users (id, name);
+        "#;
+        let mut parser = Parser::new(tokenize(&mut sql.chars().peekable())?);
+
+        let statement = parser.parse()?;
+        assert_eq!(
+            statement,
+            StatementAST::CreateIndex(CreateIndexStatementAST {
+                index_name: String::from("id_name_index"),
+                table_name: String::from("users"),
+                column_names: vec![String::from("id"), String::from("name")],
+            })
+        );
+        Ok(())
+    }
+
     #[test]
     fn test_parse_select() -> Result<()> {
         let sql = r#"

src/server.rs

@@ -179,6 +179,12 @@ impl Session {
                             .create_table(&ast, txn_id)?;
                         format!("table {} created", ast.table_name)
                     }
+                    StatementAST::CreateIndex(ast) => {
+                        format!(
+                            "create index is not implemented yet ({:?}, {:?}, {:?})",
+                            ast.index_name, ast.table_name, ast.column_names
+                        )
+                    }
                     _ => {
                         let (rows, schema) = self
                             .instance