Snowflake: parse TRANSIENT DYNAMIC, bare TARGET_LAG=DOWNSTREAM, INITIALIZATION_WAREHOUSE, SCHEDULER, IMMUTABLE WHERE

Author: sabir-akhadov-localstack

src/ast/ddl.rs

@@ -3127,9 +3127,23 @@ pub struct CreateTable {
     /// Snowflake "TARGET_LAG" clause for dybamic tables
     /// <https://docs.snowflake.com/en/sql-reference/sql/create-dynamic-table>
     pub target_lag: Option<String>,
-    /// Snowflake "WAREHOUSE" clause for dybamic tables
+    /// Snowflake "WAREHOUSE" clause for dybamic tables. Stored verbatim (not
+    /// as an `Ident`) so the user's original casing survives — SHOW / GET_DDL
+    /// echo the warehouse exactly as written.
     /// <https://docs.snowflake.com/en/sql-reference/sql/create-dynamic-table>
-    pub warehouse: Option<Ident>,
+    pub warehouse: Option<String>,
+    /// Snowflake "INITIALIZATION_WAREHOUSE" clause for dynamic tables. Stored
+    /// verbatim for the same case-fidelity reason as `warehouse`.
+    /// <https://docs.snowflake.com/en/sql-reference/sql/create-dynamic-table>
+    pub initialization_warehouse: Option<String>,
+    /// Snowflake "SCHEDULER" clause for dynamic tables (a quoted string or a
+    /// bare keyword such as `DISABLE`); the value is stored verbatim.
+    /// <https://docs.snowflake.com/en/sql-reference/sql/create-dynamic-table>
+    pub scheduler: Option<String>,
+    /// Snowflake "IMMUTABLE WHERE (<predicate>)" clause for dynamic tables.
+    /// Stored as the serialized predicate text so its casing survives.
+    /// <https://docs.snowflake.com/en/sql-reference/sql/create-dynamic-table>
+    pub immutable_where: Option<String>,
     /// Snowflake "REFRESH_MODE" clause for dybamic tables
     /// <https://docs.snowflake.com/en/sql-reference/sql/create-dynamic-table>
     pub refresh_mode: Option<RefreshModeKind>,
@@ -3445,6 +3459,18 @@ impl fmt::Display for CreateTable {
             write!(f, " WAREHOUSE={warehouse}")?;
         }
 
+        if let Some(initialization_warehouse) = &self.initialization_warehouse {
+            write!(f, " INITIALIZATION_WAREHOUSE={initialization_warehouse}")?;
+        }
+
+        if let Some(scheduler) = &self.scheduler {
+            write!(f, " SCHEDULER='{scheduler}'")?;
+        }
+
+        if let Some(immutable_where) = &self.immutable_where {
+            write!(f, " IMMUTABLE WHERE ({immutable_where})")?;
+        }
+
         if let Some(refresh_mode) = &self.refresh_mode {
             write!(f, " REFRESH_MODE={refresh_mode}")?;
         }

src/ast/helpers/stmt_create_table.rs

@@ -171,8 +171,14 @@ pub struct CreateTableBuilder {
     pub table_options: CreateTableOptions,
     /// Optional target lag configuration.
     pub target_lag: Option<String>,
-    /// Optional warehouse identifier.
-    pub warehouse: Option<Ident>,
+    /// Optional warehouse name, stored verbatim.
+    pub warehouse: Option<String>,
+    /// Optional initialization warehouse name, stored verbatim.
+    pub initialization_warehouse: Option<String>,
+    /// Optional scheduler value (quoted string or bare keyword).
+    pub scheduler: Option<String>,
+    /// Optional `IMMUTABLE WHERE` predicate text.
+    pub immutable_where: Option<String>,
     /// Optional refresh mode for materialized tables.
     pub refresh_mode: Option<RefreshModeKind>,
     /// Optional initialization kind for the table.
@@ -247,6 +253,9 @@ impl CreateTableBuilder {
             table_options: CreateTableOptions::None,
             target_lag: None,
             warehouse: None,
+            initialization_warehouse: None,
+            scheduler: None,
+            immutable_where: None,
             refresh_mode: None,
             initialize: None,
             require_user: false,
@@ -522,11 +531,26 @@ impl CreateTableBuilder {
         self.target_lag = target_lag;
         self
     }
-    /// Associate the table with a warehouse identifier.
-    pub fn warehouse(mut self, warehouse: Option<Ident>) -> Self {
+    /// Associate the table with a warehouse name (stored verbatim).
+    pub fn warehouse(mut self, warehouse: Option<String>) -> Self {
         self.warehouse = warehouse;
         self
     }
+    /// Set the initialization warehouse name (stored verbatim).
+    pub fn initialization_warehouse(mut self, initialization_warehouse: Option<String>) -> Self {
+        self.initialization_warehouse = initialization_warehouse;
+        self
+    }
+    /// Set the scheduler value (quoted string or bare keyword).
+    pub fn scheduler(mut self, scheduler: Option<String>) -> Self {
+        self.scheduler = scheduler;
+        self
+    }
+    /// Set the `IMMUTABLE WHERE` predicate text.
+    pub fn immutable_where(mut self, immutable_where: Option<String>) -> Self {
+        self.immutable_where = immutable_where;
+        self
+    }
     /// Set refresh mode for materialized/managed tables.
     pub fn refresh_mode(mut self, refresh_mode: Option<RefreshModeKind>) -> Self {
         self.refresh_mode = refresh_mode;
@@ -619,6 +643,9 @@ impl CreateTableBuilder {
             table_options: self.table_options,
             target_lag: self.target_lag,
             warehouse: self.warehouse,
+            initialization_warehouse: self.initialization_warehouse,
+            scheduler: self.scheduler,
+            immutable_where: self.immutable_where,
             refresh_mode: self.refresh_mode,
             initialize: self.initialize,
             require_user: self.require_user,
@@ -702,6 +729,9 @@ impl From<CreateTable> for CreateTableBuilder {
             table_options: table.table_options,
             target_lag: table.target_lag,
             warehouse: table.warehouse,
+            initialization_warehouse: table.initialization_warehouse,
+            scheduler: table.scheduler,
+            immutable_where: table.immutable_where,
             refresh_mode: table.refresh_mode,
             initialize: table.initialize,
             require_user: table.require_user,

src/ast/spans.rs

@@ -656,6 +656,9 @@ impl Spanned for CreateTable {
             table_options,
             target_lag: _,
             warehouse: _,
+            initialization_warehouse: _,
+            scheduler: _,
+            immutable_where: _,
             version: _,
             refresh_mode: _,
             initialize: _,

src/dialect/snowflake.rs

@@ -431,13 +431,24 @@ impl Dialect for SnowflakeDialect {
                 _ => None,
             };
 
-            let dynamic = parser.parse_keyword(Keyword::DYNAMIC);
-
             let mut temporary = false;
             let mut volatile = false;
             let mut transient = false;
             let mut iceberg = false;
 
+            // Snowflake allows a leading `TRANSIENT` before `DYNAMIC`
+            // (`CREATE [OR REPLACE] [TRANSIENT] DYNAMIC [ICEBERG] TABLE`); the
+            // standalone `TRANSIENT` modifier for plain tables is still handled
+            // by the modifier group below.
+            let dynamic = if parser.parse_keyword(Keyword::DYNAMIC) {
+                true
+            } else if parser.parse_keywords(&[Keyword::TRANSIENT, Keyword::DYNAMIC]) {
+                transient = true;
+                true
+            } else {
+                false
+            };
+
             match parser.parse_one_of_keywords(&[
                 Keyword::TEMP,
                 Keyword::TEMPORARY,
@@ -1221,13 +1232,43 @@ pub fn parse_create_table(
                 }
                 Keyword::TARGET_LAG => {
                     parser.expect_token(&Token::Eq)?;
-                    let target_lag = parser.parse_literal_string()?;
+                    // TARGET_LAG accepts a quoted duration ('1 minute') or the
+                    // bare keyword DOWNSTREAM.
+                    let target_lag = if parser.parse_keyword(Keyword::DOWNSTREAM) {
+                        "DOWNSTREAM".to_string()
+                    } else {
+                        parser.parse_literal_string()?
+                    };
                     builder = builder.target_lag(Some(target_lag));
                 }
                 Keyword::WAREHOUSE => {
                     parser.expect_token(&Token::Eq)?;
                     let warehouse = parser.parse_identifier()?;
-                    builder = builder.warehouse(Some(warehouse));
+                    builder = builder.warehouse(Some(warehouse.value));
+                }
+                Keyword::INITIALIZATION_WAREHOUSE => {
+                    parser.expect_token(&Token::Eq)?;
+                    let warehouse = parser.parse_identifier()?;
+                    builder = builder.initialization_warehouse(Some(warehouse.value));
+                }
+                Keyword::SCHEDULER => {
+                    parser.expect_token(&Token::Eq)?;
+                    // SCHEDULER accepts a quoted string ('DISABLE') or a bare
+                    // keyword (the GET_DDL spelling, e.g. DISABLE).
+                    let value_token = parser.next_token();
+                    let scheduler = match &value_token.token {
+                        Token::SingleQuotedString(s) => s.clone(),
+                        Token::Word(w) => w.value.clone(),
+                        _ => return parser.expected("a scheduler value", value_token),
+                    };
+                    builder = builder.scheduler(Some(scheduler));
+                }
+                Keyword::IMMUTABLE => {
+                    parser.expect_keyword_is(Keyword::WHERE)?;
+                    parser.expect_token(&Token::LParen)?;
+                    let predicate = parser.parse_expr()?;
+                    parser.expect_token(&Token::RParen)?;
+                    builder = builder.immutable_where(Some(predicate.to_string()));
                 }
                 Keyword::AT | Keyword::BEFORE => {
                     parser.prev_token();

src/keywords.rs

@@ -545,6 +545,7 @@ define_keywords!(
     INDICATOR,
     INHERIT,
     INHERITS,
+    INITIALIZATION_WAREHOUSE,
     INITIALIZE,
     INITIALLY,
     INNER,
@@ -965,6 +966,7 @@ define_keywords!(
     SAMPLE,
     SAVEPOINT,
     SCHEDULE,
+    SCHEDULER,
     SCHEMA,
     SCHEMAS,
     SCOPE,

tests/sqlparser_snowflake.rs

@@ -1366,6 +1366,47 @@ fn parse_create_dynamic_table() {
     ));
 }
 
+#[test]
+fn parse_create_dynamic_table_snowflake_clauses() {
+    // Leading TRANSIENT, bare TARGET_LAG = DOWNSTREAM, INITIALIZATION_WAREHOUSE,
+    // SCHEDULER (quoted + bare), and IMMUTABLE WHERE all carry their values in
+    // the AST.
+    let sql = concat!(
+        "CREATE OR REPLACE TRANSIENT DYNAMIC TABLE t",
+        " TARGET_LAG='1 minute'",
+        " WAREHOUSE=my_wh",
+        " INITIALIZATION_WAREHOUSE=init_wh",
+        " SCHEDULER='DISABLE'",
+        " IMMUTABLE WHERE (id > 5)",
+        " AS SELECT id FROM staging_table"
+    );
+    match snowflake().verified_stmt(sql) {
+        Statement::CreateTable(ct) => {
+            assert!(ct.transient);
+            assert!(ct.dynamic);
+            assert!(ct.or_replace);
+            assert_eq!(Some("1 minute".to_string()), ct.target_lag);
+            assert_eq!(Some("my_wh".to_string()), ct.warehouse);
+            assert_eq!(Some("init_wh".to_string()), ct.initialization_warehouse);
+            assert_eq!(Some("DISABLE".to_string()), ct.scheduler);
+            assert_eq!(Some("id > 5".to_string()), ct.immutable_where);
+        }
+        other => panic!("expected CreateTable, got {other:?}"),
+    }
+
+    // Bare TARGET_LAG = DOWNSTREAM and bare SCHEDULER value.
+    match snowflake().one_statement_parses_to(
+        "CREATE DYNAMIC TABLE t TARGET_LAG=DOWNSTREAM WAREHOUSE=wh SCHEDULER=disable AS SELECT id FROM s",
+        "CREATE DYNAMIC TABLE t TARGET_LAG='DOWNSTREAM' WAREHOUSE=wh SCHEDULER='disable' AS SELECT id FROM s",
+    ) {
+        Statement::CreateTable(ct) => {
+            assert_eq!(Some("DOWNSTREAM".to_string()), ct.target_lag);
+            assert_eq!(Some("disable".to_string()), ct.scheduler);
+        }
+        other => panic!("expected CreateTable, got {other:?}"),
+    }
+}
+
 #[test]
 fn test_sf_derived_table_in_parenthesis() {
     // Nesting a subquery in an extra set of parentheses is non-standard,