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

Author: mashuai

src/ast/ddl.rs

@@ -23,15 +23,58 @@ 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 },
+    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,33 @@ 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 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 after ALTER TABLE", self.peek_token());
+            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,41 +1315,68 @@ 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)) {
-            Statement::AlterTable {
-                name,
-                operation: AlterTableOperation::AddConstraint(constraint),
-            } => {
+    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 } => {
                 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::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!(),
+                }
             }
             _ => 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));
+        }
     }
 }
 
 #[test]
 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()
-        ),
+        ParserError::ParserError("Expected identifier, found: EOF".to_string()),
         res.unwrap_err()
     );