Dynamic Table testing improvements

dbt/adapters/snowflake/impl.py

@@ -258,28 +258,20 @@ def list_relations_without_caching(
                 return []
             raise
 
-        # this can be reduced to always including `is_dynamic` once bundle `2024_03` is mandatory
-        columns = ["database_name", "schema_name", "name", "kind"]
-        if "is_dynamic" in schema_objects.column_names:
-            columns.append("is_dynamic")
-        if "is_iceberg" in schema_objects.column_names:
+        # this can be collapsed once Snowflake adds is_iceberg to show objects
+        columns = ["database_name", "schema_name", "name", "kind", "is_dynamic"]
+        if self.behavior.enable_iceberg_materializations.no_warn:
             columns.append("is_iceberg")
 
         return [self._parse_list_relations_result(obj) for obj in schema_objects.select(columns)]
 
     def _parse_list_relations_result(self, result: "agate.Row") -> SnowflakeRelation:
-        # this can be reduced to always including `is_dynamic` once bundle `2024_03` is mandatory
-        # this can be reduced to always including `is_iceberg` once Snowflake adds it to show objects
-        try:
-            if self.behavior.enable_iceberg_materializations.no_warn:
-                database, schema, identifier, relation_type, is_dynamic, is_iceberg = result
-            else:
-                database, schema, identifier, relation_type, is_dynamic = result
-        except ValueError:
-            database, schema, identifier, relation_type = result
-            is_dynamic = "N"
-            if self.behavior.enable_iceberg_materializations.no_warn:
-                is_iceberg = "N"
+        # this can be collapsed once Snowflake adds is_iceberg to show objects
+        if self.behavior.enable_iceberg_materializations.no_warn:
+            database, schema, identifier, relation_type, is_dynamic, is_iceberg = result
+        else:
+            database, schema, identifier, relation_type, is_dynamic = result
+            is_iceberg = "N"
 
         try:
             relation_type = self.Relation.get_relation_type(relation_type.lower())
@@ -289,13 +281,8 @@ def _parse_list_relations_result(self, result: "agate.Row") -> SnowflakeRelation
         if relation_type == self.Relation.Table and is_dynamic == "Y":
             relation_type = self.Relation.DynamicTable
 
-        # This line is the main gate on supporting Iceberg materializations. Pass forward a default
-        # table format, and no downstream table macros can build iceberg relations.
-        table_format: str = (
-            TableFormat.ICEBERG
-            if self.behavior.enable_iceberg_materializations.no_warn and is_iceberg in ("Y", "YES")
-            else TableFormat.DEFAULT
-        )
+        table_format = TableFormat.ICEBERG if is_iceberg in ("Y", "YES") else TableFormat.DEFAULT
+
         quote_policy = {"database": True, "schema": True, "identifier": True}
 
         return self.Relation.create(

dbt/adapters/snowflake/relation_configs/__init__.py

@@ -5,9 +5,9 @@
     SnowflakeDynamicTableWarehouseConfigChange,
     SnowflakeDynamicTableTargetLagConfigChange,
 )
+from dbt.adapters.snowflake.relation_configs.formats import TableFormat
 from dbt.adapters.snowflake.relation_configs.policies import (
     SnowflakeIncludePolicy,
     SnowflakeQuotePolicy,
     SnowflakeRelationType,
 )
-from dbt.adapters.snowflake.relation_configs.formats import TableFormat

dbt/adapters/snowflake/relation_configs/dynamic_table.py

@@ -9,6 +9,7 @@
 
 from dbt.adapters.snowflake.relation_configs.base import SnowflakeRelationConfigBase
 
+
 if TYPE_CHECKING:
     import agate
 
@@ -59,7 +60,7 @@ class SnowflakeDynamicTableConfig(SnowflakeRelationConfigBase):
     initialize: Optional[Initialize] = Initialize.default()
 
     @classmethod
-    def from_dict(cls, config_dict) -> "SnowflakeDynamicTableConfig":
+    def from_dict(cls, config_dict: Dict[str, Any]) -> Self:
         kwargs_dict = {
             "name": cls._render_part(ComponentName.Identifier, config_dict.get("name")),
             "schema_name": cls._render_part(ComponentName.Schema, config_dict.get("schema_name")),
@@ -73,8 +74,7 @@ def from_dict(cls, config_dict) -> "SnowflakeDynamicTableConfig":
             "initialize": config_dict.get("initialize"),
         }
 
-        dynamic_table: "SnowflakeDynamicTableConfig" = super().from_dict(kwargs_dict)
-        return dynamic_table
+        return super().from_dict(kwargs_dict)
 
     @classmethod
     def parse_relation_config(cls, relation_config: RelationConfig) -> Dict[str, Any]:
@@ -96,7 +96,7 @@ def parse_relation_config(cls, relation_config: RelationConfig) -> Dict[str, Any
         return config_dict
 
     @classmethod
-    def parse_relation_results(cls, relation_results: RelationResults) -> Dict:
+    def parse_relation_results(cls, relation_results: RelationResults) -> Dict[str, Any]:
         dynamic_table: "agate.Row" = relation_results["dynamic_table"].rows[0]
 
         config_dict = {

dbt/adapters/snowflake/relation_configs/formats.py

@@ -1,4 +1,5 @@
 from dbt_common.dataclass_schema import StrEnum  # doesn't exist in standard library until py3.11
+from typing_extensions import Self
 
 
 class TableFormat(StrEnum):
@@ -10,5 +11,9 @@ class TableFormat(StrEnum):
     DEFAULT = "default"
     ICEBERG = "iceberg"
 
+    @classmethod
+    def default(cls) -> Self:
+        return cls("default")
+
     def __str__(self):
         return self.value

dbt/include/snowflake/macros/relations/dynamic_table/create.sql

@@ -1,18 +1,14 @@
 {% macro snowflake__get_create_dynamic_table_as_sql(relation, sql) -%}
 
-    {%- set dynamic_table = relation.from_config(config.model) -%}
+{%- set dynamic_table = relation.from_config(config.model) -%}
 
-    create dynamic table {{ relation }}
-        target_lag = '{{ dynamic_table.target_lag }}'
-        warehouse = {{ dynamic_table.snowflake_warehouse }}
-        {% if dynamic_table.refresh_mode %}
-        refresh_mode = {{ dynamic_table.refresh_mode }}
-        {% endif %}
-        {% if dynamic_table.initialize %}
-        initialize = {{ dynamic_table.initialize }}
-        {% endif %}
-        as (
-            {{ sql }}
-        )
+create dynamic table {{ relation }}
+    target_lag = '{{ dynamic_table.target_lag }}'
+    warehouse = {{ dynamic_table.snowflake_warehouse }}
+    {{ optional('refresh_mode', dynamic_table.refresh_mode) }}
+    {{ optional('initialize', dynamic_table.initialize) }}
+    as (
+        {{ sql }}
+    )
 
 {%- endmacro %}

dbt/include/snowflake/macros/relations/dynamic_table/describe.sql

@@ -1,20 +1,20 @@
 {% macro snowflake__describe_dynamic_table(relation) %}
-    {%- set _dynamic_table_sql -%}
-        show dynamic tables
-            like '{{ relation.identifier }}'
-            in schema {{ relation.database }}.{{ relation.schema }}
-        ;
-        select
-            "name",
-            "schema_name",
-            "database_name",
-            "text",
-            "target_lag",
-            "warehouse",
-            "refresh_mode"
-        from table(result_scan(last_query_id()))
-    {%- endset %}
-    {% set _dynamic_table = run_query(_dynamic_table_sql) %}
+{%- set _dynamic_table_sql -%}
+show dynamic tables
+    like '{{ relation.identifier }}'
+    in schema {{ relation.database }}.{{ relation.schema }}
+;
+select
+    "name",
+    "schema_name",
+    "database_name",
+    "text",
+    "target_lag",
+    "warehouse",
+    "refresh_mode"
+from table(result_scan(last_query_id()))
+{%- endset %}
+{% set _dynamic_table = run_query(_dynamic_table_sql) %}
 
-    {% do return({'dynamic_table': _dynamic_table}) %}
+{% do return({'dynamic_table': _dynamic_table}) %}
 {% endmacro %}

dbt/include/snowflake/macros/relations/dynamic_table/replace.sql

@@ -1,18 +1,14 @@
 {% macro snowflake__get_replace_dynamic_table_sql(relation, sql) -%}
 
-    {%- set dynamic_table = relation.from_config(config.model) -%}
+{%- set dynamic_table = relation.from_config(config.model) -%}
 
-    create or replace dynamic table {{ relation }}
-        target_lag = '{{ dynamic_table.target_lag }}'
-        warehouse = {{ dynamic_table.snowflake_warehouse }}
-        {% if dynamic_table.refresh_mode %}
-        refresh_mode = {{ dynamic_table.refresh_mode }}
-        {% endif %}
-        {% if dynamic_table.initialize %}
-        initialize = {{ dynamic_table.initialize }}
-        {% endif %}
-        as (
-            {{ sql }}
-        )
+create or replace dynamic table {{ relation }}
+    target_lag = '{{ dynamic_table.target_lag }}'
+    warehouse = {{ dynamic_table.snowflake_warehouse }}
+    {{ optional('refresh_mode', dynamic_table.refresh_mode) }}
+    {{ optional('initialize', dynamic_table.initialize) }}
+    as (
+        {{ sql }}
+    )
 
 {%- endmacro %}

dbt/include/snowflake/macros/utils/optional.sql

@@ -0,0 +1,3 @@
+{% macro optional(name, value, quote_char = '') %}
+{% if value is not none %}{{ name }} = {{ quote_char }}{{ value }}{{ quote_char }}{% endif %}
+{% endmacro %}