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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dbt-adapters
-Version: 1.1.1
+Version: 1.2.1
 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

dbt_adapters-1.2.1/dbt/adapters/__about__.py

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

{dbt_adapters-1.1.1 → dbt_adapters-1.2.1}/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.2.1/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.2.1}/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.2.1}/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/__about__.py

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