update to use new framework in dbt-core in alignment with adap-608

Makefile

@@ -9,6 +9,7 @@ dev: ## Installs adapter in develop mode along with development dependencies
 dev-uninstall: ## Uninstalls all packages while maintaining the virtual environment
                ## Useful when updating versions, or if you accidentally installed into the system interpreter
 	pip freeze | grep -v "^-e" | cut -d "@" -f1 | xargs pip uninstall -y
+	pip uninstall -y dbt-snowflake
 
 .PHONY: mypy
 mypy: ## Runs mypy against staged changes for static type checking.

dbt/adapters/snowflake/impl.py

@@ -5,6 +5,7 @@
 
 from dbt.adapters.base.impl import AdapterConfig, ConstraintSupport  # type: ignore
 from dbt.adapters.base.meta import available
+from dbt.adapters.relation.factory import RelationFactory
 from dbt.adapters.sql import SQLAdapter  # type: ignore
 from dbt.adapters.sql.impl import (
     LIST_SCHEMAS_MACRO_NAME,
@@ -14,6 +15,7 @@
 from dbt.adapters.snowflake import SnowflakeConnectionManager
 from dbt.adapters.snowflake import SnowflakeRelation
 from dbt.adapters.snowflake import SnowflakeColumn
+from dbt.adapters.snowflake.relation import models as relation_models
 from dbt.contracts.graph.manifest import Manifest
 from dbt.contracts.graph.nodes import ConstraintType
 from dbt.exceptions import CompilationError, DbtDatabaseError, DbtRuntimeError
@@ -48,6 +50,23 @@ class SnowflakeAdapter(SQLAdapter):
         ConstraintType.foreign_key: ConstraintSupport.NOT_ENFORCED,
     }
 
+    @property
+    def relation_factory(self):
+        return RelationFactory(
+            relation_models={
+                relation_models.SnowflakeRelationType.DynamicTable: relation_models.SnowflakeDynamicTableRelation,
+            },
+            relation_changesets={
+                relation_models.SnowflakeRelationType.DynamicTable: relation_models.SnowflakeDynamicTableRelationChangeset,
+            },
+            relation_can_be_renamed={
+                relation_models.SnowflakeRelationType.DynamicTable,
+                relation_models.SnowflakeRelationType.Table,
+                relation_models.SnowflakeRelationType.View,
+            },
+            render_policy=relation_models.SnowflakeRenderPolicy,
+        )
+
     @classmethod
     def date_function(cls):
         return "CURRENT_TIMESTAMP()"

dbt/adapters/snowflake/relation/__init__.py

@@ -0,0 +1,34 @@
+from dataclasses import dataclass, field
+from typing import Optional, Type
+
+from dbt.adapters.base.relation import BaseRelation
+from dbt.utils import classproperty
+
+from dbt.adapters.snowflake.relation.models import (
+    SnowflakeIncludePolicy,
+    SnowflakeQuotePolicy,
+    SnowflakeRelationType,
+)
+
+
+@dataclass(frozen=True, eq=False, repr=False)
+class SnowflakeRelation(BaseRelation):
+    # we need to overwrite the type annotation for `type` so that mashumaro reads the class correctly
+    type: Optional[SnowflakeRelationType] = None  # type: ignore
+
+    include_policy: SnowflakeIncludePolicy = field(
+        default_factory=lambda: SnowflakeIncludePolicy()
+    )
+    quote_policy: SnowflakeQuotePolicy = field(default_factory=lambda: SnowflakeQuotePolicy())
+
+    @property
+    def is_dynamic_table(self) -> bool:
+        return self.type == SnowflakeRelationType.DynamicTable
+
+    @classproperty
+    def DynamicTable(cls) -> str:
+        return str(SnowflakeRelationType.DynamicTable)
+
+    @classproperty
+    def get_relation_type(cls) -> Type[SnowflakeRelationType]:
+        return SnowflakeRelationType

dbt/adapters/snowflake/relation/models/__init__.py

@@ -0,0 +1,17 @@
+from dbt.adapters.snowflake.relation.models.database import SnowflakeDatabaseRelation
+from dbt.adapters.snowflake.relation.models.dynamic_table import (
+    SnowflakeDynamicTableRelation,
+    SnowflakeDynamicTableRelationChangeset,
+    SnowflakeDynamicTableWarehouseRelationChange,
+)
+from dbt.adapters.snowflake.relation.models.policy import (
+    SnowflakeIncludePolicy,
+    SnowflakeQuotePolicy,
+    SnowflakeRelationType,
+    SnowflakeRenderPolicy,
+)
+from dbt.adapters.snowflake.relation.models.schema import SnowflakeSchemaRelation
+from dbt.adapters.snowflake.relation.models.target_lag import (
+    SnowflakeDynamicTableTargetLagRelation,
+    SnowflakeDynamicTableTargetLagRelationChange,
+)

dbt/adapters/snowflake/relation/models/database.py

@@ -0,0 +1,46 @@
+from dataclasses import dataclass
+from typing import Set
+
+from dbt.adapters.relation.models import DatabaseRelation
+from dbt.adapters.validation import ValidationMixin, ValidationRule
+from dbt.exceptions import DbtRuntimeError
+
+from dbt.adapters.snowflake.relation.models.policy import SnowflakeRenderPolicy
+
+
+@dataclass(frozen=True, eq=True, unsafe_hash=True)
+class SnowflakeDatabaseRelation(DatabaseRelation, ValidationMixin):
+    """
+    This config follow the specs found here:
+    https://docs.snowflake.com/en/sql-reference/sql/create-database
+
+    The following parameters are configurable by dbt:
+    - name: name of the database
+    """
+
+    # attribution
+    name: str
+
+    # configuration
+    render = SnowflakeRenderPolicy
+
+    @property
+    def fully_qualified_path(self) -> str:
+        return self.name
+
+    @property
+    def validation_rules(self) -> Set[ValidationRule]:
+        return {
+            ValidationRule(
+                validation_check=len(self.name or "") > 0,
+                validation_error=DbtRuntimeError(
+                    f"dbt-snowflake requires a name for a database, received: {self.name}"
+                ),
+            )
+        }
+
+    @classmethod
+    def from_dict(cls, config_dict) -> "SnowflakeDatabaseRelation":
+        database = super().from_dict(config_dict)
+        assert isinstance(database, SnowflakeDatabaseRelation)
+        return database