Add RelationConfig Protocol for use in Relation.create_from

.changes/unreleased/Under the Hood-20231205-170725.yaml

@@ -0,0 +1,6 @@
+kind: Under the Hood
+body: Introduce RelationConfig Protocol, consolidate Relation.create_from
+time: 2023-12-05T17:07:25.33861+09:00
+custom:
+  Author: michelleark
+  Issue: "9215"

core/dbt/adapters/base/impl.py

@@ -423,7 +423,7 @@ def _get_cache_schemas(self, manifest: Manifest) -> Set[BaseRelation]:
         """
         # the cache only cares about executable nodes
         return {
-            self.Relation.create_from(self.config, node).without_identifier()
+            self.Relation.create_from(self.config, node).without_identifier()  # type: ignore[arg-type]
             for node in manifest.nodes.values()
             if (node.is_relational and not node.is_ephemeral_model and not node.is_external_node)
         }
@@ -470,7 +470,7 @@ def _get_catalog_relations(self, manifest: Manifest) -> List[BaseRelation]:
             manifest.sources.values(),
         )
 
-        relations = [self.Relation.create_from(self.config, n) for n in nodes]
+        relations = [self.Relation.create_from(self.config, n) for n in nodes]  # type: ignore[arg-type]
         return relations
 
     def _relations_cache_for_schemas(

core/dbt/adapters/base/relation.py

@@ -2,18 +2,16 @@
 from dataclasses import dataclass, field
 from typing import Optional, TypeVar, Any, Type, Dict, Iterator, Tuple, Set, Union, FrozenSet
 
-from dbt.contracts.graph.nodes import SourceDefinition, ManifestNode, ResultNode, ParsedNode
 from dbt.adapters.contracts.relation import (
+    RelationConfig,
     RelationType,
     ComponentName,
     HasQuoting,
     FakeAPIObject,
     Policy,
     Path,
 )
-from dbt.common.exceptions import DbtInternalError
 from dbt.adapters.exceptions import MultipleDatabasesNotAllowedError, ApproximateMatchError
-from dbt.node_types import NodeType
 from dbt.common.utils import filter_null_values, deep_merge
 from dbt.adapters.utils import classproperty
 
@@ -198,83 +196,50 @@ def quoted(self, identifier):
             identifier=identifier,
         )
 
-    @classmethod
-    def create_from_source(cls: Type[Self], source: SourceDefinition, **kwargs: Any) -> Self:
-        source_quoting = source.quoting.to_dict(omit_none=True)
-        source_quoting.pop("column", None)
-        quote_policy = deep_merge(
-            cls.get_default_quote_policy().to_dict(omit_none=True),
-            source_quoting,
-            kwargs.get("quote_policy", {}),
-        )
-
-        return cls.create(
-            database=source.database,
-            schema=source.schema,
-            identifier=source.identifier,
-            quote_policy=quote_policy,
-            **kwargs,
-        )
-
     @staticmethod
     def add_ephemeral_prefix(name: str):
         return f"__dbt__cte__{name}"
 
     @classmethod
-    def create_ephemeral_from_node(
+    def create_ephemeral_from(
         cls: Type[Self],
-        config: HasQuoting,
-        node: ManifestNode,
+        relation_config: RelationConfig,
     ) -> Self:
         # Note that ephemeral models are based on the name.
-        identifier = cls.add_ephemeral_prefix(node.name)
+        identifier = cls.add_ephemeral_prefix(relation_config.name)
         return cls.create(
             type=cls.CTE,
             identifier=identifier,
         ).quote(identifier=False)
 
     @classmethod
-    def create_from_node(
+    def create_from(
         cls: Type[Self],
-        config: HasQuoting,
-        node,
-        quote_policy: Optional[Dict[str, bool]] = None,
+        quoting: HasQuoting,
+        relation_config: RelationConfig,
         **kwargs: Any,
     ) -> Self:
-        if quote_policy is None:
-            quote_policy = {}
+        quote_policy = kwargs.pop("quote_policy", {})
+
+        config_quoting = relation_config.quoting_dict
+        config_quoting.pop("column", None)
 
-        quote_policy = dbt.common.utils.merge(config.quoting, quote_policy)
+        # precedence: kwargs quoting > relation config quoting > base quoting > default quoting
+        quote_policy = deep_merge(
+            cls.get_default_quote_policy().to_dict(omit_none=True),
+            quoting.quoting,
+            config_quoting,
+            quote_policy,
+        )
 
         return cls.create(
-            database=node.database,
-            schema=node.schema,
-            identifier=node.alias,
+            database=relation_config.database,
+            schema=relation_config.schema,
+            identifier=relation_config.identifier,
             quote_policy=quote_policy,
             **kwargs,
         )
 
-    @classmethod
-    def create_from(
-        cls: Type[Self],
-        config: HasQuoting,
-        node: ResultNode,
-        **kwargs: Any,
-    ) -> Self:
-        if node.resource_type == NodeType.Source:
-            if not isinstance(node, SourceDefinition):
-                raise DbtInternalError(
-                    "type mismatch, expected SourceDefinition but got {}".format(type(node))
-                )
-            return cls.create_from_source(node, **kwargs)
-        else:
-            # Can't use ManifestNode here because of parameterized generics
-            if not isinstance(node, (ParsedNode)):
-                raise DbtInternalError(
-                    f"type mismatch, expected ManifestNode but got {type(node)}"
-                )
-            return cls.create_from_node(config, node, **kwargs)
-
     @classmethod
     def create(
         cls: Type[Self],

core/dbt/adapters/contracts/relation.py

@@ -22,6 +22,14 @@ class RelationType(StrEnum):
     Ephemeral = "ephemeral"
 
 
+class RelationConfig(Protocol):
+    name: str
+    database: str
+    schema: str
+    identifier: str
+    quoting_dict: Dict[str, bool]
+
+
 class ComponentName(StrEnum):
     Database = "database"
     Schema = "schema"

core/dbt/adapters/protocol.py

@@ -1,21 +1,11 @@
 from dataclasses import dataclass
-from typing import (
-    Type,
-    Hashable,
-    Optional,
-    ContextManager,
-    List,
-    Generic,
-    TypeVar,
-    Tuple,
-)
+from typing import Type, Hashable, Optional, ContextManager, List, Generic, TypeVar, Tuple, Any
 from typing_extensions import Protocol
 
 import agate
 
 from dbt.adapters.contracts.connection import Connection, AdapterRequiredConfig, AdapterResponse
-from dbt.adapters.contracts.relation import Policy, HasQuoting
-from dbt.contracts.graph.nodes import ResultNode
+from dbt.adapters.contracts.relation import Policy, HasQuoting, RelationConfig
 from dbt.contracts.graph.model_config import BaseConfig
 from dbt.contracts.graph.manifest import Manifest
 
@@ -42,7 +32,9 @@ def get_default_quote_policy(cls) -> Policy:
         ...
 
     @classmethod
-    def create_from(cls: Type[Self], config: HasQuoting, node: ResultNode) -> Self:
+    def create_from(
+        cls: Type[Self], quoting: HasQuoting, relation_config: RelationConfig, **kwargs: Any
+    ) -> Self:
         ...
 
 

core/dbt/context/providers.py

@@ -89,11 +89,6 @@ def __init__(self, adapter):
     def __getattr__(self, key):
         return getattr(self._relation_type, key)
 
-    def create_from_source(self, *args, **kwargs):
-        # bypass our create when creating from source so as not to mess up
-        # the source quoting
-        return self._relation_type.create_from_source(*args, **kwargs)
-
     def create(self, *args, **kwargs):
         kwargs["quote_policy"] = merge(self._quoting_config, kwargs.pop("quote_policy", {}))
         return self._relation_type.create(*args, **kwargs)
@@ -529,7 +524,7 @@ def resolve(
     def create_relation(self, target_model: ManifestNode) -> RelationProxy:
         if target_model.is_ephemeral_model:
             self.model.set_cte(target_model.unique_id, None)
-            return self.Relation.create_ephemeral_from_node(self.config, target_model)
+            return self.Relation.create_ephemeral_from(target_model)
         else:
             return self.Relation.create_from(self.config, target_model)
 
@@ -588,7 +583,7 @@ def resolve(self, source_name: str, table_name: str):
                 target_kind="source",
                 disabled=(isinstance(target_source, Disabled)),
             )
-        return self.Relation.create_from_source(target_source)
+        return self.Relation.create_from(self.config, target_source)
 
 
 # metric` implementations
@@ -1475,7 +1470,7 @@ def defer_relation(self) -> Optional[RelationProxy]:
         object for that stateful other
         """
         if getattr(self.model, "defer_relation", None):
-            return self.db_wrapper.Relation.create_from_node(
+            return self.db_wrapper.Relation.create_from(
                 self.config, self.model.defer_relation  # type: ignore
             )
         else:

core/dbt/contracts/graph/nodes.py

@@ -219,6 +219,13 @@ def __pre_deserialize__(cls, data):
             data["database"] = None
         return data
 
+    @property
+    def quoting_dict(self) -> Dict[str, bool]:
+        if hasattr(self, "quoting"):
+            return self.quoting.to_dict(omit_none=True)
+        else:
+            return {}
+
 
 @dataclass
 class MacroDependsOn(dbtClassMixin, Replaceable):

core/dbt/parser/manifest.py

@@ -1357,7 +1357,7 @@ def _check_resource_uniqueness(
 
         # the full node name is really defined by the adapter's relation
         relation_cls = get_relation_class_by_name(config.credentials.type)
-        relation = relation_cls.create_from(config=config, node=node)
+        relation = relation_cls.create_from(quoting=config, relation_config=node)  # type: ignore[arg-type]
         full_node_name = str(relation)
 
         existing_alias = alias_resources.get(full_node_name)

core/dbt/task/clone.py

@@ -108,7 +108,7 @@
 
                 # cache the 'other' schemas too!
                 if node.defer_relation:  # type: ignore
-                    other_relation = adapter.Relation.create_from_node(
+                    other_relation = adapter.Relation.create_from(
                         self.config, node.defer_relation  # type: ignore
                     )
                     result.add(other_relation.without_identifier())

core/dbt/task/freshness.py

@@ -99,7 +99,7 @@ def from_run_result(self, result, start_time, timing_info):
         return result
 
     def execute(self, compiled_node, manifest):
-        relation = self.adapter.Relation.create_from_source(compiled_node)
+        relation = self.adapter.Relation.create_from(self.config, compiled_node)
         # given a Source, calculate its freshness.
         with self.adapter.connection_named(compiled_node.unique_id, compiled_node):
             self.adapter.clear_transaction()