sql-parser: support for replacement materialized views

Author: teskje

src/adapter/src/coord/command_handler.rs

@@ -929,6 +929,7 @@ impl Coordinator {
                     | Statement::AlterConnection(_)
                     | Statement::AlterDefaultPrivileges(_)
                     | Statement::AlterIndex(_)
+                    | Statement::AlterMaterializedViewApplyReplacement(_)
                     | Statement::AlterSetCluster(_)
                     | Statement::AlterOwner(_)
                     | Statement::AlterRetainHistory(_)
@@ -1170,6 +1171,7 @@ impl Coordinator {
                         if_exists: cmvs.if_exists,
                         name: cmvs.name,
                         columns: cmvs.columns,
+                        replacing: cmvs.replacing,
                         in_cluster: cmvs.in_cluster,
                         query: cmvs.query,
                         with_options: cmvs.with_options,

src/sql-lexer/src/keywords.txt

@@ -40,6 +40,7 @@ Analysis
 Analyze
 And
 Any
+Apply
 Arity
 Arn
 Arranged
@@ -390,6 +391,8 @@ Rename
 Reoptimize
 Repeatable
 Replace
+Replacement
+Replacing
 Replan
 Replica
 Replicas

src/sql-parser/src/ast/defs/statement.rs

@@ -82,6 +82,7 @@ pub enum Statement<T: AstInfo> {
     AlterNetworkPolicy(AlterNetworkPolicyStatement<T>),
     AlterRole(AlterRoleStatement<T>),
     AlterTableAddColumn(AlterTableAddColumnStatement<T>),
+    AlterMaterializedViewApplyReplacement(AlterMaterializedViewApplyReplacementStatement),
     Discard(DiscardStatement),
     DropObjects(DropObjectsStatement),
     DropOwned(DropOwnedStatement<T>),
@@ -160,6 +161,7 @@ impl<T: AstInfo> AstDisplay for Statement<T> {
             Statement::AlterConnection(stmt) => f.write_node(stmt),
             Statement::AlterRole(stmt) => f.write_node(stmt),
             Statement::AlterTableAddColumn(stmt) => f.write_node(stmt),
+            Statement::AlterMaterializedViewApplyReplacement(stmt) => f.write_node(stmt),
             Statement::Discard(stmt) => f.write_node(stmt),
             Statement::DropObjects(stmt) => f.write_node(stmt),
             Statement::DropOwned(stmt) => f.write_node(stmt),
@@ -241,6 +243,9 @@ pub fn statement_kind_label_value(kind: StatementKind) -> &'static str {
         StatementKind::AlterOwner => "alter_owner",
         StatementKind::AlterConnection => "alter_connection",
         StatementKind::AlterTableAddColumn => "alter_table",
+        StatementKind::AlterMaterializedViewApplyReplacement => {
+            "alter_materialized_view_apply_replacement"
+        }
         StatementKind::Discard => "discard",
         StatementKind::DropObjects => "drop_objects",
         StatementKind::DropOwned => "drop_owned",
@@ -1382,6 +1387,7 @@ pub struct CreateMaterializedViewStatement<T: AstInfo> {
     pub if_exists: IfExistsBehavior,
     pub name: UnresolvedItemName,
     pub columns: Vec<Ident>,
+    pub replacing: Option<T::ItemName>,
     pub in_cluster: Option<T::ClusterName>,
     pub query: Query<T>,
     pub as_of: Option<u64>,
@@ -1410,6 +1416,11 @@ impl<T: AstInfo> AstDisplay for CreateMaterializedViewStatement<T> {
             f.write_str(")");
         }
 
+        if let Some(target) = &self.replacing {
+            f.write_str(" REPLACING ");
+            f.write_node(target);
+        }
+
         if let Some(cluster) = &self.in_cluster {
             f.write_str(" IN CLUSTER ");
             f.write_node(cluster);
@@ -3199,6 +3210,32 @@ impl<T: AstInfo> AstDisplay for AlterTableAddColumnStatement<T> {
 
 impl_display_t!(AlterTableAddColumnStatement);
 
+/// `ALTER MATERIALIZED VIEW ... APPLY REPLACEMENT ...`
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct AlterMaterializedViewApplyReplacementStatement {
+    pub if_exists: bool,
+    pub name: UnresolvedItemName,
+    pub replacement_name: UnresolvedItemName,
+}
+
+impl AstDisplay for AlterMaterializedViewApplyReplacementStatement {
+    fn fmt<W>(&self, f: &mut AstFormatter<W>)
+    where
+        W: fmt::Write,
+    {
+        f.write_str("ALTER MATERIALIZED VIEW ");
+        if self.if_exists {
+            f.write_str("IF EXISTS ");
+        }
+        f.write_node(&self.name);
+
+        f.write_str(" APPLY REPLACEMENT ");
+        f.write_node(&self.replacement_name);
+    }
+}
+
+impl_display!(AlterMaterializedViewApplyReplacementStatement);
+
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct DiscardStatement {
     pub target: DiscardTarget,

src/sql-parser/src/parser.rs

@@ -3862,6 +3862,10 @@ impl<'a> Parser<'a> {
 
         let name = self.parse_item_name()?;
         let columns = self.parse_parenthesized_column_list(Optional)?;
+        let replacing = self
+            .parse_keyword(REPLACING)
+            .then(|| self.parse_raw_name())
+            .transpose()?;
         let in_cluster = self.parse_optional_in_cluster()?;
 
         let with_options = if self.parse_keyword(WITH) {
@@ -3882,6 +3886,7 @@ impl<'a> Parser<'a> {
                 if_exists,
                 name,
                 columns,
+                replacing,
                 in_cluster,
                 query,
                 as_of,
@@ -6432,10 +6437,10 @@ impl<'a> Parser<'a> {
     ) -> Result<Statement<Raw>, ParserStatementError> {
         let if_exists = self.parse_if_exists().map_no_statement_parser_err()?;
         let name = self.parse_item_name().map_no_statement_parser_err()?;
-        let keywords = if object_type == ObjectType::Table {
-            [SET, RENAME, OWNER, RESET, ADD].as_slice()
-        } else {
-            [SET, RENAME, OWNER, RESET].as_slice()
+        let keywords: &[_] = match object_type {
+            ObjectType::Table => &[SET, RENAME, OWNER, RESET, ADD],
+            ObjectType::MaterializedView => &[SET, RENAME, OWNER, RESET, APPLY],
+            _ => &[SET, RENAME, OWNER, RESET],
         };
 
         let action = self
@@ -6526,6 +6531,28 @@ impl<'a> Parser<'a> {
                     },
                 ))
             }
+            APPLY => {
+                assert_eq!(
+                    object_type,
+                    ObjectType::MaterializedView,
+                    "checked object_type above",
+                );
+
+                self.expect_keyword(REPLACEMENT)
+                    .map_parser_err(StatementKind::AlterMaterializedViewApplyReplacement)?;
+
+                let replacement_name = self
+                    .parse_item_name()
+                    .map_parser_err(StatementKind::AlterMaterializedViewApplyReplacement)?;
+
+                Ok(Statement::AlterMaterializedViewApplyReplacement(
+                    AlterMaterializedViewApplyReplacementStatement {
+                        if_exists,
+                        name,
+                        replacement_name,
+                    },
+                ))
+            }
             _ => unreachable!(),
         }
     }

src/sql-parser/tests/testdata/alter

@@ -131,3 +131,17 @@ ALTER TABLE IF EXISTS t1 ADD COLUMN IF NOT EXISTS bar text
 ALTER TABLE IF EXISTS t1 ADD COLUMN IF NOT EXISTS bar text
 =>
 AlterTableAddColumn(AlterTableAddColumnStatement { if_exists: true, name: UnresolvedItemName([Ident("t1")]), if_col_not_exist: true, column_name: Ident("bar"), data_type: Other { name: Name(UnresolvedItemName([Ident("text")])), typ_mod: [] } })
+
+parse-statement
+ALTER MATERIALIZED VIEW mv APPLY REPLACEMENT rpl
+----
+ALTER MATERIALIZED VIEW mv APPLY REPLACEMENT rpl
+=>
+AlterMaterializedViewApplyReplacement(AlterMaterializedViewApplyReplacementStatement { if_exists: false, name: UnresolvedItemName([Ident("mv")]), replacement_name: UnresolvedItemName([Ident("rpl")]) })
+
+parse-statement
+ALTER MATERIALIZED VIEW IF EXISTS mv APPLY REPLACEMENT rpl
+----
+ALTER MATERIALIZED VIEW IF EXISTS mv APPLY REPLACEMENT rpl
+=>
+AlterMaterializedViewApplyReplacement(AlterMaterializedViewApplyReplacementStatement { if_exists: true, name: UnresolvedItemName([Ident("mv")]), replacement_name: UnresolvedItemName([Ident("rpl")]) })