dbt-adapters 1.22.2__py3-none-any.whl

dbt/adapters/exceptions/compilation.py

@@ -0,0 +1,269 @@
+from typing import Any, List, Mapping
+
+from dbt_common.exceptions import CompilationError, DbtDatabaseError
+from dbt_common.ui import line_wrap_message
+
+
+class MissingConfigError(CompilationError):
+    def __init__(self, unique_id: str, name: str):
+        self.unique_id = unique_id
+        self.name = name
+        msg = (
+            f"Model '{self.unique_id}' does not define a required config parameter '{self.name}'."
+        )
+        super().__init__(msg=msg)
+
+
+class MultipleDatabasesNotAllowedError(CompilationError):
+    def __init__(self, databases):
+        self.databases = databases
+        super().__init__(msg=self.get_message())
+
+    def get_message(self) -> str:
+        msg = str(self.databases)
+        return msg
+
+
+class ApproximateMatchError(CompilationError):
+    def __init__(self, target, relation):
+        self.target = target
+        self.relation = relation
+        super().__init__(msg=self.get_message())
+
+    def get_message(self) -> str:
+        msg = (
+            "When searching for a relation, dbt found an approximate match. "
+            "Instead of guessing \nwhich relation to use, dbt will move on. "
+            f"Please delete {self.relation}, or rename it to be less ambiguous."
+            f"\nSearched for: {self.target}\nFound: {self.relation}"
+        )
+
+        return msg
+
+
+class SnapshotTargetIncompleteError(CompilationError):
+    def __init__(self, extra: List, missing: List):
+        self.extra = extra
+        self.missing = missing
+        super().__init__(msg=self.get_message())
+
+    def get_message(self) -> str:
+        msg = (
+            'Snapshot target has ("{}") but not ("{}") - is it an '
+            "unmigrated previous version archive?".format(
+                '", "'.join(self.extra), '", "'.join(self.missing)
+            )
+        )
+        return msg
+
+
+class DuplicateMacroInPackageError(CompilationError):
+    def __init__(self, macro, macro_mapping: Mapping):
+        self.macro = macro
+        self.macro_mapping = macro_mapping
+        super().__init__(msg=self.get_message())
+
+    def get_message(self) -> str:
+        other_path = self.macro_mapping[self.macro.unique_id].original_file_path
+        # subtract 2 for the "Compilation Error" indent
+        # note that the line wrap eats newlines, so if you want newlines,
+        # this is the result :(
+        msg = line_wrap_message(
+            f"""\
+            dbt found two macros named "{self.macro.name}" in the project
+            "{self.macro.package_name}".
+
+
+            To fix this error, rename or remove one of the following
+            macros:
+
+                - {self.macro.original_file_path}
+
+                - {other_path}
+            """,
+            subtract=2,
+        )
+        return msg
+
+
+class DuplicateMaterializationNameError(CompilationError):
+    def __init__(self, macro, other_macro):
+        self.macro = macro
+        self.other_macro = other_macro
+        super().__init__(msg=self.get_message())
+
+    def get_message(self) -> str:
+        macro_name = self.macro.name
+        macro_package_name = self.macro.package_name
+        other_package_name = self.other_macro.macro.package_name
+
+        msg = (
+            f"Found two materializations with the name {macro_name} (packages "
+            f"{macro_package_name} and {other_package_name}). dbt cannot resolve "
+            "this ambiguity"
+        )
+        return msg
+
+
+class ColumnTypeMissingError(CompilationError):
+    def __init__(self, column_names: List):
+        self.column_names = column_names
+        super().__init__(msg=self.get_message())
+
+    def get_message(self) -> str:
+        msg = (
+            "Contracted models require data_type to be defined for each column. "
+            "Please ensure that the column name and data_type are defined within "
+            f"the YAML configuration for the {self.column_names} column(s)."
+        )
+        return msg
+
+
+class MacroNotFoundError(CompilationError):
+    def __init__(self, node, target_macro_id: str):
+        self.node = node
+        self.target_macro_id = target_macro_id
+        msg = f"'{self.node.unique_id}' references macro '{self.target_macro_id}' which is not defined!"
+
+        super().__init__(msg=msg)
+
+
+class MissingMaterializationError(CompilationError):
+    def __init__(self, materialization, adapter_type):
+        self.materialization = materialization
+        self.adapter_type = adapter_type
+        super().__init__(msg=self.get_message())
+
+    def get_message(self) -> str:
+        valid_types = "'default'"
+
+        if self.adapter_type != "default":
+            valid_types = f"'default' and '{self.adapter_type}'"
+
+        msg = f"No materialization '{self.materialization}' was found for adapter {self.adapter_type}! (searched types {valid_types})"
+        return msg
+
+
+class SnapshotTargetNotSnapshotTableError(CompilationError):
+    def __init__(self, missing: List):
+        self.missing = missing
+        super().__init__(msg=self.get_message())
+
+    def get_message(self) -> str:
+        missing = '", "'.join(self.missing)
+        msg = (
+            f'Snapshot target is missing configured columns (missing "{missing}"). '
+            "See https://docs.getdbt.com/docs/build/snapshots#snapshot-meta-fields for more information."
+        )
+        return msg
+
+
+class NullRelationDropAttemptedError(CompilationError):
+    def __init__(self, name: str):
+        self.name = name
+        self.msg = f"Attempted to drop a null relation for {self.name}"
+        super().__init__(msg=self.msg)
+
+
+class NullRelationCacheAttemptedError(CompilationError):
+    def __init__(self, name: str):
+        self.name = name
+        self.msg = f"Attempted to cache a null relation for {self.name}"
+        super().__init__(msg=self.msg)
+
+
+class RelationTypeNullError(CompilationError):
+    def __init__(self, relation):
+        self.relation = relation
+        self.msg = f"Tried to drop relation {self.relation}, but its type is null."
+        super().__init__(msg=self.msg)
+
+
+class MaterializationNotAvailableError(CompilationError):
+    def __init__(self, materialization, adapter_type: str):
+        self.materialization = materialization
+        self.adapter_type = adapter_type
+        super().__init__(msg=self.get_message())
+
+    def get_message(self) -> str:
+        msg = f"Materialization '{self.materialization}' is not available for {self.adapter_type}!"
+        return msg
+
+
+class RelationReturnedMultipleResultsError(CompilationError):
+    def __init__(self, kwargs: Mapping[str, Any], matches: List):
+        self.kwargs = kwargs
+        self.matches = matches
+        super().__init__(msg=self.get_message())
+
+    def get_message(self) -> str:
+        msg = (
+            "get_relation returned more than one relation with the given args. "
+            "Please specify a database or schema to narrow down the result set."
+            f"\n{self.kwargs}\n\n{self.matches}"
+        )
+        return msg
+
+
+class UnexpectedNonTimestampError(DbtDatabaseError):
+    def __init__(self, field_name: str, source, dt: Any):
+        self.field_name = field_name
+        self.source = source
+        self.type_name = type(dt).__name__
+        msg = (
+            f"Expected a timestamp value when querying field '{self.field_name}' of table "
+            f"{self.source} but received value of type '{self.type_name}' instead"
+        )
+        super().__init__(msg)
+
+
+class RenameToNoneAttemptedError(CompilationError):
+    def __init__(self, src_name: str, dst_name: str, name: str):
+        self.src_name = src_name
+        self.dst_name = dst_name
+        self.name = name
+        self.msg = f"Attempted to rename {self.src_name} to {self.dst_name} for {self.name}"
+        super().__init__(msg=self.msg)
+
+
+class QuoteConfigTypeError(CompilationError):
+    def __init__(self, quote_config: Any):
+        self.quote_config = quote_config
+        super().__init__(msg=self.get_message())
+
+    def get_message(self) -> str:
+        msg = (
+            'The seed configuration value of "quote_columns" has an '
+            f"invalid type {type(self.quote_config)}"
+        )
+        return msg
+
+
+class RelationWrongTypeError(CompilationError):
+    def __init__(self, relation, expected_type, model=None):
+        self.relation = relation
+        self.expected_type = expected_type
+        self.model = model
+        super().__init__(msg=self.get_message())
+
+    def get_message(self) -> str:
+        msg = (
+            f"Trying to create {self.expected_type} {self.relation}, "
+            f"but it currently exists as a {self.relation.type}. Either "
+            f"drop {self.relation} manually, or run dbt with "
+            "`--full-refresh` and dbt will drop it for you."
+        )
+
+        return msg
+
+
+class InvalidRelationConfigError(CompilationError):
+    def __init__(self, relation, config, msg):
+        self.relation = relation
+        self.config = config
+        self.msg = msg
+        super().__init__(msg=self.get_message())
+
+    def get_message(self) -> str:
+        msg = f"Invalid relation config: {self.config}"
+        return msg

dbt/adapters/exceptions/connection.py

@@ -0,0 +1,16 @@
+from typing import List
+
+from dbt_common.exceptions import DbtDatabaseError, DbtRuntimeError
+
+
+class InvalidConnectionError(DbtRuntimeError):
+    def __init__(self, thread_id, known: List) -> None:
+        self.thread_id = thread_id
+        self.known = known
+        super().__init__(
+            msg=f"connection never acquired for thread {self.thread_id}, have {self.known}"
+        )
+
+
+class FailedToConnectError(DbtDatabaseError):
+    pass

dbt/adapters/exceptions/database.py

@@ -0,0 +1,51 @@
+from typing import Any
+
+from dbt_common.exceptions import CompilationError, NotImplementedError
+
+
+class UnexpectedDbReferenceError(NotImplementedError):
+    def __init__(self, adapter, database, expected):
+        self.adapter = adapter
+        self.database = database
+        self.expected = expected
+        super().__init__(msg=self.get_message())
+
+    def get_message(self) -> str:
+        msg = f"Cross-db references not allowed in {self.adapter} ({self.database} vs {self.expected})"
+        return msg
+
+
+class CrossDbReferenceProhibitedError(CompilationError):
+    def __init__(self, adapter, exc_msg: str):
+        self.adapter = adapter
+        self.exc_msg = exc_msg
+        super().__init__(msg=self.get_message())
+
+    def get_message(self) -> str:
+        msg = f"Cross-db references not allowed in adapter {self.adapter}: Got {self.exc_msg}"
+        return msg
+
+
+class IndexConfigNotDictError(CompilationError):
+    def __init__(self, raw_index: Any):
+        self.raw_index = raw_index
+        super().__init__(msg=self.get_message())
+
+    def get_message(self) -> str:
+        msg = (
+            f"Invalid index config:\n"
+            f"  Got: {self.raw_index}\n"
+            f'  Expected a dictionary with at minimum a "columns" key'
+        )
+        return msg
+
+
+class IndexConfigError(CompilationError):
+    def __init__(self, exc: TypeError):
+        self.exc = exc
+        super().__init__(msg=self.get_message())
+
+    def get_message(self) -> str:
+        validator_msg = self.validator_error_message(self.exc)
+        msg = f"Could not parse index config: {validator_msg}"
+        return msg

dbt/adapters/factory.py

@@ -0,0 +1,264 @@
+from contextlib import contextmanager
+from importlib import import_module
+from multiprocessing.context import SpawnContext
+from pathlib import Path
+import threading
+import traceback
+from typing import Any, Dict, List, Optional, Set, Type
+
+from dbt_common.events.functions import fire_event
+from dbt_common.events.base_types import EventLevel
+from dbt_common.exceptions import DbtInternalError, DbtRuntimeError
+from dbt_common.semver import VersionSpecifier
+
+from dbt.adapters.base.plugin import AdapterPlugin
+from dbt.adapters.contracts.connection import AdapterRequiredConfig, Credentials
+from dbt.adapters.events.types import (
+    AdapterImportError,
+    PluginLoadError,
+    AdapterRegistered,
+)
+from dbt.include.global_project import (
+    PACKAGE_PATH as GLOBAL_PROJECT_PATH,
+    PROJECT_NAME as GLOBAL_PROJECT_NAME,
+)
+from dbt.adapters.protocol import AdapterConfig, AdapterProtocol, RelationProtocol
+
+
+Adapter = AdapterProtocol
+
+
+class AdapterContainer:
+    def __init__(self) -> None:
+        self.lock = threading.Lock()
+        self.adapters: Dict[str, Adapter] = {}
+        self.plugins: Dict[str, AdapterPlugin] = {}
+        # map package names to their include paths
+        self.packages: Dict[str, Path] = {
+            GLOBAL_PROJECT_NAME: Path(GLOBAL_PROJECT_PATH),
+        }
+
+    def get_plugin_by_name(self, name: str) -> AdapterPlugin:
+        with self.lock:
+            if name in self.plugins:
+                return self.plugins[name]
+            names = ", ".join(self.plugins.keys())
+
+        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]:
+        plugin = self.get_plugin_by_name(name)
+        return plugin.adapter
+
+    def get_relation_class_by_name(self, name: str) -> Type[RelationProtocol]:
+        adapter = self.get_adapter_class_by_name(name)
+        return adapter.Relation
+
+    def get_config_class_by_name(self, name: str) -> Type[AdapterConfig]:
+        adapter = self.get_adapter_class_by_name(name)
+        return adapter.AdapterSpecificConfigs
+
+    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
+        plugin: AdapterPlugin = mod.Plugin
+        plugin_type = plugin.adapter.type()
+
+        if plugin_type != name:
+            raise DbtRuntimeError(
+                f"Expected to find adapter with type named {name}, got "
+                f"adapter with type {plugin_type}"
+            )
+
+        with self.lock:
+            # things do hold the lock to iterate over it so we need it to add
+            self.plugins[name] = plugin
+
+        self.packages[plugin.project_name] = Path(plugin.include_path)
+
+        for dep in plugin.dependencies:
+            self.load_plugin(dep)
+
+        return plugin.credentials
+
+    def register_adapter(
+        self,
+        config: AdapterRequiredConfig,
+        mp_context: SpawnContext,
+        adapter_registered_log_level: Optional[EventLevel] = EventLevel.INFO,
+    ) -> None:
+        adapter_name = config.credentials.type
+        adapter_type = self.get_adapter_class_by_name(adapter_name)
+        adapter_version = self._adapter_version(adapter_name)
+        fire_event(
+            AdapterRegistered(adapter_name=adapter_name, adapter_version=adapter_version),
+            level=adapter_registered_log_level,
+        )
+        with self.lock:
+            if adapter_name in self.adapters:
+                # this shouldn't really happen...
+                return
+
+            adapter: Adapter = adapter_type(config, mp_context)  # type: ignore
+            self.adapters[adapter_name] = adapter
+
+    def _adapter_version(self, adapter_name: str) -> str:
+        try:
+            raw_version = import_module(f".{adapter_name}.__about__", "dbt.adapters").version
+        except ModuleNotFoundError:
+            raw_version = import_module(f".{adapter_name}.__version__", "dbt.adapters").version
+        return self._validate_version(raw_version)
+
+    def _validate_version(self, raw_version: str) -> str:
+        return VersionSpecifier.from_version_string(raw_version).to_version_string()
+
+    def lookup_adapter(self, adapter_name: str) -> Adapter:
+        return self.adapters[adapter_name]
+
+    def reset_adapters(self):
+        """Clear the adapters. This is useful for tests, which change configs."""
+        with self.lock:
+            for adapter in self.adapters.values():
+                adapter.cleanup_connections()
+            self.adapters.clear()
+
+    def cleanup_connections(self):
+        """Only clean up the adapter connections list without resetting the
+        actual adapters.
+        """
+        with self.lock:
+            for adapter in self.adapters.values():
+                adapter.cleanup_connections()
+
+    def get_adapter_plugins(self, name: Optional[str]) -> List[AdapterPlugin]:
+        """Iterate over the known adapter plugins. If a name is provided,
+        iterate in dependency order over the named plugin and its dependencies.
+        """
+        if name is None:
+            return list(self.plugins.values())
+
+        plugins: List[AdapterPlugin] = []
+        seen: Set[str] = set()
+        plugin_names: List[str] = [name]
+        while plugin_names:
+            plugin_name = plugin_names[0]
+            plugin_names = plugin_names[1:]
+            try:
+                plugin = self.plugins[plugin_name]
+            except KeyError:
+                raise DbtInternalError(f"No plugin found for {plugin_name}") from None
+            plugins.append(plugin)
+            seen.add(plugin_name)
+            for dep in plugin.dependencies:
+                if dep not in seen:
+                    plugin_names.append(dep)
+        return plugins
+
+    def get_adapter_package_names(self, name: Optional[str]) -> List[str]:
+        package_names: List[str] = [p.project_name for p in self.get_adapter_plugins(name)]
+        package_names.append(GLOBAL_PROJECT_NAME)
+        return package_names
+
+    def get_include_paths(self, name: Optional[str]) -> List[Path]:
+        paths = []
+        for package_name in self.get_adapter_package_names(name):
+            try:
+                path = self.packages[package_name]
+            except KeyError:
+                raise DbtInternalError(f"No internal package listing found for {package_name}")
+            paths.append(path)
+        return paths
+
+    def get_adapter_type_names(self, name: Optional[str]) -> List[str]:
+        return [p.adapter.type() for p in self.get_adapter_plugins(name)]
+
+    def get_adapter_constraint_support(self, name: Optional[str]) -> Dict[str, str]:
+        return self.lookup_adapter(name).CONSTRAINT_SUPPORT  # type: ignore
+
+
+FACTORY: AdapterContainer = AdapterContainer()
+
+
+def register_adapter(
+    config: AdapterRequiredConfig,
+    mp_context: SpawnContext,
+    adapter_registered_log_level: Optional[EventLevel] = EventLevel.INFO,
+) -> None:
+    FACTORY.register_adapter(config, mp_context, adapter_registered_log_level)
+
+
+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]) -> Dict[str, str]:
+    return FACTORY.get_adapter_constraint_support(name)
+
+
+@contextmanager
+def adapter_management():
+    reset_adapters()
+    try:
+        yield
+    finally:
+        cleanup_connections()