Support DROP [TABLE|VIEW]

Co-authored-by: Jamie Brandon <jamie@scattered-thoughts.net>

Author: benesch

src/dialect/keywords.rs

@@ -71,6 +71,7 @@ define_keywords!(
     CALL,
     CALLED,
     CARDINALITY,
+    CASCADE,
     CASCADED,
     CASE,
     CAST,
@@ -178,6 +179,7 @@ define_keywords!(
     HOLD,
     HOUR,
     IDENTITY,
+    IF,
     IN,
     INDICATOR,
     INNER,
@@ -290,6 +292,7 @@ define_keywords!(
     REGR_SXY,
     REGR_SYY,
     RELEASE,
+    RESTRICT,
     RESULT,
     RETURN,
     RETURNS,

src/sqlast/mod.rs

@@ -394,6 +394,10 @@ pub enum SQLStatement {
         name: SQLObjectName,
         operation: AlterOperation,
     },
+    /// DROP TABLE
+    SQLDropTable(SQLDrop),
+    /// DROP VIEW
+    SQLDropView(SQLDrop),
 }
 
 impl ToString for SQLStatement {
@@ -499,6 +503,8 @@ impl ToString for SQLStatement {
                 name.to_string(),
                 comma_separated_string(columns)
             ),
+            SQLStatement::SQLDropTable(drop) => drop.to_string_internal("TABLE"),
+            SQLStatement::SQLDropView(drop) => drop.to_string_internal("VIEW"),
             SQLStatement::SQLAlterTable { name, operation } => {
                 format!("ALTER TABLE {} {}", name.to_string(), operation.to_string())
             }
@@ -608,3 +614,22 @@ impl FromStr for FileFormat {
         }
     }
 }
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct SQLDrop {
+    pub if_exists: bool,
+    pub names: Vec<SQLObjectName>,
+    pub cascade: bool,
+}
+
+impl SQLDrop {
+    fn to_string_internal(&self, object_type: &str) -> String {
+        format!(
+            "DROP {}{} {}{}",
+            object_type,
+            if self.if_exists { " IF EXISTS" } else { "" },
+            comma_separated_string(&self.names),
+            if self.cascade { " CASCADE" } else { "" },
+        )
+    }
+}

src/sqlparser.rs

@@ -97,6 +97,7 @@ impl Parser {
                         Ok(SQLStatement::SQLQuery(Box::new(self.parse_query()?)))
                     }
                     "CREATE" => Ok(self.parse_create()?),
+                    "DROP" => Ok(self.parse_drop()?),
                     "DELETE" => Ok(self.parse_delete()?),
                     "INSERT" => Ok(self.parse_insert()?),
                     "ALTER" => Ok(self.parse_alter()?),
@@ -738,6 +739,53 @@ impl Parser {
         })
     }
 
+    pub fn parse_drop(&mut self) -> Result<SQLStatement, ParserError> {
+        if self.parse_keyword("TABLE") {
+            self.parse_drop_table()
+        } else if self.parse_keyword("VIEW") {
+            self.parse_drop_view()
+        } else {
+            parser_err!(format!(
+                "Unexpected token after DROP: {:?}",
+                self.peek_token()
+            ))
+        }
+    }
+
+    pub fn parse_drop_table(&mut self) -> Result<SQLStatement, ParserError> {
+        Ok(SQLStatement::SQLDropTable(self.parse_drop_inner()?))
+    }
+
+    pub fn parse_drop_view(&mut self) -> Result<SQLStatement, ParserError> {
+        Ok(SQLStatement::SQLDropView(self.parse_drop_inner()?))
+    }
+
+    pub fn parse_drop_inner(&mut self) -> Result<SQLDrop, ParserError> {
+        let if_exists = self.parse_keywords(vec!["IF", "EXISTS"]);
+        let mut names = vec![self.parse_object_name()?];
+        loop {
+            let token = &self.next_token();
+            if let Some(Token::Comma) = token {
+                names.push(self.parse_object_name()?)
+            } else {
+                if token.is_some() {
+                    self.prev_token();
+                }
+                break;
+            }
+        }
+        let cascade = self.parse_keyword("CASCADE");
+        let restrict = self.parse_keyword("RESTRICT");
+        if cascade && restrict {
+            return parser_err!("Cannot specify both CASCADE and RESTRICT in DROP");
+        }
+        Ok(SQLDrop {
+            if_exists,
+            names,
+            cascade,
+        })
+    }
+
     pub fn parse_create_table(&mut self) -> Result<SQLStatement, ParserError> {
         let table_name = self.parse_object_name()?;
         // parse optional column list (schema)

tests/sqlparser_common.rs

@@ -1200,6 +1200,69 @@ fn parse_create_materialized_view() {
     }
 }
 
+#[test]
+fn parse_drop_table() {
+    let sql = "DROP TABLE foo";
+    match verified_stmt(sql) {
+        SQLStatement::SQLDropTable(SQLDrop {
+            if_exists,
+            names,
+            cascade,
+        }) => {
+            assert_eq!(false, if_exists);
+            assert_eq!(
+                vec!["foo"],
+                names.iter().map(|n| n.to_string()).collect::<Vec<_>>()
+            );
+            assert_eq!(false, cascade);
+        }
+        _ => assert!(false),
+    }
+
+    let sql = "DROP TABLE IF EXISTS foo, bar CASCADE";
+    match verified_stmt(sql) {
+        SQLStatement::SQLDropTable(SQLDrop {
+            if_exists,
+            names,
+            cascade,
+        }) => {
+            assert_eq!(true, if_exists);
+            assert_eq!(
+                vec!["foo", "bar"],
+                names.iter().map(|n| n.to_string()).collect::<Vec<_>>()
+            );
+            assert_eq!(true, cascade);
+        }
+        _ => assert!(false),
+    }
+
+    let sql = "DROP TABLE";
+    assert_eq!(
+        ParserError::ParserError("Expected identifier, found: EOF".to_string()),
+        parse_sql_statements(sql).unwrap_err(),
+    );
+
+    let sql = "DROP TABLE IF EXISTS foo, bar CASCADE RESTRICT";
+    assert_eq!(
+        ParserError::ParserError("Cannot specify both CASCADE and RESTRICT in DROP".to_string()),
+        parse_sql_statements(sql).unwrap_err(),
+    );
+}
+
+#[test]
+fn parse_drop_view() {
+    let sql = "DROP VIEW myschema.myview";
+    match verified_stmt(sql) {
+        SQLStatement::SQLDropView(SQLDrop { names, .. }) => {
+            assert_eq!(
+                vec!["myschema.myview"],
+                names.iter().map(|n| n.to_string()).collect::<Vec<_>>()
+            );
+        }
+        _ => assert!(false),
+    }
+}
+
 #[test]
 fn parse_invalid_subquery_without_parens() {
     let res = parse_sql_statements("SELECT SELECT 1 FROM bar WHERE 1=1 FROM baz");