dbt-adapters 1.1.1__tar.gz → 1.3.0__tar.gz

{dbt_adapters-1.1.1 → dbt_adapters-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dbt-adapters
-Version: 1.1.1
+Version: 1.3.0
 Summary: The set of adapter protocols and base functionality that supports integration with dbt-core
 Project-URL: Homepage, https://github.com/dbt-labs/dbt-adapters
 Project-URL: Documentation, https://docs.getdbt.com
@@ -23,7 +23,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.8.0
 Requires-Dist: agate<2.0,>=1.0
-Requires-Dist: dbt-common<2.0
+Requires-Dist: dbt-common<2.0,>=1.3
 Requires-Dist: mashumaro[msgpack]<4.0,>=3.0
 Requires-Dist: protobuf<5.0,>=3.0
 Requires-Dist: pytz>=2015.7

dbt_adapters-1.3.0/dbt/adapters/__about__.py

@@ -0,0 +1 @@
+version = "1.3.0"

{dbt_adapters-1.1.1 → dbt_adapters-1.3.0}/dbt/adapters/base/impl.py

@@ -1,10 +1,10 @@
 import abc
+import time
 from concurrent.futures import as_completed, Future
 from contextlib import contextmanager
 from datetime import datetime
 from enum import Enum
 from multiprocessing.context import SpawnContext
-import time
 from typing import (
     Any,
     Callable,
@@ -23,12 +23,15 @@ from typing import (
     TYPE_CHECKING,
 )
 
+import pytz
 from dbt_common.clients.jinja import CallableMacroGenerator
 from dbt_common.contracts.constraints import (
     ColumnLevelConstraint,
     ConstraintType,
     ModelLevelConstraint,
 )
+from dbt_common.contracts.metadata import CatalogTable
+from dbt_common.events.functions import fire_event, warn_or_error
 from dbt_common.exceptions import (
     DbtInternalError,
     DbtRuntimeError,
@@ -38,14 +41,12 @@ from dbt_common.exceptions import (
     NotImplementedError,
     UnexpectedNullError,
 )
-from dbt_common.events.functions import fire_event, warn_or_error
 from dbt_common.utils import (
     AttrDict,
     cast_to_str,
     executor,
     filter_null_values,
 )
-import pytz
 
 from dbt.adapters.base.column import Column as BaseColumn
 from dbt.adapters.base.connections import (
@@ -222,6 +223,7 @@ class BaseAdapter(metaclass=AdapterMeta):
         - truncate_relation
         - rename_relation
         - get_columns_in_relation
+        - get_catalog_for_single_relation
         - get_column_schema_from_query
         - expand_column_types
         - list_relations_without_caching
@@ -627,6 +629,13 @@ class BaseAdapter(metaclass=AdapterMeta):
         """Get a list of the columns in the given Relation."""
         raise NotImplementedError("`get_columns_in_relation` is not implemented for this adapter!")
 
+    @abc.abstractmethod
+    def get_catalog_for_single_relation(self, relation: BaseRelation) -> Optional[CatalogTable]:
+        """Get catalog information including table-level and column-level metadata for a single relation."""
+        raise NotImplementedError(
+            "`get_catalog_for_single_relation` is not implemented for this adapter!"
+        )
+
     @available.deprecated("get_columns_in_relation", lambda *a, **k: [])
     def get_columns_in_table(self, schema: str, identifier: str) -> List[BaseColumn]:
         """DEPRECATED: Get a list of the columns in the given table."""

{dbt_adapters-1.1.1 → dbt_adapters-1.3.0}/dbt/adapters/capability.py

@@ -14,7 +14,12 @@ class Capability(str, Enum):
     """Indicates support for determining the time of the last table modification by querying database metadata."""
 
     TableLastModifiedMetadataBatch = "TableLastModifiedMetadataBatch"
-    """Indicates support for performantly determining the time of the last table modification by querying database metadata in batch."""
+    """Indicates support for performantly determining the time of the last table modification by querying database
+    metadata in batch."""
+
+    GetCatalogForSingleRelation = "GetCatalogForSingleRelation"
+    """Indicates support for getting catalog information including table-level and column-level metadata for a single
+    relation."""
 
 
 class Support(str, Enum):

{dbt_adapters-1.1.1 → dbt_adapters-1.3.0}/dbt/adapters/contracts/relation.py

@@ -18,8 +18,9 @@ class RelationType(StrEnum):
     View = "view"
     CTE = "cte"
     MaterializedView = "materialized_view"
-    External = "external"
     Ephemeral = "ephemeral"
+    # this is a "catch all" that is better than `None` == external to anything dbt is aware of
+    External = "external"
 
 
 class MaterializationContract(Protocol):

dbt_adapters-1.3.0/dbt/adapters/record.py

@@ -0,0 +1,67 @@
+import dataclasses
+from io import StringIO
+import json
+import re
+from typing import Any, Optional, Mapping
+
+from agate import Table
+
+from dbt_common.events.contextvars import get_node_info
+from dbt_common.record import Record, Recorder
+
+from dbt.adapters.contracts.connection import AdapterResponse
+
+
+@dataclasses.dataclass
+class QueryRecordParams:
+    sql: str
+    auto_begin: bool = False
+    fetch: bool = False
+    limit: Optional[int] = None
+    node_unique_id: Optional[str] = None
+
+    def __post_init__(self) -> None:
+        if self.node_unique_id is None:
+            node_info = get_node_info()
+            self.node_unique_id = node_info["unique_id"] if node_info else ""
+
+    @staticmethod
+    def _clean_up_sql(sql: str) -> str:
+        sql = re.sub(r"--.*?\n", "", sql)  # Remove single-line comments (--)
+        sql = re.sub(r"/\*.*?\*/", "", sql, flags=re.DOTALL)  # Remove multi-line comments (/* */)
+        return sql.replace(" ", "").replace("\n", "")
+
+    def _matches(self, other: "QueryRecordParams") -> bool:
+        return self.node_unique_id == other.node_unique_id and self._clean_up_sql(
+            self.sql
+        ) == self._clean_up_sql(other.sql)
+
+
+@dataclasses.dataclass
+class QueryRecordResult:
+    adapter_response: Optional["AdapterResponse"]
+    table: Optional[Table]
+
+    def _to_dict(self) -> Any:
+        buf = StringIO()
+        self.table.to_json(buf)  # type: ignore
+
+        return {
+            "adapter_response": self.adapter_response.to_dict(),  # type: ignore
+            "table": buf.getvalue(),
+        }
+
+    @classmethod
+    def _from_dict(cls, dct: Mapping) -> "QueryRecordResult":
+        return QueryRecordResult(
+            adapter_response=AdapterResponse.from_dict(dct["adapter_response"]),
+            table=Table.from_object(json.loads(dct["table"])),
+        )
+
+
+class QueryRecord(Record):
+    params_cls = QueryRecordParams
+    result_cls = QueryRecordResult
+
+
+Recorder.register_record_type(QueryRecord)

{dbt_adapters-1.1.1 → dbt_adapters-1.3.0}/dbt/adapters/sql/connections.py

@@ -1,10 +1,11 @@
 import abc
 import time
-from typing import Any, Dict, Iterable, List, Optional, Tuple, TYPE_CHECKING
+from typing import Any, Dict, Iterable, Iterator, List, Optional, Tuple, TYPE_CHECKING
 
 from dbt_common.events.contextvars import get_node_info
 from dbt_common.events.functions import fire_event
 from dbt_common.exceptions import DbtInternalError, NotImplementedError
+from dbt_common.record import record_function
 from dbt_common.utils import cast_to_str
 
 from dbt.adapters.base import BaseConnectionManager
@@ -19,6 +20,7 @@ from dbt.adapters.events.types import (
     SQLQuery,
     SQLQueryStatus,
 )
+from dbt.adapters.record import QueryRecord
 
 if TYPE_CHECKING:
     import agate
@@ -110,27 +112,24 @@ class SQLConnectionManager(BaseConnectionManager):
     @classmethod
     def process_results(
         cls, column_names: Iterable[str], rows: Iterable[Any]
-    ) -> List[Dict[str, Any]]:
-        # TODO CT-211
+    ) -> Iterator[Dict[str, Any]]:
         unique_col_names = dict()  # type: ignore[var-annotated]
-        # TODO CT-211
         for idx in range(len(column_names)):  # type: ignore[arg-type]
-            # TODO CT-211
             col_name = column_names[idx]  # type: ignore[index]
             if col_name in unique_col_names:
                 unique_col_names[col_name] += 1
-                # TODO CT-211
                 column_names[idx] = f"{col_name}_{unique_col_names[col_name]}"  # type: ignore[index] # noqa
             else:
-                # TODO CT-211
                 unique_col_names[column_names[idx]] = 1  # type: ignore[index]
-        return [dict(zip(column_names, row)) for row in rows]
+
+        for row in rows:
+            yield dict(zip(column_names, row))
 
     @classmethod
     def get_result_from_cursor(cls, cursor: Any, limit: Optional[int]) -> "agate.Table":
         from dbt_common.clients.agate_helper import table_from_data_flat
 
-        data: List[Any] = []
+        data: Iterable[Any] = []
         column_names: List[str] = []
 
         if cursor.description is not None:
@@ -143,6 +142,7 @@ class SQLConnectionManager(BaseConnectionManager):
 
         return table_from_data_flat(data, column_names)
 
+    @record_function(QueryRecord, method=True, tuple_result=True)
     def execute(
         self,
         sql: str,

{dbt_adapters-1.1.1 → dbt_adapters-1.3.0}/dbt/adapters/sql/impl.py

@@ -1,5 +1,6 @@
 from typing import Any, List, Optional, Tuple, Type, TYPE_CHECKING
 
+from dbt_common.contracts.metadata import CatalogTable
 from dbt_common.events.functions import fire_event
 
 from dbt.adapters.base import BaseAdapter, BaseRelation, available
@@ -9,9 +10,9 @@ from dbt.adapters.events.types import ColTypeChange, SchemaCreation, SchemaDrop
 from dbt.adapters.exceptions import RelationTypeNullError
 from dbt.adapters.sql.connections import SQLConnectionManager
 
-
 LIST_RELATIONS_MACRO_NAME = "list_relations_without_caching"
 GET_COLUMNS_IN_RELATION_MACRO_NAME = "get_columns_in_relation"
+GET_CATALOG_FOR_SINGLE_RELATION_NAME = "get_catalog_for_single_relation"
 LIST_SCHEMAS_MACRO_NAME = "list_schemas"
 CHECK_SCHEMA_EXISTS_MACRO_NAME = "check_schema_exists"
 CREATE_SCHEMA_MACRO_NAME = "create_schema"
@@ -41,6 +42,7 @@ class SQLAdapter(BaseAdapter):
         - get_catalog
         - list_relations_without_caching
         - get_columns_in_relation
+        - get_catalog_for_single_relation
     """
 
     ConnectionManager: Type[SQLConnectionManager]
@@ -158,6 +160,11 @@ class SQLAdapter(BaseAdapter):
             GET_COLUMNS_IN_RELATION_MACRO_NAME, kwargs={"relation": relation}
         )
 
+    def get_catalog_for_single_relation(self, relation: BaseRelation) -> Optional[CatalogTable]:
+        return self.execute_macro(
+            GET_CATALOG_FOR_SINGLE_RELATION_NAME, kwargs={"relation": relation}
+        )
+
     def create_schema(self, relation: BaseRelation) -> None:
         relation = relation.without_identifier()
         fire_event(SchemaCreation(relation=_make_ref_key_dict(relation)))

{dbt_adapters-1.1.1 → dbt_adapters-1.3.0}/dbt/include/global_project/macros/adapters/metadata.sql

@@ -77,6 +77,15 @@
     'list_relations_without_caching macro not implemented for adapter '+adapter.type()) }}
 {% endmacro %}
 
+{% macro get_catalog_for_single_relation(relation) %}
+  {{ return(adapter.dispatch('get_catalog_for_single_relation', 'dbt')(relation)) }}
+{% endmacro %}
+
+{% macro default__get_catalog_for_single_relation(relation) %}
+  {{ exceptions.raise_not_implemented(
+    'get_catalog_for_single_relation macro not implemented for adapter '+adapter.type()) }}
+{% endmacro %}
+
 {% macro get_relations() %}
   {{ return(adapter.dispatch('get_relations', 'dbt')()) }}
 {% endmacro %}

{dbt_adapters-1.1.1 → dbt_adapters-1.3.0}/dbt/include/global_project/macros/unit_test_sql/get_fixture_sql.sql

@@ -15,7 +15,7 @@
 {%- endif -%}
 
 {%- if not column_name_to_data_types -%}
-    {{ exceptions.raise_compiler_error("Not able to get columns for unit test '" ~ model.name ~ "' from relation " ~ this) }}
+    {{ exceptions.raise_compiler_error("Not able to get columns for unit test '" ~ model.name ~ "' from relation " ~ this ~ " because the relation doesn't exist") }}
 {%- endif -%}
 
 {%- for column_name, column_type in column_name_to_data_types.items() -%}

{dbt_adapters-1.1.1 → dbt_adapters-1.3.0}/pyproject.toml

@@ -24,7 +24,7 @@ classifiers = [
     "Programming Language :: Python :: 3.12",
 ]
 dependencies = [
-    "dbt-common<2.0",
+    "dbt-common>=1.3,<2.0",
     "pytz>=2015.7",
     # installed via dbt-common but used directly
     "agate>=1.0,<2.0",
@@ -43,6 +43,9 @@ Changelog = "https://github.com/dbt-labs/dbt-adapters/blob/main/CHANGELOG.md"
 requires = ["hatchling"]
 build-backend = "hatchling.build"
 
+[tool.hatch.metadata]
+allow-direct-references = true
+
 [tool.hatch.version]
 path = "dbt/adapters/__about__.py"
 

dbt_adapters-1.1.1/dbt/adapters/__about__.py

@@ -1 +0,0 @@
-version = "1.1.1"