dbt-adapters 1.22.2__py3-none-any.whl

dbt/adapters/record/cursor/fetchone.py

@@ -0,0 +1,23 @@
+import dataclasses
+from typing import Any
+
+from dbt_common.record import Record, Recorder
+
+
+@dataclasses.dataclass
+class CursorFetchOneParams:
+    connection_name: str
+
+
+@dataclasses.dataclass
+class CursorFetchOneResult:
+    result: Any
+
+
+@Recorder.register_record_type
+class CursorFetchOneRecord(Record):
+    """Implements record/replay support for the cursor.fetchone() method."""
+
+    params_cls = CursorFetchOneParams
+    result_cls = CursorFetchOneResult
+    group = "Database"

dbt/adapters/record/cursor/rowcount.py

@@ -0,0 +1,23 @@
+import dataclasses
+from typing import Optional
+
+from dbt_common.record import Record, Recorder
+
+
+@dataclasses.dataclass
+class CursorGetRowCountParams:
+    connection_name: str
+
+
+@dataclasses.dataclass
+class CursorGetRowCountResult:
+    rowcount: Optional[int]
+
+
+@Recorder.register_record_type
+class CursorGetRowCountRecord(Record):
+    """Implements record/replay support for the cursor.rowcount property."""
+
+    params_cls = CursorGetRowCountParams
+    result_cls = CursorGetRowCountResult
+    group = "Database"

dbt/adapters/record/handle.py

@@ -0,0 +1,55 @@
+from typing import Any
+
+from dbt_common.events.base_types import BaseEvent
+from dbt_common.events.functions import fire_event
+from dbt_common.events.types import RecordReplayIssue
+
+from dbt.adapters.contracts.connection import Connection
+from dbt.adapters.record.cursor.cursor import RecordReplayCursor
+
+
+class RecordReplayHandle:
+    """A proxy object used for record/replay modes. What adapters call a
+    'handle' is typically a native database connection, but should not be
+    confused with the Connection protocol, which is a dbt-adapters concept.
+
+    Currently, the only function of the handle proxy is to provide a record/replay
+    aware cursor object when cursor() is called."""
+
+    def __init__(self, native_handle: Any, connection: Connection) -> None:
+        self.native_handle = native_handle
+        self.connection = connection
+
+    def cursor(self) -> Any:
+        # The native handle could be None if we are in replay mode, because no
+        # actual database access should be performed in that mode.
+        cursor = None if self.native_handle is None else self.native_handle.cursor()
+        return RecordReplayCursor(cursor, self.connection)
+
+    def commit(self):
+        self.native_handle.commit()
+
+    def rollback(self):
+        self.native_handle.rollback()
+
+    def close(self):
+        self.native_handle.close()
+
+    def get_backend_pid(self):
+        return self.native_handle.get_backend_pid()
+
+    @property
+    def closed(self):
+        return self.native_handle.closed
+
+    def _fire_event(self, evt: BaseEvent) -> None:
+        """Wraps fire_event for easier test mocking."""
+        fire_event(evt)
+
+    def __getattr__(self, name: str) -> Any:
+        self._fire_event(
+            RecordReplayIssue(
+                msg=f"Unexpected attribute '{name}' accessed on {self.__class__.__name__}"
+            )
+        )
+        return getattr(self.native_handle, name)

dbt/adapters/record/serialization.py

@@ -0,0 +1,115 @@
+import dataclasses
+from datetime import datetime, date
+from decimal import Decimal
+from typing import Any, Dict, TYPE_CHECKING, List, Union, Optional
+
+from dbt_common.record import get_record_row_limit_from_env
+
+RECORDER_ROW_LIMIT: Optional[int] = get_record_row_limit_from_env()
+
+if TYPE_CHECKING:
+    from agate import Table
+    from dbt.adapters.base.relation import BaseRelation
+    from dbt.adapters.base.column import Column as BaseColumn
+
+
+def _column_filter(val: Any) -> Any:
+    return (
+        float(val)
+        if isinstance(val, Decimal)
+        else (
+            str(val)
+            if isinstance(val, datetime)
+            else str(val) if isinstance(val, date) else str(val)
+        )
+    )
+
+
+def serialize_agate_table(table: "Table") -> Dict[str, Any]:
+    rows = []
+
+    if RECORDER_ROW_LIMIT and len(table.rows) > RECORDER_ROW_LIMIT:
+        rows = [
+            [
+                f"Recording Error: Agate table contains {len(table.rows)} rows, maximum is {RECORDER_ROW_LIMIT} rows."
+            ]
+        ]
+    else:
+        for row in table.rows:
+            row = list(map(_column_filter, row))
+            rows.append(row)
+
+    return {
+        "column_names": table.column_names,
+        "column_types": [t.__class__.__name__ for t in table.column_types],
+        "rows": rows,
+    }
+
+
+def serialize_bindings(bindings: Any) -> Union[None, List[Any], str]:
+    if bindings is None:
+        return None
+    elif isinstance(bindings, list):
+        return list(map(_column_filter, bindings))
+    else:
+        return "bindings"
+
+
+def serialize_base_relation(relation: "BaseRelation") -> Dict[str, Any]:
+    """Serialize a BaseRelation object for recording."""
+    return relation.to_dict(omit_none=True)
+
+
+def serialize_base_relation_list(relations: List["BaseRelation"]) -> List[Dict[str, Any]]:
+    """Serialize a list of BaseRelation objects for recording."""
+    if RECORDER_ROW_LIMIT and len(relations) > RECORDER_ROW_LIMIT:
+        return [
+            {
+                "error": f"Recording Error: List of BaseRelation objects contains {len(relations)} objects, maximum is {RECORDER_ROW_LIMIT} objects."
+            }
+        ]
+    else:
+        return [serialize_base_relation(relation) for relation in relations]
+
+
+def deserialize_base_relation(relation_dict: Dict[str, Any]) -> "BaseRelation":
+    """Deserialize a BaseRelation object from a dictionary."""
+    from dbt.adapters.base.relation import BaseRelation
+
+    return BaseRelation.from_dict(relation_dict)
+
+
+def deserialize_base_relation_list(relations_data: List[Dict[str, Any]]) -> List["BaseRelation"]:
+    """Deserialize a list of BaseRelation objects from dictionaries."""
+    return [deserialize_base_relation(relation_dict) for relation_dict in relations_data]
+
+
+def serialize_base_column_list(columns: List["BaseColumn"]) -> List[Dict[str, Any]]:
+    if RECORDER_ROW_LIMIT and len(columns) > RECORDER_ROW_LIMIT:
+        return [
+            {
+                "error": f"Recording Error: List of BaseColumn objects contains {len(columns)} objects, maximum is {RECORDER_ROW_LIMIT} objects."
+            }
+        ]
+    else:
+        return [serialize_base_column(column) for column in columns]
+
+
+def serialize_base_column(column: "BaseColumn") -> Dict[str, Any]:
+    column_dict = dataclasses.asdict(column)
+    return column_dict
+
+
+def deserialize_base_column_list(columns_data: List[Dict[str, Any]]) -> List["BaseColumn"]:
+    return [deserialize_base_column(column_dict) for column_dict in columns_data]
+
+
+def deserialize_base_column(column_dict: Dict[str, Any]) -> "BaseColumn":
+    # Only include fields that are present in the base column class
+    params_dict = {
+        field.name: column_dict[field.name]
+        for field in dataclasses.fields(BaseColumn)
+        if field.name in column_dict
+    }
+
+    return BaseColumn(**params_dict)

dbt/adapters/reference_keys.py

@@ -0,0 +1,39 @@
+# this module exists to resolve circular imports with the events module
+from collections import namedtuple
+from typing import Any, Optional
+
+
+_ReferenceKey = namedtuple("_ReferenceKey", "database schema identifier")
+
+
+def lowercase(value: Optional[str]) -> Optional[str]:
+    if value is None:
+        return None
+    else:
+        return value.lower()
+
+
+# For backwards compatibility. New code should use _make_ref_key
+def _make_key(relation: Any) -> _ReferenceKey:
+    return _make_ref_key(relation)
+
+
+def _make_ref_key(relation: Any) -> _ReferenceKey:
+    """
+    Make _ReferenceKeys with lowercase values for the cache,
+    so we don't have to keep track of quoting
+    """
+    # databases and schemas can both be None
+    return _ReferenceKey(
+        lowercase(relation.database),
+        lowercase(relation.schema),
+        lowercase(relation.identifier),
+    )
+
+
+def _make_ref_key_dict(relation: Any):
+    return {
+        "database": relation.database,
+        "schema": relation.schema,
+        "identifier": relation.identifier,
+    }

dbt/adapters/relation_configs/README.md

@@ -0,0 +1,25 @@
+# RelationConfig
+This package serves as an initial abstraction for managing the inspection of existing relations and determining
+changes on those relations. It arose from the materialized view work and is currently only supporting
+materialized views for Postgres and Redshift as well as dynamic tables for Snowflake. There are three main
+classes in this package.
+
+## RelationConfigBase
+This is a very small class that only has a `from_dict()` method and a default `NotImplementedError()`. At some
+point this could be replaced by a more robust framework, like `mashumaro` or `pydantic`.
+
+## RelationConfigChange
+This class inherits from `RelationConfigBase` ; however, this can be thought of as a separate class. The subclassing
+merely points to the idea that both classes would likely inherit from the same class in a `mashumaro` or
+`pydantic` implementation. This class is much more restricted in attribution. It should really only
+ever need an `action` and a `context`. This can be though of as being analogous to a web request. You need to
+know what you're doing (`action`: 'create' = GET, 'drop' = DELETE, etc.) and the information (`context`) needed
+to make the change. In our scenarios, the context tends to be an instance of `RelationConfigBase` corresponding
+to the new state.
+
+## RelationConfigValidationMixin
+This mixin provides optional validation mechanics that can be applied to either `RelationConfigBase` or
+`RelationConfigChange` subclasses. A validation rule is a combination of a `validation_check`, something
+that should evaluate to `True`, and an optional `validation_error`, an instance of `DbtRuntimeError`
+that should be raised in the event the `validation_check` fails. While optional, it's recommended that
+the `validation_error` be provided for clearer transparency to the end user.

dbt/adapters/relation_configs/__init__.py

@@ -0,0 +1,12 @@
+from dbt.adapters.relation_configs.config_base import (
+    RelationConfigBase,
+    RelationResults,
+)
+from dbt.adapters.relation_configs.config_change import (
+    RelationConfigChange,
+    RelationConfigChangeAction,
+)
+from dbt.adapters.relation_configs.config_validation import (
+    RelationConfigValidationMixin,
+    RelationConfigValidationRule,
+)

dbt/adapters/relation_configs/config_base.py

@@ -0,0 +1,46 @@
+from dataclasses import dataclass
+from typing import Dict, Union, TYPE_CHECKING
+
+from dbt_common.utils import filter_null_values
+
+if TYPE_CHECKING:
+    import agate
+
+
+"""
+This is what relation metadata from the database looks like. It's a dictionary because there will be
+multiple grains of data for a single object. For example, a materialized view in Postgres has base level information,
+like name. But it also can have multiple indexes, which needs to be a separate query. It might look like this:
+
+{
+    "base": agate.Row({"table_name": "table_abc", "query": "select * from table_def"})
+    "indexes": agate.Table("rows": [
+        agate.Row({"name": "index_a", "columns": ["column_a"], "type": "hash", "unique": False}),
+        agate.Row({"name": "index_b", "columns": ["time_dim_a"], "type": "btree", "unique": False}),
+    ])
+}
+"""
+RelationResults = Dict[str, Union["agate.Row", "agate.Table"]]
+
+
+@dataclass(frozen=True)
+class RelationConfigBase:
+    @classmethod
+    def from_dict(cls, kwargs_dict) -> "RelationConfigBase":
+        """
+        This assumes the subclass of `RelationConfigBase` is flat, in the sense that no attribute is
+        itself another subclass of `RelationConfigBase`. If that's not the case, this should be overriden
+        to manually manage that complexity.
+
+        Args:
+            kwargs_dict: the dict representation of this instance
+
+        Returns: the `RelationConfigBase` representation associated with the provided dict
+        """
+        return cls(**filter_null_values(kwargs_dict))
+
+    @classmethod
+    def _not_implemented_error(cls) -> NotImplementedError:
+        return NotImplementedError(
+            "This relation type has not been fully configured for this adapter."
+        )

dbt/adapters/relation_configs/config_change.py

@@ -0,0 +1,26 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Hashable
+
+from dbt_common.dataclass_schema import StrEnum
+
+from dbt.adapters.relation_configs.config_base import RelationConfigBase
+
+
+class RelationConfigChangeAction(StrEnum):
+    alter = "alter"
+    create = "create"
+    drop = "drop"
+
+
+@dataclass(frozen=True, eq=True, unsafe_hash=True)
+class RelationConfigChange(RelationConfigBase, ABC):
+    action: RelationConfigChangeAction
+    context: (
+        Hashable  # this is usually a RelationConfig, e.g. IndexConfig, but shouldn't be limited
+    )
+
+    @property
+    @abstractmethod
+    def requires_full_refresh(self) -> bool:
+        raise self._not_implemented_error()

dbt/adapters/relation_configs/config_validation.py

@@ -0,0 +1,57 @@
+from dataclasses import dataclass
+from typing import Optional, Set
+
+from dbt_common.exceptions import DbtRuntimeError
+
+
+@dataclass(frozen=True, eq=True, unsafe_hash=True)
+class RelationConfigValidationRule:
+    validation_check: bool
+    validation_error: Optional[DbtRuntimeError]
+
+    @property
+    def default_error(self):
+        return DbtRuntimeError(
+            "There was a validation error in preparing this relation config."
+            "No additional context was provided by this adapter."
+        )
+
+
+@dataclass(frozen=True)
+class RelationConfigValidationMixin:
+    def __post_init__(self):
+        self.run_validation_rules()
+
+    @property
+    def validation_rules(self) -> Set[RelationConfigValidationRule]:
+        """
+        A set of validation rules to run against the object upon creation.
+
+        A validation rule is a combination of a validation check (bool) and an optional error message.
+
+        This defaults to no validation rules if not implemented. It's recommended to override this with values,
+        but that may not always be necessary.
+
+        Returns: a set of validation rules
+        """
+        return set()
+
+    def run_validation_rules(self):
+        for validation_rule in self.validation_rules:
+            try:
+                assert validation_rule.validation_check
+            except AssertionError:
+                if validation_rule.validation_error:
+                    raise validation_rule.validation_error
+                else:
+                    raise validation_rule.default_error
+        self.run_child_validation_rules()
+
+    def run_child_validation_rules(self):
+        for attr_value in vars(self).values():
+            if hasattr(attr_value, "validation_rules"):
+                attr_value.run_validation_rules()
+            if isinstance(attr_value, set):
+                for member in attr_value:
+                    if hasattr(member, "validation_rules"):
+                        member.run_validation_rules()

dbt/adapters/sql/__init__.py

@@ -0,0 +1,2 @@
+from dbt.adapters.sql.connections import SQLConnectionManager
+from dbt.adapters.sql.impl import SQLAdapter