Move Adapter Factory to Core

core/dbt/adapters/events/adapter_types.proto

@@ -346,19 +346,7 @@ message CacheDumpGraphMsg {
 
 
 // Skipping E032, E033, E034
-
-
-
-// E034
-message AdapterRegistered {
-    string adapter_name = 1;
-    string adapter_version = 2;
-}
-
-message AdapterRegisteredMsg {
-    AdapterCommonEventInfo info = 1;
-    AdapterRegistered data = 2;
-}
+// E034 is defined in dbt-core
 
 // E035
 message AdapterImportError {

core/dbt/adapters/events/types.py

@@ -29,16 +29,16 @@
 
 class AdapterDeprecationWarning(WarnLevel):
     def code(self) -> str:
         return "D005"
 
     def message(self) -> str:
         description = (
             f"The adapter function `adapter.{self.old_name}` is deprecated and will be removed in "
             f"a future release of dbt. Please use `adapter.{self.new_name}` instead. "
             f"\n\nDocumentation for {self.new_name} can be found here:"
             f"\n\nhttps://docs.getdbt.com/docs/adapter"
         )
         return line_wrap_message(warning_tag(f"Deprecated functionality\n\n{description}"))
 
 
 # =======================================================
@@ -56,26 +56,26 @@
 
 class AdapterEventInfo(InfoLevel):
     def code(self) -> str:
         return "E002"
 
     def message(self) -> str:
         return format_adapter_message(self.name, self.base_msg, self.args)
 
 
 class AdapterEventWarning(WarnLevel):
     def code(self) -> str:
         return "E003"
 
     def message(self) -> str:
         return format_adapter_message(self.name, self.base_msg, self.args)
 
 
 class AdapterEventError(ErrorLevel):
     def code(self) -> str:
         return "E004"
 
     def message(self) -> str:
         return format_adapter_message(self.name, self.base_msg, self.args)
 
 
 class NewConnection(DebugLevel):
@@ -96,10 +96,10 @@
 
 class ConnectionLeftOpenInCleanup(DebugLevel):
     def code(self) -> str:
         return "E007"
 
     def message(self) -> str:
         return f"Connection '{self.conn_name}' was left open."
 
 
 class ConnectionClosedInCleanup(DebugLevel):
@@ -112,10 +112,10 @@
 
 class RollbackFailed(DebugLevel):
     def code(self) -> str:
         return "E009"
 
     def message(self) -> str:
         return f"Failed to rollback '{self.conn_name}'"
 
 
 class ConnectionClosed(DebugLevel):
@@ -251,14 +251,14 @@
             return f"old key {ref_key} not found in self.relations, assuming temporary"
         elif self.action == "rename_relation":
             return f"Renaming relation {ref_key} to {ref_key_2}"
         elif self.action == "uncached_relation":
             return (
                 f"{ref_key_2} references {ref_key} "
                 f"but {self.ref_key.database}.{self.ref_key.schema}"
                 "is not in the cache, skipping assumed external relation"
             )
         else:
             return ref_key
 
 
 # Skipping E023, E024, E025, E026, E027, E028, E029, E030
@@ -266,37 +266,27 @@
 
 class CacheDumpGraph(DebugLevel):
     def code(self) -> str:
         return "E031"
 
     def message(self) -> str:
         return f"dump {self.before_after} {self.action} : {self.dump}"
 
 
-# Skipping E032, E033, E034
-
-
-class AdapterRegistered(InfoLevel):
-    def code(self) -> str:
-        return "E034"
-
-    def message(self) -> str:
-        return f"Registered adapter: {self.adapter_name}{self.adapter_version}"
-
-
+# Skipping E032, E033
 class AdapterImportError(InfoLevel):
     def code(self) -> str:
         return "E035"
 
     def message(self) -> str:
         return f"Error importing adapter: {self.exc}"
 
 
 class PluginLoadError(DebugLevel):
     def code(self) -> str:
         return "E036"
 
     def message(self) -> str:
         return f"{self.exc_info}"
 
 
 class NewConnectionOpening(DebugLevel):
@@ -309,23 +299,23 @@
 
 class CodeExecution(DebugLevel):
     def code(self) -> str:
         return "E038"
 
     def message(self) -> str:
         return f"On {self.conn_name}: {self.code_content}"
 
 
 class CodeExecutionStatus(DebugLevel):
     def code(self) -> str:
         return "E039"
 
     def message(self) -> str:
         return f"Execution status: {self.status} in {self.elapsed} seconds"
 
 
 class CatalogGenerationError(WarnLevel):
     def code(self) -> str:
         return "E040"
 
     def message(self) -> str:
         return f"Encountered an error while generating catalog: {self.exc}"
@@ -333,10 +323,10 @@
 
 class WriteCatalogFailure(ErrorLevel):
     def code(self) -> str:
         return "E041"
 
     def message(self) -> str:
         return (
             f"dbt encountered {self.num_exceptions} failure{(self.num_exceptions != 1) * 's'} "
             "while writing the catalog"
         )
@@ -352,10 +342,10 @@
 
 class CannotGenerateDocs(InfoLevel):
     def code(self) -> str:
         return "E043"
 
     def message(self) -> str:
         return "compile failed, cannot generate docs"
 
 
 class BuildingCatalog(InfoLevel):
@@ -393,25 +383,25 @@
 
 class ConstraintNotEnforced(WarnLevel):
     def code(self) -> str:
         return "E048"
 
     def message(self) -> str:
         msg = (
             f"The constraint type {self.constraint} is not enforced by {self.adapter}. "
             "The constraint will be included in this model's DDL statement, but it will not "
             "guarantee anything about the underlying data. Set 'warn_unenforced: false' on "
             "this constraint to ignore this warning."
         )
         return line_wrap_message(warning_tag(msg))
 
 
 class ConstraintNotSupported(WarnLevel):
     def code(self) -> str:
         return "E049"
 
     def message(self) -> str:
         msg = (
             f"The constraint type {self.constraint} is not supported by {self.adapter}, and will "
             "be ignored. Set 'warn_unsupported: false' on this constraint to ignore this warning."
         )
         return line_wrap_message(warning_tag(msg))

core/dbt/adapters/include/global_project/__init__.py

@@ -2,3 +2,11 @@
 
 PACKAGE_PATH = os.path.dirname(__file__)
 PROJECT_NAME = "dbt"
+
+
+def get_global_project_path() -> str:
+    return PACKAGE_PATH
+
+
+def get_global_project_name() -> str:
+    return PROJECT_NAME

core/dbt/adapters/load_adapter.py

@@ -0,0 +1,26 @@
+import traceback
+from importlib import import_module
+from types import ModuleType
+
+
+from dbt.adapters.events.types import AdapterImportError, PluginLoadError
+from dbt.common.events.functions import fire_event
+from dbt.common.exceptions import DbtRuntimeError
+
+
+def get_adapter_by_name(name: str) -> ModuleType:
+    try:
+        # mypy doesn't think modules have any attributes.
+        mod: ModuleType = import_module("." + name, "dbt.adapters")
+        return mod
+    except ModuleNotFoundError as exc:
+        # if we failed to import the target module in particular, inform
+        # the user about it via a runtime error
+        if exc.name == "dbt.adapters." + name:
+            fire_event(AdapterImportError(exc=str(exc)))
+            raise DbtRuntimeError(f"Could not find adapter type {name}!")
+        # otherwise, the error had to have come from some underlying
+        # library. Log the stack trace.
+
+        fire_event(PluginLoadError(exc_info=traceback.format_exc()))
+        raise

core/dbt/cli/requires.py

@@ -1,7 +1,7 @@
 import dbt.tracking
 from dbt.common.invocation import reset_invocation_id
 from dbt.version import installed as installed_version
-from dbt.adapters.factory import adapter_management, register_adapter, get_adapter
+from dbt.clients.adapter import adapter_management, register_adapter, get_adapter
 from dbt.flags import set_flags, get_flag_dict
 from dbt.cli.exceptions import (
     ExceptionExit,

core/dbt/clients/adapter/__init__.py

@@ -0,0 +1 @@
+from dbt.clients.adapter.client import *  # noqa

core/dbt/clients/adapter/client.py

@@ -0,0 +1,88 @@
+from contextlib import contextmanager
+
+from pathlib import Path
+
+from typing import Type, Optional, List
+from dbt.adapters.contracts.connection import AdapterRequiredConfig, Credentials
+from dbt.adapters.protocol import AdapterProtocol, AdapterConfig, RelationProtocol
+from dbt.clients.adapter.container import AdapterContainer
+
+_FACTORY: AdapterContainer = AdapterContainer()
+
+
+def register_adapter(config: AdapterRequiredConfig) -> None:
+    global _FACTORY
+    _FACTORY.register_adapter(config)
+
+
+def get_adapter(config: AdapterRequiredConfig):
+    global _FACTORY
+    return _FACTORY.lookup_adapter(config.credentials.type)
+
+
+def get_adapter_by_type(adapter_type):
+    global _FACTORY
+    return _FACTORY.lookup_adapter(adapter_type)
+
+
+def reset_adapters():
+    """Clear the adapters. This is useful for tests, which change configs."""
+    global _FACTORY
+    _FACTORY.reset_adapters()
+
+
+def cleanup_connections():
+    """Only clean up the adapter connections list without resetting the actual
+    adapters.
+    """
+    global _FACTORY
+    _FACTORY.cleanup_connections()
+
+
+def get_adapter_class_by_name(name: str) -> Type[AdapterProtocol]:
+    global _FACTORY
+    return _FACTORY.get_adapter_class_by_name(name)
+
+
+def get_config_class_by_name(name: str) -> Type[AdapterConfig]:
+    global _FACTORY
+    return _FACTORY.get_config_class_by_name(name)
+
+
+def get_relation_class_by_name(name: str) -> Type[RelationProtocol]:
+    global _FACTORY
+    return _FACTORY.get_relation_class_by_name(name)
+
+
+def load_plugin(name: str) -> Type[Credentials]:
+    global _FACTORY
+    return _FACTORY.load_plugin(name)
+
+
+def get_include_paths(name: Optional[str]) -> List[Path]:
+    global _FACTORY
+    return _FACTORY.get_include_paths(name)
+
+
+def get_adapter_package_names(name: Optional[str]) -> List[str]:
+    global _FACTORY
+    return _FACTORY.get_adapter_package_names(name)
+
+
+def get_adapter_type_names(name: Optional[str]) -> List[str]:
+    global _FACTORY
+    return _FACTORY.get_adapter_type_names(name)
+
+
+def get_adapter_constraint_support(name: Optional[str]) -> List[str]:
+    global _FACTORY
+    return _FACTORY.get_adapter_constraint_support(name)
+
+
+@contextmanager
+def adapter_management():
+    reset_adapters()
+    try:
+        yield
+    finally:
+        cleanup_connections()

core/dbt/adapters/factory.py → core/dbt/clients/adapter/container.py

@@ -1,28 +1,30 @@
-import threading
-import traceback
-from contextlib import contextmanager
 from importlib import import_module
+
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Set, Type
 
-from dbt.adapters.base.plugin import AdapterPlugin
-from dbt.adapters.protocol import AdapterConfig, AdapterProtocol, RelationProtocol
-from dbt.adapters.contracts.connection import AdapterRequiredConfig, Credentials
+from typing import Dict, Type, Any, Optional, List, Set
+
+import threading
+
+from dbt.adapters.base import AdapterPlugin
+from dbt.adapters.contracts.connection import Credentials, AdapterRequiredConfig
+from dbt.adapters.include.global_project import (
+    PROJECT_NAME as GLOBAL_PROJECT_NAME,
+    PACKAGE_PATH as GLOBAL_PROJECT_PATH,
+)
+from dbt.adapters import load_adapter
+from dbt.adapters.protocol import RelationProtocol, AdapterConfig, AdapterProtocol
 from dbt.common.events.functions import fire_event
-from dbt.adapters.events.types import AdapterImportError, PluginLoadError, AdapterRegistered
-from dbt.common.exceptions import DbtInternalError, DbtRuntimeError
-from dbt.adapters.include.global_project import PACKAGE_PATH as GLOBAL_PROJECT_PATH
-from dbt.adapters.include.global_project import PROJECT_NAME as GLOBAL_PROJECT_NAME
+from dbt.common.exceptions import DbtRuntimeError, DbtInternalError
 from dbt.common.semver import VersionSpecifier
+from dbt.events.types import AdapterRegistered
 from dbt.mp_context import get_mp_context
 
-Adapter = AdapterProtocol
-
 
 class AdapterContainer:
     def __init__(self) -> None:
         self.lock = threading.Lock()
-        self.adapters: Dict[str, Adapter] = {}
+        self.adapters: Dict[str, AdapterProtocol] = {}
         self.plugins: Dict[str, AdapterPlugin] = {}
         # map package names to their include paths
         self.packages: Dict[str, Path] = {
@@ -38,7 +40,7 @@ def get_plugin_by_name(self, name: str) -> AdapterPlugin:
         message = f"Invalid adapter type {name}! Must be one of {names}"
         raise DbtRuntimeError(message)
 
-    def get_adapter_class_by_name(self, name: str) -> Type[Adapter]:
+    def get_adapter_class_by_name(self, name: str) -> Type[AdapterProtocol]:
         plugin = self.get_plugin_by_name(name)
         return plugin.adapter
 
@@ -54,20 +56,8 @@ def load_plugin(self, name: str) -> Type[Credentials]:
         # this doesn't need a lock: in the worst case we'll overwrite packages
         # and adapter_type entries with the same value, as they're all
         # singletons
-        try:
-            # mypy doesn't think modules have any attributes.
-            mod: Any = import_module("." + name, "dbt.adapters")
-        except ModuleNotFoundError as exc:
-            # if we failed to import the target module in particular, inform
-            # the user about it via a runtime error
-            if exc.name == "dbt.adapters." + name:
-                fire_event(AdapterImportError(exc=str(exc)))
-                raise DbtRuntimeError(f"Could not find adapter type {name}!")
-            # otherwise, the error had to have come from some underlying
-            # library. Log the stack trace.
-
-            fire_event(PluginLoadError(exc_info=traceback.format_exc()))
-            raise
+        mod: Any = load_adapter.get_adapter_by_name(name)
+
         plugin: AdapterPlugin = mod.Plugin
         plugin_type = plugin.adapter.type()
 
@@ -103,10 +93,10 @@ def register_adapter(self, config: AdapterRequiredConfig) -> None:
                 # this shouldn't really happen...
                 return
 
-            adapter: Adapter = adapter_type(config, get_mp_context())  # type: ignore
+            adapter: AdapterProtocol = adapter_type(config, get_mp_context())  # type: ignore
             self.adapters[adapter_name] = adapter
 
-    def lookup_adapter(self, adapter_name: str) -> Adapter:
+    def lookup_adapter(self, adapter_name: str) -> AdapterProtocol:
         return self.adapters[adapter_name]
 
     def reset_adapters(self):
@@ -168,71 +158,3 @@ def get_adapter_type_names(self, name: Optional[str]) -> List[str]:
 
     def get_adapter_constraint_support(self, name: Optional[str]) -> List[str]:
         return self.lookup_adapter(name).CONSTRAINT_SUPPORT  # type: ignore
-
-
-FACTORY: AdapterContainer = AdapterContainer()
-
-
-def register_adapter(config: AdapterRequiredConfig) -> None:
-    FACTORY.register_adapter(config)
-
-
-def get_adapter(config: AdapterRequiredConfig):
-    return FACTORY.lookup_adapter(config.credentials.type)
-
-
-def get_adapter_by_type(adapter_type):
-    return FACTORY.lookup_adapter(adapter_type)
-
-
-def reset_adapters():
-    """Clear the adapters. This is useful for tests, which change configs."""
-    FACTORY.reset_adapters()
-
-
-def cleanup_connections():
-    """Only clean up the adapter connections list without resetting the actual
-    adapters.
-    """
-    FACTORY.cleanup_connections()
-
-
-def get_adapter_class_by_name(name: str) -> Type[AdapterProtocol]:
-    return FACTORY.get_adapter_class_by_name(name)
-
-
-def get_config_class_by_name(name: str) -> Type[AdapterConfig]:
-    return FACTORY.get_config_class_by_name(name)
-
-
-def get_relation_class_by_name(name: str) -> Type[RelationProtocol]:
-    return FACTORY.get_relation_class_by_name(name)
-
-
-def load_plugin(name: str) -> Type[Credentials]:
-    return FACTORY.load_plugin(name)
-
-
-def get_include_paths(name: Optional[str]) -> List[Path]:
-    return FACTORY.get_include_paths(name)
-
-
-def get_adapter_package_names(name: Optional[str]) -> List[str]:
-    return FACTORY.get_adapter_package_names(name)
-
-
-def get_adapter_type_names(name: Optional[str]) -> List[str]:
-    return FACTORY.get_adapter_type_names(name)
-
-
-def get_adapter_constraint_support(name: Optional[str]) -> List[str]:
-    return FACTORY.get_adapter_constraint_support(name)
-
-
-@contextmanager
-def adapter_management():
-    reset_adapters()
-    try:
-        yield
-    finally:
-        cleanup_connections()

core/dbt/common/contracts/config/base.py

@@ -28,19 +28,19 @@
 
     # enable syntax like: config['key'] = value
     def __setitem__(self, key, value):
         if hasattr(self, key):
             setattr(self, key, value)
         else:
             self._extra[key] = value
 
     def __delitem__(self, key):
         if hasattr(self, key):
             msg = (
                 'Error, tried to delete config key "{}": Cannot delete ' "built-in keys"
             ).format(key)
             raise CompilationError(msg)
         else:
             del self._extra[key]
 
     def _content_iterator(self, include_condition: Callable[[Field], bool]):
         seen = set()
@@ -49,16 +49,16 @@
             if include_condition(fld):
                 yield fld.name
 
         for key in self._extra:
             if key not in seen:
                 seen.add(key)
                 yield key
 
     def __iter__(self):
         yield from self._content_iterator(include_condition=lambda f: True)
 
     def __len__(self):
         return len(self._get_fields()) + len(self._extra)
 
     @staticmethod
     def compare_key(
@@ -69,7 +69,7 @@
         if key not in unrendered and key not in other:
             return True
         elif key not in unrendered and key in other:
             return False
         elif key in unrendered and key not in other:
             return False
         else:
@@ -88,9 +88,9 @@
 
         for key in chain(unrendered, other):
             if key not in seen:
                 seen.add(key)
                 if not cls.compare_key(unrendered, other, key):
                     return False
         return True
 
     # This is used in 'add_config_call' to create the combined config_call_dict.
@@ -145,7 +145,7 @@
         it, and return a new config with the updated values
         """
         # sadly, this is a circular import
-        from dbt.adapters.factory import get_config_class_by_name
+        from dbt.clients.adapter import get_config_class_by_name
 
         dct = self.to_dict(omit_none=False)
 
@@ -162,7 +162,7 @@
 
         # any validation failures must have come from the update
         if validate:
             self.validate(dct)
         return self.from_dict(dct)
 
     def finalize_and_validate(self: T) -> T:
@@ -224,17 +224,17 @@
         return _listify(self_value) + _listify(other_value)
     elif merge_behavior == MergeBehavior.Update:
         if not isinstance(self_value, dict):
             raise DbtInternalError(f"expected dict, got {self_value}")
         if not isinstance(other_value, dict):
             raise DbtInternalError(f"expected dict, got {other_value}")
         value = self_value.copy()
         value.update(other_value)
         return value
     elif merge_behavior == MergeBehavior.DictKeyAppend:
         if not isinstance(self_value, dict):
             raise DbtInternalError(f"expected dict, got {self_value}")
         if not isinstance(other_value, dict):
             raise DbtInternalError(f"expected dict, got {other_value}")
         new_dict = {}
         for key in self_value.keys():
             new_dict[key] = _listify(self_value[key])
@@ -256,4 +256,4 @@
         return new_dict
 
     else:
         raise DbtInternalError(f"Got an invalid merge_behavior: {merge_behavior}")

core/dbt/compilation.py

@@ -9,7 +9,7 @@
 
 from dbt.common.invocation import get_invocation_id
 from dbt.flags import get_flags
-from dbt.adapters.factory import get_adapter
+from dbt.clients.adapter import get_adapter
 from dbt.clients import jinja
 from dbt.clients.system import make_directory
 from dbt.context.providers import generate_runtime_model_context

core/dbt/config/profile.py

@@ -153,7 +153,7 @@ def _credentials_from_profile(
         profile: Dict[str, Any], profile_name: str, target_name: str
     ) -> Credentials:
         # avoid an import cycle
-        from dbt.adapters.factory import load_plugin
+        from dbt.clients.adapter import load_plugin
 
         # credentials carry their 'type' in their actual type, not their
         # attributes. We do want this in order to pick our Credentials class.

core/dbt/config/runtime.py

@@ -15,7 +15,7 @@
     Type,
 )
 
-from dbt.adapters.factory import get_include_paths, get_relation_class_by_name
+from dbt.clients.adapter import get_include_paths, get_relation_class_by_name
 from dbt.adapters.contracts.connection import AdapterRequiredConfig, Credentials, HasCredentials
 from dbt.adapters.contracts.relation import ComponentName
 from dbt.flags import get_flags

core/dbt/context/manifest.py

@@ -44,7 +44,7 @@ def _build_namespace(self):
 
     def _get_namespace_builder(self) -> MacroNamespaceBuilder:
         # avoid an import loop
-        from dbt.adapters.factory import get_adapter_package_names
+        from dbt.clients.adapter import get_adapter_package_names
 
         internal_packages: List[str] = get_adapter_package_names(self.config.credentials.type)
         return MacroNamespaceBuilder(

core/dbt/context/providers.py

@@ -15,8 +15,8 @@
 from typing_extensions import Protocol
 
 from dbt.adapters.base.column import Column
+from dbt.clients.adapter import get_adapter, get_adapter_package_names, get_adapter_type_names
 from dbt.common.clients.jinja import MacroProtocol
-from dbt.adapters.factory import get_adapter, get_adapter_package_names, get_adapter_type_names
 from dbt.common.clients import agate_helper
 from dbt.clients.jinja import get_rendered, MacroGenerator, MacroStack
 from dbt.config import RuntimeConfig, Project