implement alter table for sqlite grammar

src/ast/ddl.rs

@@ -23,15 +23,60 @@ 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 {
+        table_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 { table_name } => {
+                write!(f, "RENAME TO {}", table_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 table_name = self.parse_identifier()?;
+                AlterTableOperation::RenameTable { table_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

@@ -1313,6 +1313,57 @@ fn parse_create_table_empty() {
     let _ = verified_stmt("CREATE TABLE t ()");
 }
 
+#[test]
+fn parse_alter_table() {
+    let add_column = "ALTER TABLE tab ADD COLUMN foo TEXT";
+    match verified_stmt(add_column) {
+        Statement::AlterTable {
+            name,
+            operation:
+                AlterTableOperation::AddColumn {
+                    has_column_identifier,
+                    column_def,
+                },
+        } => {
+            assert_eq!("tab", name.to_string());
+            assert_eq!(has_column_identifier, true);
+            assert_eq!("foo", column_def.name.to_string());
+        }
+        _ => unreachable!(),
+    };
+
+    let rename_table = "ALTER TABLE tab RENAME TO new_tab";
+    match verified_stmt(rename_table) {
+        Statement::AlterTable {
+            name,
+            operation: AlterTableOperation::RenameTable { table_name },
+        } => {
+            assert_eq!("tab", name.to_string());
+            assert_eq!("new_tab", table_name.to_string())
+        }
+        _ => unreachable!(),
+    };
+
+    let rename_column = "ALTER TABLE tab RENAME COLUMN foo TO new_foo";
+    match verified_stmt(rename_column) {
+        Statement::AlterTable {
+            name,
+            operation:
+                AlterTableOperation::RenameColumn {
+                    has_column_identifier,
+                    old_column_name,
+                    new_column_name,
+                },
+        } => {
+            assert_eq!("tab", name.to_string());
+            assert_eq!(has_column_identifier, true);
+            assert_eq!(old_column_name.to_string(), "foo");
+            assert_eq!(new_column_name.to_string(), "new_foo");
+        }
+        _ => unreachable!(),
+    }
+}
+
 #[test]
 fn parse_alter_table_constraints() {
     check_one("CONSTRAINT address_pkey PRIMARY KEY (address_id)");
@@ -1347,9 +1398,7 @@ fn parse_alter_table_constraints() {
 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()
     );