implement alter table for sqlite grammer: https://www.sqlite.org/lang_altertable.html

Author: mashuai

src/ast/ddl.rs

@@ -23,15 +23,25 @@ use std::fmt;
 pub enum AlterTableOperation {
     /// `ADD <table_constraint>`
     AddConstraint(TableConstraint),
+    AddColumn{has_column_identifier: bool, column_def: ColumnDef},
     /// TODO: implement `DROP CONSTRAINT <name>`
     DropConstraint { name: Ident },
+    RenameColumn{has_column_identifier: bool, old_column_name: Ident, new_column_name: Ident},
+    RenameTable{name: Ident}
 }
 
 impl fmt::Display for AlterTableOperation {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             AlterTableOperation::AddConstraint(c) => write!(f, "ADD {}", c),
+            AlterTableOperation::AddColumn { has_column_identifier, column_def } => {
+                write!(f, "ADD {}{}", if *has_column_identifier { "COLUMN "} else {""},column_def.to_string())
+            },
             AlterTableOperation::DropConstraint { name } => write!(f, "DROP CONSTRAINT {}", name),
+            AlterTableOperation::RenameColumn {has_column_identifier, old_column_name, new_column_name} => {
+                write!(f,"RENAME {}{} TO {}", if *has_column_identifier {"COLUMN "} else {""} ,old_column_name, new_column_name)
+            },
+            AlterTableOperation::RenameTable { name } => write!(f, "RENAME TO {}", name),
         }
     }
 }

src/dialect/keywords.rs

@@ -340,6 +340,7 @@ define_keywords!(
     REGR_SXY,
     REGR_SYY,
     RELEASE,
+    RENAME,
     REPEATABLE,
     RESTRICT,
     RESULT,

src/parser.rs

@@ -1122,6 +1122,29 @@ impl Parser {
         })
     }
 
+    fn parse_column(&mut self) -> Result<ColumnDef, ParserError> {
+        let name = self.parse_identifier()?;
+        let data_type = self.parse_data_type()?;
+        let collation = if self.parse_keyword(Keyword::COLLATE) {
+            Some(self.parse_object_name()?)
+        } else {
+            None
+        };
+        let mut options = vec![];
+        loop {
+            match self.peek_token() {
+                Token::EOF => break,
+                _ => options.push(self.parse_column_option_def()?),
+            }
+        }
+        Ok(ColumnDef{
+            name,
+            data_type,
+            collation,
+            options
+        })
+    }
+
     fn parse_columns(&mut self) -> Result<(Vec<ColumnDef>, Vec<TableConstraint>), ParserError> {
         let mut columns = vec![];
         let mut constraints = vec![];
@@ -1318,10 +1341,23 @@ impl Parser {
             if let Some(constraint) = self.parse_optional_table_constraint()? {
                 AlterTableOperation::AddConstraint(constraint)
             } else {
-                return self.expected("a constraint in ALTER TABLE .. ADD", self.peek_token());
+                let has_column_identifier = self.parse_keyword(Keyword::COLUMN);
+                let column_def = self.parse_column()?;
+                AlterTableOperation::AddColumn {has_column_identifier, column_def}
             }
-        } else {
-            return self.expected("ADD after ALTER TABLE", self.peek_token());
+        } else if self.parse_keyword(Keyword::RENAME){
+            if self.parse_keyword(Keyword::TO) {
+                let name = self.parse_identifier()?;
+                AlterTableOperation::RenameTable {name}
+            } else {
+                let  has_column_identifier = self.parse_keyword(Keyword::COLUMN);
+                let old_column_name = self.parse_identifier()?;
+                self.expect_keyword(Keyword::TO)?;
+                let new_column_name = self.parse_identifier()?;
+                AlterTableOperation::RenameColumn {has_column_identifier, old_column_name, new_column_name}
+            }
+        }else {
+            return self.expected("ADD,RENAME TO or RENAME after ALTER TABLE", self.peek_token());
         };
         Ok(Statement::AlterTable {
             name: table_name,

tests/sqlparser_common.rs

@@ -1315,31 +1315,56 @@ fn parse_create_table_empty() {
 
 #[test]
 fn parse_alter_table_constraints() {
-    check_one("CONSTRAINT address_pkey PRIMARY KEY (address_id)");
-    check_one("CONSTRAINT uk_task UNIQUE (report_date, task_id)");
+    check_one("ADD CONSTRAINT address_pkey PRIMARY KEY (address_id)");
+    check_one("ADD CONSTRAINT uk_task UNIQUE (report_date, task_id)");
     check_one(
-        "CONSTRAINT customer_address_id_fkey FOREIGN KEY (address_id) \
+        "ADD CONSTRAINT customer_address_id_fkey FOREIGN KEY (address_id) \
          REFERENCES public.address(address_id)",
     );
-    check_one("CONSTRAINT ck CHECK (rtrim(ltrim(REF_CODE)) <> '')");
+    check_one("ADD CONSTRAINT ck CHECK (rtrim(ltrim(REF_CODE)) <> '')");
 
-    check_one("PRIMARY KEY (foo, bar)");
-    check_one("UNIQUE (id)");
-    check_one("FOREIGN KEY (foo, bar) REFERENCES AnotherTable(foo, bar)");
-    check_one("CHECK (end_date > start_date OR end_date IS NULL)");
+    check_one("ADD PRIMARY KEY (foo, bar)");
+    check_one("ADD UNIQUE (id)");
+    check_one("ADD FOREIGN KEY (foo, bar) REFERENCES AnotherTable(foo, bar)");
+    check_one("ADD CHECK (end_date > start_date OR end_date IS NULL)");
+    check_one("ADD foo TEXT");
+    check_one("ADD COLUMN foo TEXT");
 
-    fn check_one(constraint_text: &str) {
-        match verified_stmt(&format!("ALTER TABLE tab ADD {}", constraint_text)) {
+    check_one("RENAME TO tab_rename");
+    check_one("RENAME old_col TO new_col");
+    check_one("RENAME COLUMN old_col TO new_col");
+
+    fn check_one(stmt: &str) {
+        match verified_stmt(&format!("ALTER TABLE tab {}", stmt)) {
             Statement::AlterTable {
                 name,
-                operation: AlterTableOperation::AddConstraint(constraint),
+                operation,
             } => {
                 assert_eq!("tab", name.to_string());
-                assert_eq!(constraint_text, constraint.to_string());
-            }
+                match operation {
+                    AlterTableOperation::AddConstraint(constraint) => {
+                        assert_eq!(stmt, "ADD ".to_string() + &constraint.to_string());
+                    },
+                    AlterTableOperation::AddColumn { has_column_identifier, column_def } => {
+                        assert_eq!("foo", column_def.name.to_string());
+                    }
+                    AlterTableOperation::DropConstraint {.. } => {},
+                    AlterTableOperation::RenameColumn { has_column_identifier, old_column_name, new_column_name } => {
+                        assert_eq!("old_col", old_column_name.to_string());
+                        assert_eq!("new_col", new_column_name.to_string());
+                    },
+                    AlterTableOperation::RenameTable { name } => {
+                        assert_eq!("tab_rename", name.to_string())
+                    },
+                }
+            },
             _ => unreachable!(),
         }
-        verified_stmt(&format!("CREATE TABLE foo (id INT, {})", constraint_text));
+        if stmt.starts_with("ADD") {
+            let stmt = stmt.replacen("ADD ", "", 1);
+            let stmt = stmt.replacen("COLUMN ", "", 1);
+            verified_stmt(&format!("CREATE TABLE foo (id INT, {})", stmt));
+        }
     }
 }
 
@@ -1348,7 +1373,7 @@ fn parse_bad_constraint() {
     let res = parse_sql_statements("ALTER TABLE tab ADD");
     assert_eq!(
         ParserError::ParserError(
-            "Expected a constraint in ALTER TABLE .. ADD, found: EOF".to_string()
+            "Expected identifier, found: EOF".to_string()
         ),
         res.unwrap_err()
     );