remove manifest from adapter.set_relations_cache signature

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

@@ -0,0 +1,6 @@
+kind: Under the Hood
+body: Remove usage of dbt.contracts in dbt/adapters
+time: 2023-12-05T12:05:59.936775+09:00
+custom:
+  Author: michelleark
+  Issue: "9208"

.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"

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

@@ -0,0 +1,6 @@
+kind: Under the Hood
+body: remove manifest from adapter.set_relations_cache signature
+time: 2023-12-05T23:58:30.920144+09:00
+custom:
+  Author: michelleark
+  Issue: "9217"

core/dbt/adapters/base/impl.py

@@ -76,6 +76,7 @@
 )
 from dbt.common.utils import filter_null_values, executor, cast_to_str, AttrDict
 
+from dbt.adapters.contracts.relation import RelationConfig
 from dbt.adapters.base.connections import Connection, AdapterResponse, BaseConnectionManager
 from dbt.adapters.base.meta import AdapterMeta, available
 from dbt.adapters.base.relation import (
@@ -423,15 +424,13 @@ def _schema_is_cached(self, database: Optional[str], schema: str) -> bool:
         else:
             return True
 
-    def _get_cache_schemas(self, manifest: Manifest) -> Set[BaseRelation]:
+    def _get_cache_schemas(self, relation_configs: Iterable[RelationConfig]) -> Set[BaseRelation]:
         """Get the set of schema relations that the cache logic needs to
-        populate. This means only executable nodes are included.
+        populate.
         """
-        # the cache only cares about executable nodes
         return {
-            self.Relation.create_from(self.config, node).without_identifier()
-            for node in manifest.nodes.values()
-            if (node.is_relational and not node.is_ephemeral_model and not node.is_external_node)
+            self.Relation.create_from(quoting=self.config, config=relation_config)
+            for relation_config in relation_configs
         }
 
     def _get_catalog_schemas(self, manifest: Manifest) -> SchemaSearchMap:
@@ -476,17 +475,19 @@ 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(
-        self, manifest: Manifest, cache_schemas: Optional[Set[BaseRelation]] = None
+        self,
+        relation_configs: Iterable[RelationConfig],
+        cache_schemas: Optional[Set[BaseRelation]] = None,
     ) -> None:
         """Populate the relations cache for the given schemas. Returns an
         iterable of the schemas populated, as strings.
         """
         if not cache_schemas:
-            cache_schemas = self._get_cache_schemas(manifest)
+            cache_schemas = self._get_cache_schemas(relation_configs)
         with executor(self.config) as tpe:
             futures: List[Future[List[BaseRelation]]] = []
             for cache_schema in cache_schemas:
@@ -515,7 +516,7 @@ def _relations_cache_for_schemas(
 
     def set_relations_cache(
         self,
-        manifest: Manifest,
+        relation_configs: Iterable[RelationConfig],
         clear: bool = False,
         required_schemas: Optional[Set[BaseRelation]] = None,
     ) -> None:
@@ -525,7 +526,7 @@ def set_relations_cache(
         with self.cache.lock:
             if clear:
                 self.cache.clear()
-            self._relations_cache_for_schemas(manifest, required_schemas)
+            self._relations_cache_for_schemas(relation_configs, required_schemas)
 
     @available
     def cache_added(self, relation: Optional[BaseRelation]) -> str:

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.contracts.relation import (
+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,33 +196,14 @@ 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,
+        node: RelationConfig,
     ) -> Self:
         # Note that ephemeral models are based on the name.
         identifier = cls.add_ephemeral_prefix(node.name)
@@ -234,47 +213,33 @@ def create_ephemeral_from_node(
         ).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,
+        config: RelationConfig,
         **kwargs: Any,
     ) -> Self:
-        if quote_policy is None:
-            quote_policy = {}
+        quote_policy = kwargs.pop("quote_policy", {})
+
+        config_quoting = config.quoting_dict
+        config_quoting.pop("column", None)
 
-        quote_policy = dbt.common.utils.merge(config.quoting, quote_policy)
+        # precedence: kwargs quoting > 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=config.database,
+            schema=config.schema,
+            identifier=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/contracts/relation.py → core/dbt/adapters/contracts/relation.py

@@ -8,9 +8,8 @@
 
 from dbt.common.dataclass_schema import dbtClassMixin, StrEnum
 
-from dbt.contracts.util import Replaceable
-from dbt.common.exceptions import CompilationError
-from dbt.exceptions import DataclassNotDictError
+from dbt.common.contracts.util import Replaceable
+from dbt.common.exceptions import CompilationError, DataclassNotDictError
 from dbt.common.utils import deep_merge
 
 
@@ -23,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,23 +1,13 @@
 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.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
-from dbt.contracts.relation import Policy, HasQuoting
 
 
 @dataclass
@@ -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, config: RelationConfig, **kwargs: Any
+    ) -> Self:
         ...
 
 

core/dbt/common/exceptions/__init__.py

@@ -1,3 +1,4 @@
 from dbt.common.exceptions.base import *  # noqa
 from dbt.common.exceptions.events import *  # noqa
 from dbt.common.exceptions.macros import *  # noqa
+from dbt.common.exceptions.contracts import *  # noqa

core/dbt/common/exceptions/contracts.py

@@ -0,0 +1,17 @@
+from typing import Any
+from dbt.common.exceptions import CompilationError
+
+
+# this is part of the context and also raised in dbt.contracts.relation.py
+class DataclassNotDictError(CompilationError):
+    def __init__(self, obj: Any):
+        self.obj = obj
+        super().__init__(msg=self.get_message())
+
+    def get_message(self) -> str:
+        msg = (
+            f'The object ("{self.obj}") was used as a dictionary. This '
+            "capability has been removed from objects of this type."
+        )
+
+        return msg

core/dbt/config/runtime.py

@@ -15,13 +15,13 @@
     Type,
 )
 
-from dbt.flags import get_flags
 from dbt.adapters.factory import get_include_paths, get_relation_class_by_name
-from dbt.config.project import load_raw_project
 from dbt.adapters.contracts.connection import AdapterRequiredConfig, Credentials, HasCredentials
+from dbt.adapters.contracts.relation import ComponentName
+from dbt.flags import get_flags
+from dbt.config.project import load_raw_project
 from dbt.contracts.graph.manifest import ManifestMetadata
 from dbt.contracts.project import Configuration, UserConfig
-from dbt.contracts.relation import ComponentName
 from dbt.common.dataclass_schema import ValidationError
 from dbt.common.events.functions import warn_or_error
 from dbt.common.events.types import UnusedResourceConfigPath

core/dbt/context/exceptions_jinja.py

@@ -4,7 +4,12 @@
 from dbt.common.events.functions import warn_or_error
 from dbt.common.events.types import JinjaLogWarning
 
-from dbt.common.exceptions import DbtRuntimeError, NotImplementedError, DbtDatabaseError
+from dbt.common.exceptions import (
+    DbtRuntimeError,
+    NotImplementedError,
+    DbtDatabaseError,
+    DataclassNotDictError,
+)
 from dbt.adapters.exceptions import (
     MissingConfigError,
     ColumnTypeMissingError,
@@ -15,7 +20,6 @@
     MissingRelationError,
     AmbiguousAliasError,
     AmbiguousCatalogMatchError,
-    DataclassNotDictError,
     CompilationError,
     DependencyNotFoundError,
     DependencyError,

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):