dbt-adapters 1.3.3__tar.gz → 1.4.0__tar.gz

{dbt_adapters-1.3.3 → dbt_adapters-1.4.0}/.gitignore

@@ -158,7 +158,7 @@ cython_debug/
 # MacOS
 .DS_Store
 
-# vscode
+# VSCode
 .vscode/
 .venv/
 

{dbt_adapters-1.3.3 → dbt_adapters-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dbt-adapters
-Version: 1.3.3
+Version: 1.4.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
@@ -11,7 +11,7 @@ Author-email: dbt Labs <info@dbtlabs.com>
 Maintainer-email: dbt Labs <info@dbtlabs.com>
 License-File: LICENSE
 Keywords: adapter,adapters,database,dbt,dbt Cloud,dbt Core,dbt Labs,dbt-core,elt
-Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: Microsoft :: Windows
@@ -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,>=1.3
+Requires-Dist: dbt-common<2.0,>=1.6
 Requires-Dist: mashumaro[msgpack]<4.0,>=3.0
 Requires-Dist: protobuf<5.0,>=3.0
 Requires-Dist: pytz>=2015.7

dbt_adapters-1.4.0/dbt/adapters/__about__.py

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

{dbt_adapters-1.3.3 → dbt_adapters-1.4.0}/dbt/adapters/base/column.py

@@ -123,9 +123,6 @@ class Column:
         else:
             return "{}({},{})".format(dtype, precision, scale)
 
-    def __repr__(self) -> str:
-        return "<Column {} ({})>".format(self.name, self.data_type)
-
     @classmethod
     def from_description(cls, name: str, raw_data_type: str) -> "Column":
         match = re.match(r"([^(]+)(\([^)]+\))?", raw_data_type)

{dbt_adapters-1.3.3 → dbt_adapters-1.4.0}/dbt/adapters/base/impl.py

@@ -1602,8 +1602,13 @@ class BaseAdapter(metaclass=AdapterMeta):
             rendered_column_constraint = f"unique {constraint_expression}"
         elif constraint.type == ConstraintType.primary_key:
             rendered_column_constraint = f"primary key {constraint_expression}"
-        elif constraint.type == ConstraintType.foreign_key and constraint_expression:
-            rendered_column_constraint = f"references {constraint_expression}"
+        elif constraint.type == ConstraintType.foreign_key:
+            if constraint.to and constraint.to_columns:
+                rendered_column_constraint = (
+                    f"references {constraint.to} ({', '.join(constraint.to_columns)})"
+                )
+            elif constraint_expression:
+                rendered_column_constraint = f"references {constraint_expression}"
         elif constraint.type == ConstraintType.custom and constraint_expression:
             rendered_column_constraint = constraint_expression
 
@@ -1682,20 +1687,29 @@ class BaseAdapter(metaclass=AdapterMeta):
         rendering."""
         constraint_prefix = f"constraint {constraint.name} " if constraint.name else ""
         column_list = ", ".join(constraint.columns)
+        rendered_model_constraint = None
+
         if constraint.type == ConstraintType.check and constraint.expression:
-            return f"{constraint_prefix}check ({constraint.expression})"
+            rendered_model_constraint = f"{constraint_prefix}check ({constraint.expression})"
         elif constraint.type == ConstraintType.unique:
             constraint_expression = f" {constraint.expression}" if constraint.expression else ""
-            return f"{constraint_prefix}unique{constraint_expression} ({column_list})"
+            rendered_model_constraint = (
+                f"{constraint_prefix}unique{constraint_expression} ({column_list})"
+            )
         elif constraint.type == ConstraintType.primary_key:
             constraint_expression = f" {constraint.expression}" if constraint.expression else ""
-            return f"{constraint_prefix}primary key{constraint_expression} ({column_list})"
-        elif constraint.type == ConstraintType.foreign_key and constraint.expression:
-            return f"{constraint_prefix}foreign key ({column_list}) references {constraint.expression}"
+            rendered_model_constraint = (
+                f"{constraint_prefix}primary key{constraint_expression} ({column_list})"
+            )
+        elif constraint.type == ConstraintType.foreign_key:
+            if constraint.to and constraint.to_columns:
+                rendered_model_constraint = f"{constraint_prefix}foreign key ({column_list}) references {constraint.to} ({', '.join(constraint.to_columns)})"
+            elif constraint.expression:
+                rendered_model_constraint = f"{constraint_prefix}foreign key ({column_list}) references {constraint.expression}"
         elif constraint.type == ConstraintType.custom and constraint.expression:
-            return f"{constraint_prefix}{constraint.expression}"
-        else:
-            return None
+            rendered_model_constraint = f"{constraint_prefix}{constraint.expression}"
+
+        return rendered_model_constraint
 
     @classmethod
     def capabilities(cls) -> CapabilityDict:

dbt_adapters-1.4.0/dbt/adapters/record/__init__.py

@@ -0,0 +1,2 @@
+from dbt.adapters.record.handle import RecordReplayHandle
+from dbt.adapters.record.cursor.cursor import RecordReplayCursor

dbt_adapters-1.4.0/dbt/adapters/record/cursor/cursor.py

@@ -0,0 +1,54 @@
+from typing import Any, Optional
+
+from dbt_common.record import record_function
+
+from dbt.adapters.contracts.connection import Connection
+from dbt.adapters.record.cursor.description import CursorGetDescriptionRecord
+from dbt.adapters.record.cursor.execute import CursorExecuteRecord
+from dbt.adapters.record.cursor.fetchone import CursorFetchOneRecord
+from dbt.adapters.record.cursor.fetchmany import CursorFetchManyRecord
+from dbt.adapters.record.cursor.fetchall import CursorFetchAllRecord
+from dbt.adapters.record.cursor.rowcount import CursorGetRowCountRecord
+
+
+class RecordReplayCursor:
+    """A proxy object used to wrap native database cursors under record/replay
+    modes. In record mode, this proxy notes the parameters and return values
+    of the methods and properties it implements, which closely match the Python
+    DB API 2.0 cursor methods used by many dbt adapters to interact with the
+    database or DWH. In replay mode, it mocks out those calls using previously
+    recorded calls, so that no interaction with a database actually occurs."""
+
+    def __init__(self, native_cursor: Any, connection: Connection) -> None:
+        self.native_cursor = native_cursor
+        self.connection = connection
+
+    @record_function(CursorExecuteRecord, method=True, id_field_name="connection_name")
+    def execute(self, operation, parameters=None) -> None:
+        self.native_cursor.execute(operation, parameters)
+
+    @record_function(CursorFetchOneRecord, method=True, id_field_name="connection_name")
+    def fetchone(self) -> Any:
+        return self.native_cursor.fetchone()
+
+    @record_function(CursorFetchManyRecord, method=True, id_field_name="connection_name")
+    def fetchmany(self, size: int) -> Any:
+        return self.native_cursor.fetchmany(size)
+
+    @record_function(CursorFetchAllRecord, method=True, id_field_name="connection_name")
+    def fetchall(self) -> Any:
+        return self.native_cursor.fetchall()
+
+    @property
+    def connection_name(self) -> Optional[str]:
+        return self.connection.name
+
+    @property
+    @record_function(CursorGetRowCountRecord, method=True, id_field_name="connection_name")
+    def rowcount(self) -> int:
+        return self.native_cursor.rowcount
+
+    @property
+    @record_function(CursorGetDescriptionRecord, method=True, id_field_name="connection_name")
+    def description(self) -> str:
+        return self.native_cursor.description

dbt_adapters-1.4.0/dbt/adapters/record/cursor/description.py

@@ -0,0 +1,37 @@
+import dataclasses
+from typing import Any, Iterable, Mapping
+
+from dbt_common.record import Record, Recorder
+
+
+@dataclasses.dataclass
+class CursorGetDescriptionParams:
+    connection_name: str
+
+
+@dataclasses.dataclass
+class CursorGetDescriptionResult:
+    columns: Iterable[Any]
+
+    def _to_dict(self) -> Any:
+        column_dicts = []
+        for c in self.columns:
+            # This captures the mandatory column information, but we might need
+            # more for some adapters.
+            # See https://peps.python.org/pep-0249/#description
+            column_dicts.append((c[0], c[1]))
+
+        return {"columns": column_dicts}
+
+    @classmethod
+    def _from_dict(cls, dct: Mapping) -> "CursorGetDescriptionResult":
+        return CursorGetDescriptionResult(columns=dct["columns"])
+
+
+@Recorder.register_record_type
+class CursorGetDescriptionRecord(Record):
+    """Implements record/replay support for the cursor.description property."""
+
+    params_cls = CursorGetDescriptionParams
+    result_cls = CursorGetDescriptionResult
+    group = "Database"

dbt_adapters-1.4.0/dbt/adapters/record/cursor/execute.py

@@ -0,0 +1,20 @@
+import dataclasses
+from typing import Any, Iterable, Union, Mapping
+
+from dbt_common.record import Record, Recorder
+
+
+@dataclasses.dataclass
+class CursorExecuteParams:
+    connection_name: str
+    operation: str
+    parameters: Union[Iterable[Any], Mapping[str, Any]]
+
+
+@Recorder.register_record_type
+class CursorExecuteRecord(Record):
+    """Implements record/replay support for the cursor.execute() method."""
+
+    params_cls = CursorExecuteParams
+    result_cls = None
+    group = "Database"

dbt_adapters-1.4.0/dbt/adapters/record/cursor/fetchall.py

@@ -0,0 +1,66 @@
+import dataclasses
+import datetime
+from typing import Any, Dict, List, Mapping
+
+from dbt_common.record import Record, Recorder
+
+
+@dataclasses.dataclass
+class CursorFetchAllParams:
+    connection_name: str
+
+
+@dataclasses.dataclass
+class CursorFetchAllResult:
+    results: List[Any]
+
+    def _to_dict(self) -> Dict[str, Any]:
+        processed_results = []
+        for result in self.results:
+            result = tuple(map(self._process_value, result))
+            processed_results.append(result)
+
+        return {"results": processed_results}
+
+    @classmethod
+    def _from_dict(cls, dct: Mapping) -> "CursorFetchAllResult":
+        unprocessed_results = []
+        for result in dct["results"]:
+            result = tuple(map(cls._unprocess_value, result))
+            unprocessed_results.append(result)
+
+        return CursorFetchAllResult(unprocessed_results)
+
+    @classmethod
+    def _process_value(cls, value: Any) -> Any:
+        if type(value) is datetime.date:
+            return {"type": "date", "value": value.isoformat()}
+        elif type(value) is datetime.datetime:
+            return {"type": "datetime", "value": value.isoformat()}
+        else:
+            return value
+
+    @classmethod
+    def _unprocess_value(cls, value: Any) -> Any:
+        if type(value) is dict:
+            value_type = value.get("type")
+            if value_type == "date":
+                date_string = value.get("value")
+                assert isinstance(date_string, str)
+                return datetime.date.fromisoformat(date_string)
+            elif value_type == "datetime":
+                date_string = value.get("value")
+                assert isinstance(date_string, str)
+                return datetime.datetime.fromisoformat(date_string)
+            return value
+        else:
+            return value
+
+
+@Recorder.register_record_type
+class CursorFetchAllRecord(Record):
+    """Implements record/replay support for the cursor.fetchall() method."""
+
+    params_cls = CursorFetchAllParams
+    result_cls = CursorFetchAllResult
+    group = "Database"

dbt_adapters-1.4.0/dbt/adapters/record/cursor/fetchmany.py

@@ -0,0 +1,23 @@
+import dataclasses
+from typing import Any, List
+
+from dbt_common.record import Record, Recorder
+
+
+@dataclasses.dataclass
+class CursorFetchManyParams:
+    connection_name: str
+
+
+@dataclasses.dataclass
+class CursorFetchManyResult:
+    results: List[Any]
+
+
+@Recorder.register_record_type
+class CursorFetchManyRecord(Record):
+    """Implements record/replay support for the cursor.fetchmany() method."""
+
+    params_cls = CursorFetchManyParams
+    result_cls = CursorFetchManyResult
+    group = "Database"

dbt_adapters-1.4.0/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-1.4.0/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-1.4.0/dbt/adapters/record/handle.py

@@ -0,0 +1,24 @@
+from typing import Any
+
+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)

{dbt_adapters-1.3.3 → dbt_adapters-1.4.0}/dbt/adapters/sql/connections.py

@@ -5,7 +5,6 @@ from typing import Any, Dict, Iterable, Iterator, List, Optional, Tuple, TYPE_CH
 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
@@ -20,7 +19,6 @@ from dbt.adapters.events.types import (
     SQLQuery,
     SQLQueryStatus,
 )
-from dbt.adapters.record import QueryRecord
 
 if TYPE_CHECKING:
     import agate
@@ -143,7 +141,6 @@ 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.3.3 → dbt_adapters-1.4.0}/dbt/include/global_project/macros/materializations/models/incremental/incremental.sql

@@ -39,9 +39,12 @@
       {% set need_swap = true %}
   {% else %}
     {% do run_query(get_create_table_as_sql(True, temp_relation, sql)) %}
-    {% do adapter.expand_target_column_types(
-             from_relation=temp_relation,
-             to_relation=target_relation) %}
+    {% set contract_config = config.get('contract') %}
+    {% if not contract_config or not contract_config.enforced %}
+      {% do adapter.expand_target_column_types(
+               from_relation=temp_relation,
+               to_relation=target_relation) %}
+    {% endif %}
     {#-- Process schema changes. Returns dict of changes if successful. Use source columns for upserting/merging --#}
     {% set dest_columns = process_schema_changes(on_schema_change, temp_relation, existing_relation) %}
     {% if not dest_columns %}

{dbt_adapters-1.3.3 → dbt_adapters-1.4.0}/dbt/include/global_project/macros/unit_test_sql/get_fixture_sql.sql

@@ -22,6 +22,7 @@
     {%- do default_row.update({column_name: (safe_cast("null", column_type) | trim )}) -%}
 {%- endfor -%}
 
+{{ validate_fixture_rows(rows, row_number) }}
 
 {%- for row in rows -%}
 {%-   set formatted_row = format_row(row, column_name_to_data_types) -%}
@@ -93,3 +94,11 @@ union all
     {%- endfor -%}
     {{ return(formatted_row) }}
 {%- endmacro -%}
+
+{%- macro validate_fixture_rows(rows, row_number) -%}
+  {{ return(adapter.dispatch('validate_fixture_rows', 'dbt')(rows, row_number)) }}
+{%- endmacro -%}
+
+{%- macro default__validate_fixture_rows(rows, row_number) -%}
+  {# This is an abstract method for adapter overrides as needed #}
+{%- endmacro -%}

{dbt_adapters-1.3.3 → dbt_adapters-1.4.0}/pyproject.toml

@@ -12,7 +12,7 @@ maintainers = [
     { name = "dbt Labs", email = "info@dbtlabs.com" },
 ]
 classifiers = [
-    "Development Status :: 2 - Pre-Alpha",
+    "Development Status :: 5 - Production/Stable",
     "License :: OSI Approved :: Apache Software License",
     "Operating System :: MacOS :: MacOS X",
     "Operating System :: Microsoft :: Windows",
@@ -24,7 +24,7 @@ classifiers = [
     "Programming Language :: Python :: 3.12",
 ]
 dependencies = [
-    "dbt-common>=1.3,<2.0",
+    "dbt-common>=1.6,<2.0",
     "pytz>=2015.7",
     # installed via dbt-common but used directly
     "agate>=1.0,<2.0",
@@ -43,9 +43,6 @@ 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"
 
@@ -60,20 +57,14 @@ dependencies = [
     "dbt_common @ git+https://github.com/dbt-labs/dbt-common.git",
     'pre-commit==3.7.0;python_version>="3.9"',
     'pre-commit==3.5.0;python_version=="3.8"',
-]
-[tool.hatch.envs.default.scripts]
-dev = "pre-commit install"
-code-quality = "pre-commit run --all-files"
-
-[tool.hatch.envs.unit-tests]
-dependencies = [
-    "dbt_common @ git+https://github.com/dbt-labs/dbt-common.git",
     "pytest",
     "pytest-dotenv",
     "pytest-xdist",
 ]
-[tool.hatch.envs.unit-tests.scripts]
-all = "python -m pytest {args:tests/unit}"
+[tool.hatch.envs.default.scripts]
+setup = "pre-commit install"
+code-quality = "pre-commit run --all-files"
+unit-tests = "python -m pytest {args:tests/unit}"
 
 [tool.hatch.envs.build]
 detached = true

dbt_adapters-1.3.3/dbt/adapters/__about__.py

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

dbt_adapters-1.3.3/dbt/adapters/record.py

@@ -1,67 +0,0 @@
-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)