dbt-adapters 1.14.3__tar.gz → 1.14.5__tar.gz

{dbt_adapters-1.14.3 → dbt_adapters-1.14.5}/.changes/1.14.3.md

@@ -12,5 +12,3 @@
 
 - Add node_checksum to NodeInfo in structured logs ([#883](https://github.com/dbt-labs/dbt-adapters/issues/883))
 - Make use of new record/replay features to enable recording "available" functions ([#761](https://github.com/dbt-labs/dbt-adapters/issues/761))
-
-

dbt_adapters-1.14.5/.changes/1.14.4.md

@@ -0,0 +1,9 @@
+## dbt-adapters 1.14.4 - March 31, 2025
+
+### Features
+
+- Make source and target tables able to be referenced via DBT_INTERNAL_DEST and DBT_INTERNAL_SOURCE for the delete/insert incremental strategy ([#910](https://github.com/dbt-labs/dbt-adapters/issues/910))
+
+### Fixes
+
+- Fix the python model empty/sample mode fix to not break when the ref macro has been overridden ([#953](https://github.com/dbt-labs/dbt-adapters/issues/953))

dbt_adapters-1.14.5/.changes/1.14.5.md

@@ -0,0 +1,9 @@
+## dbt-adapters 1.14.5 - April 07, 2025
+
+### Fixes
+
+- Create indexes on the intermediate relation before the swap ([#966](https://github.com/dbt-labs/dbt-adapters/issues/966))
+- Create indexes on the intermediate relation before the swap for incremental models ([#966](https://github.com/dbt-labs/dbt-adapters/issues/966))
+
+### Contributors
+- [@etx121](https://github.com/etx121) ([#966](https://github.com/dbt-labs/dbt-adapters/issues/966), [#966](https://github.com/dbt-labs/dbt-adapters/issues/966))

{dbt_adapters-1.14.3 → dbt_adapters-1.14.5}/CHANGELOG.md

@@ -10,6 +10,27 @@ and is generated by [Changie](https://github.com/miniscruff/changie)
 - Do not edit this file directly. This file is auto-generated using [changie](https://github.com/miniscruff/changie)
 - For details on how to document a change, see the [contributing guide](/CONTRIBUTING.md#changelog-entry)
 
+## dbt-adapters 1.14.5 - April 07, 2025
+
+### Fixes
+
+- Create indexes on the intermediate relation before the swap ([#966](https://github.com/dbt-labs/dbt-adapters/issues/966))
+- Create indexes on the intermediate relation before the swap for incremental models ([#966](https://github.com/dbt-labs/dbt-adapters/issues/966))
+
+### Contributors
+- [@etx121](https://github.com/etx121) ([#966](https://github.com/dbt-labs/dbt-adapters/issues/966), [#966](https://github.com/dbt-labs/dbt-adapters/issues/966))
+
+
+## dbt-adapters 1.14.4 - March 31, 2025
+
+### Features
+
+- Make source and target tables able to be referenced via DBT_INTERNAL_DEST and DBT_INTERNAL_SOURCE for the delete/insert incremental strategy ([#910](https://github.com/dbt-labs/dbt-adapters/issues/910))
+
+### Fixes
+
+- Fix the python model empty/sample mode fix to not break when the ref macro has been overridden ([#953](https://github.com/dbt-labs/dbt-adapters/issues/953))
+
 ## dbt-adapters 1.14.3 - March 19, 2025
 
 ### Features
@@ -25,8 +46,6 @@ and is generated by [Changie](https://github.com/miniscruff/changie)
 - Add node_checksum to NodeInfo in structured logs ([#883](https://github.com/dbt-labs/dbt-adapters/issues/883))
 - Make use of new record/replay features to enable recording "available" functions ([#761](https://github.com/dbt-labs/dbt-adapters/issues/761))
 
-
-
 ## dbt-adapters 1.14.1 - March 04, 2025
 
 ### Fixes

{dbt_adapters-1.14.3 → dbt_adapters-1.14.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dbt-adapters
-Version: 1.14.3
+Version: 1.14.5
 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/tree/main/dbt-adapters
 Project-URL: Documentation, https://docs.getdbt.com

dbt_adapters-1.14.5/src/dbt/adapters/__about__.py

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

{dbt_adapters-1.14.3 → dbt_adapters-1.14.5}/src/dbt/adapters/base/impl.py

@@ -77,6 +77,7 @@ from dbt.adapters.catalogs import (
     CatalogIntegration,
     CatalogIntegrationClient,
     CatalogIntegrationConfig,
+    CatalogRelation,
 )
 from dbt.adapters.contracts.connection import Credentials
 from dbt.adapters.contracts.macros import MacroResolverProtocol
@@ -283,7 +284,7 @@ class BaseAdapter(metaclass=AdapterMeta):
     Relation: Type[BaseRelation] = BaseRelation
     Column: Type[BaseColumn] = BaseColumn
     ConnectionManager: Type[BaseConnectionManager]
-    CATALOG_INTEGRATIONS: Dict[str, Type[CatalogIntegration]] = {}
+    CATALOG_INTEGRATIONS: Iterable[Type[CatalogIntegration]] = []
 
     # A set of clobber config fields accepted by this adapter
     # for use in materializations
@@ -312,13 +313,20 @@ class BaseAdapter(metaclass=AdapterMeta):
         self.behavior = DEFAULT_BASE_BEHAVIOR_FLAGS  # type: ignore
         self._catalog_client = CatalogIntegrationClient(self.CATALOG_INTEGRATIONS)
 
-    def add_catalog_integration(self, catalog: CatalogIntegrationConfig) -> CatalogIntegration:
-        return self._catalog_client.add(catalog)
+    def add_catalog_integration(
+        self, catalog_integration: CatalogIntegrationConfig
+    ) -> CatalogIntegration:
+        return self._catalog_client.add(catalog_integration)
 
     @available
     def get_catalog_integration(self, name: str) -> CatalogIntegration:
         return self._catalog_client.get(name)
 
+    @available
+    def build_catalog_relation(self, config: RelationConfig) -> CatalogRelation:
+        catalog = self.get_catalog_integration(config.catalog)
+        return catalog.build_relation(config)
+
     ###
     # Methods to set / access a macro resolver
     ###

{dbt_adapters-1.14.3 → dbt_adapters-1.14.5}/src/dbt/adapters/base/relation.py

@@ -60,7 +60,7 @@ class BaseRelation(FakeAPIObject, Hashable):
     require_alias: bool = (
         True  # used to govern whether to add an alias when render_limited is called
     )
-    catalog_name: Optional[str] = None
+    catalog: Optional[str] = None
 
     # register relation types that can be renamed for the purpose of replacing relations using stages and backups
     # adding a relation type here also requires defining the associated rename macro

{dbt_adapters-1.14.3 → dbt_adapters-1.14.5}/src/dbt/adapters/catalogs/__init__.py

@@ -7,4 +7,5 @@ from dbt.adapters.catalogs._exceptions import (
 from dbt.adapters.catalogs._integration import (
     CatalogIntegration,
     CatalogIntegrationConfig,
+    CatalogRelation,
 )

{dbt_adapters-1.14.3 → dbt_adapters-1.14.5}/src/dbt/adapters/catalogs/_client.py

@@ -1,4 +1,4 @@
-from typing import Dict, Type
+from typing import Dict, Iterable, Type
 
 from dbt.adapters.catalogs._exceptions import (
     DbtCatalogIntegrationAlreadyExistsError,
@@ -26,29 +26,29 @@ class CatalogIntegrationClient:
             integration names mapped to their instances
     """
 
-    def __init__(self, supported_catalogs: Dict[str, Type[CatalogIntegration]]):
-        self.__supported_catalogs = supported_catalogs
+    def __init__(self, supported_catalogs: Iterable[Type[CatalogIntegration]]):
+        self.__supported_catalogs: Dict[str, Type[CatalogIntegration]] = {
+            catalog.catalog_type: catalog for catalog in supported_catalogs
+        }
         self.__catalog_integrations: Dict[str, CatalogIntegration] = {}
 
-    def add(self, catalog_integration: CatalogIntegrationConfig) -> CatalogIntegration:
-        try:
-            catalog_factory = self.__supported_catalogs[catalog_integration.catalog_type]
-        except KeyError:
-            raise DbtCatalogIntegrationNotSupportedError(
-                catalog_integration.catalog_type, self.__supported_catalogs.keys()
-            )
-
-        if catalog_integration.name in self.__catalog_integrations.keys():
-            raise DbtCatalogIntegrationAlreadyExistsError(catalog_integration.name)
-
-        self.__catalog_integrations[catalog_integration.name] = catalog_factory(
-            catalog_integration
-        )
-
-        return self.get(catalog_integration.name)
+    def add(self, config: CatalogIntegrationConfig) -> CatalogIntegration:
+        factory = self.__catalog_integration_factory(config.catalog_type)
+        if config.name in self.__catalog_integrations:
+            raise DbtCatalogIntegrationAlreadyExistsError(config.name)
+        self.__catalog_integrations[config.name] = factory(config)
+        return self.get(config.name)
 
     def get(self, name: str) -> CatalogIntegration:
         try:
             return self.__catalog_integrations[name]
         except KeyError:
             raise DbtCatalogIntegrationNotFoundError(name, self.__catalog_integrations.keys())
+
+    def __catalog_integration_factory(self, catalog_type: str) -> Type[CatalogIntegration]:
+        try:
+            return self.__supported_catalogs[catalog_type]
+        except KeyError as e:
+            raise DbtCatalogIntegrationNotSupportedError(
+                catalog_type, self.__supported_catalogs.keys()
+            ) from e

{dbt_adapters-1.14.3 → dbt_adapters-1.14.5}/src/dbt/adapters/catalogs/_integration.py

@@ -1,7 +1,9 @@
-from enum import Enum
+import abc
 from typing import Any, Dict, Optional
 from typing_extensions import Protocol
 
+from dbt.adapters.contracts.relation import RelationConfig
+
 
 class CatalogIntegrationConfig(Protocol):
     """
@@ -14,62 +16,95 @@ class CatalogIntegrationConfig(Protocol):
     ensuring a standardized structure and attributes are in place.
 
     Attributes:
-        name (str): the name of the catalog integration in the data platform, e.g. "my_favorite_iceberg_catalog"
-            - this is required for dbt to correctly reference catalogs by name from model configuration
-            - expected to be unique within the adapter, if not the entire data platform
+        name (str): the name of the catalog integration in the dbt project, e.g. "my_iceberg_operational_data"
+            - a unique name for this catalog integration to be referenced in a model configuration
         catalog_type (str): the type of the catalog integration in the data platform, e.g. "iceberg_rest"
             - this is required for dbt to determine the correct method for parsing user configuration
             - usually a combination of the catalog and the way in which the data platform interacts with it
+        catalog_name (Optional[str]): the name of the catalog integration in the data platform, e.g. "my_favorite_iceberg_catalog"
+            - this is required for dbt to correctly reference catalogs by name from model configuration
+            - expected to be unique within the data platform, but many dbt catalog integrations can share the same catalog name
         table_format (Optional[str]): the table format this catalog uses
             - this is commonly unique to each catalog type, and should only be required from the user for catalogs that support multiple formats
         external_volume (Optional[str]): external storage volume identifier
             - while this is a separate concept from catalogs, we feel it is more user-friendly to group it with the catalog configuration
+            - it's possible to use a default external volume at the user, database, or account level, hence this is optional
             - a result of this grouping is that there can only be one external volume per catalog integration, but many catalogs can share the same volume
+            - a user should create a new dbt catalog if they want to use a different external volume for a given catalog integration
         adapter_properties (Optional[Dict[str, Any]]):
             - additional, adapter-specific properties are nested here to avoid future collision when expanding the catalog integration protocol
     """
 
     name: str
     catalog_type: str
+    catalog_name: Optional[str]
     table_format: Optional[str]
     external_volume: Optional[str]
-    adapter_properties: Optional[Dict[str, Any]]
+    adapter_properties: Dict[str, Any]
 
 
-class CatalogIntegrationMode(Enum):
-    READ = "r"
-    WRITE = "w"
+class CatalogRelation(Protocol):
+    catalog_name: Optional[str]
+    table_format: Optional[str]
+    external_volume: Optional[str]
 
 
-class CatalogIntegration:
+class CatalogIntegration(abc.ABC):
     """
     Represent a catalog integration for a given user config
 
-    This class should be subclassed by specific catalog integration types in an adapter.
+    This class should be implemented by specific catalog integration types in an adapter.
     A catalog integration is a specific platform's way of interacting with a specific catalog.
 
     Attributes:
-        name (str): the name of the catalog integration in the data platform, e.g. "my_favorite_iceberg_catalog"
-            - this is required for dbt to correctly reference catalogs by name from model configuration
-            - expected to be unique within the adapter, if not the entire data platform
+        name (str): the name of the catalog integration in the dbt project, e.g. "my_iceberg_operational_data"
+            - a unique name for this catalog integration to be referenced in a model configuration
         catalog_type (str): the type of the catalog integration in the data platform, e.g. "iceberg_rest"
-            - this is required for dbt to determine the correct method for parsing user configuration
-            - usually a combination of the catalog and the way in which the data platform interacts with it
-        allows_writes (bool): identifies whether this catalog integration supports writes
-            - this is required for dbt to correctly identify whether a catalog is writable during parse time
-            - this is determined by the catalog integration type, hence it is a class attribute
+            - this is a name for this particular implementation of the catalog integration, hence it is a class attribute
+        catalog_name (Optional[str]): the name of the catalog integration in the data platform, e.g. "my_favorite_iceberg_catalog"
+            - this is required for dbt to correctly reference catalogs by name from model configuration
+            - expected to be unique within the data platform, but many dbt catalog integrations can share the same catalog name
         table_format (Optional[str]): the table format this catalog uses
-            - this is commonly determined by the catalog integration type, hence it is usually a class attribute
-            - it should only be required from the user for catalogs that support multiple formats
+            - this is commonly unique to each catalog type, and should only be required from the user for catalogs that support multiple formats
         external_volume (Optional[str]): external storage volume identifier
             - while this is a separate concept from catalogs, we feel it is more user-friendly to group it with the catalog configuration
+            - it's possible to use a default external volume at the user, database, or account level, hence this is optional
             - a result of this grouping is that there can only be one external volume per catalog integration, but many catalogs can share the same volume
+            - a user should create a new dbt catalog if they want to use a different external volume for a given catalog integration
+        allows_writes (bool): identifies whether this catalog integration supports writes
+            - this is required for dbt to correctly identify whether a catalog is writable during parse time
+            - this is determined by the catalog integration type, hence it is a class attribute
     """
 
-    allows_writes: CatalogIntegrationMode = CatalogIntegrationMode.READ
+    catalog_type: str
+    table_format: Optional[str] = None
+    allows_writes: bool = False
+
+    def __init__(self, config: CatalogIntegrationConfig) -> None:
+        # table_format is often fixed for a catalog type, allow it to be defined at the class level
+        if config.table_format is not None:
+            self.table_format = config.table_format
 
-    def __init__(self, config: CatalogIntegrationConfig):
         self.name: str = config.name
-        self.catalog_type: str = config.catalog_type
-        self.table_format: Optional[str] = config.table_format or None
-        self.external_volume: Optional[str] = config.external_volume or None
+        self.catalog_name: Optional[str] = config.catalog_name
+        self.external_volume: Optional[str] = config.external_volume
+
+    def build_relation(self, config: RelationConfig) -> CatalogRelation:
+        """
+        Builds relation configuration within the context of this catalog integration.
+
+        This method is a placeholder and must be implemented in subclasses to provide
+        custom logic for building a relation.
+
+        Args:
+            config: User-provided model configuration.
+
+        Returns:
+            A `CatalogRelation` object constructed based on the input configuration.
+
+        Raises:
+            NotImplementedError: Raised when this method is not implemented in a subclass.
+        """
+        raise NotImplementedError(
+            f"`{self.__class__.__name__}.build_relation` must be implemented to use this feature"
+        )

{dbt_adapters-1.14.3 → dbt_adapters-1.14.5}/src/dbt/adapters/contracts/relation.py

@@ -58,7 +58,7 @@ class RelationConfig(Protocol):
     tags: List[str]
     quoting_dict: Dict[str, bool]
     config: Optional[MaterializationConfig]
-    catalog_name: Optional[str]
+    catalog: Optional[str]
 
 
 class ComponentName(StrEnum):

dbt_adapters-1.14.5/src/dbt/adapters/record/cursor/execute.py

@@ -0,0 +1,39 @@
+import dataclasses
+from typing import Any, Iterable, Union, Mapping, Optional
+
+from dbt.adapters.record.cursor.fetchall import CursorFetchAllResult
+from dbt_common.record import Record, Recorder
+
+
+@dataclasses.dataclass
+class CursorExecuteParams:
+    connection_name: str
+    operation: str
+    parameters: Optional[Union[Iterable[Any], Mapping[str, Any]]] = None
+
+    def _to_dict(self):
+        p = self.parameters
+        if isinstance(self.parameters, dict):
+            p = {(k, CursorFetchAllResult._process_value(v)) for k, v in self.parameters.items()}
+        elif isinstance(self.parameters, list) or isinstance(self.parameters, tuple):
+            p = [CursorFetchAllResult._process_value(v) for v in self.parameters]
+
+        return {
+            "connection_name": self.connection_name,
+            "operation": self.operation,
+            "parameters": p,
+        }
+
+    def _from_dict(cls, data):
+        # NOTE: This will be needed for replay, but is not needed at time
+        # of writing.
+        raise NotImplementedError()
+
+
+@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.14.3 → dbt_adapters-1.14.5}/src/dbt/adapters/record/cursor/fetchall.py

@@ -1,5 +1,6 @@
 import dataclasses
 import datetime
+import decimal
 from typing import Any, Dict, List, Mapping
 
 from dbt_common.record import Record, Recorder
@@ -37,6 +38,8 @@ class CursorFetchAllResult:
             return {"type": "date", "value": value.isoformat()}
         elif type(value) is datetime.datetime:
             return {"type": "datetime", "value": value.isoformat()}
+        elif type(value) is decimal.Decimal:
+            return float(value)
         else:
             return value
 

{dbt_adapters-1.14.3 → dbt_adapters-1.14.5}/src/dbt/include/global_project/macros/materializations/models/incremental/incremental.sql

@@ -37,11 +37,14 @@
 
   {% if existing_relation is none %}
       {% set build_sql = get_create_table_as_sql(False, target_relation, sql) %}
+      {% set relation_for_indexes = target_relation %}
   {% elif full_refresh_mode %}
       {% set build_sql = get_create_table_as_sql(False, intermediate_relation, sql) %}
+      {% set relation_for_indexes = intermediate_relation %}
       {% set need_swap = true %}
   {% else %}
     {% do run_query(get_create_table_as_sql(True, temp_relation, sql)) %}
+    {% set relation_for_indexes = temp_relation %}
     {% set contract_config = config.get('contract') %}
     {% if not contract_config or not contract_config.enforced %}
       {% do adapter.expand_target_column_types(
@@ -65,6 +68,10 @@
       {{ build_sql }}
   {% endcall %}
 
+  {% if existing_relation is none or existing_relation.is_view or should_full_refresh() %}
+    {% do create_indexes(relation_for_indexes) %}
+  {% endif %}
+
   {% if need_swap %}
       {% do adapter.rename_relation(target_relation, backup_relation) %}
       {% do adapter.rename_relation(intermediate_relation, target_relation) %}
@@ -76,10 +83,6 @@
 
   {% do persist_docs(target_relation, model) %}
 
-  {% if existing_relation is none or existing_relation.is_view or should_full_refresh() %}
-    {% do create_indexes(target_relation) %}
-  {% endif %}
-
   {{ run_hooks(post_hooks, inside_transaction=True) }}
 
   -- `COMMIT` happens here

{dbt_adapters-1.14.3 → dbt_adapters-1.14.5}/src/dbt/include/global_project/macros/materializations/models/incremental/merge.sql

@@ -67,10 +67,10 @@
 
         {%- set unique_key_str = unique_key|join(', ') -%}
 
-        delete from {{ target }}
+        delete from {{ target }} as DBT_INTERNAL_DEST
         where ({{ unique_key_str }}) in (
             select distinct {{ unique_key_str }}
-            from {{ source }}
+            from {{ source }} as DBT_INTERNAL_SOURCE
         )
         {%- if incremental_predicates %}
             {% for predicate in incremental_predicates %}

{dbt_adapters-1.14.3 → dbt_adapters-1.14.5}/src/dbt/include/global_project/macros/materializations/models/table.sql

@@ -31,6 +31,8 @@
     {{ get_create_table_as_sql(False, intermediate_relation, sql) }}
   {%- endcall %}
 
+  {% do create_indexes(intermediate_relation) %}
+
   -- cleanup
   {% if existing_relation is not none %}
      /* Do the equivalent of rename_if_exists. 'existing_relation' could have been dropped
@@ -43,8 +45,6 @@
 
   {{ adapter.rename_relation(intermediate_relation, target_relation) }}
 
-  {% do create_indexes(target_relation) %}
-
   {{ run_hooks(post_hooks, inside_transaction=True) }}
 
   {% set should_revoke = should_revoke(existing_relation, full_refresh_mode=True) %}

{dbt_adapters-1.14.3 → dbt_adapters-1.14.5}/src/dbt/include/global_project/macros/python_model/python.sql

@@ -11,7 +11,18 @@
     {%- set ref_dict = {} -%}
     {%- for _ref in model.refs -%}
         {% set _ref_args = [_ref.get('package'), _ref['name']] if _ref.get('package') else [_ref['name'],] %}
-        {%- set resolved = ref(*_ref_args, v=_ref.get('version')).render() -%}
+        {%- set resolved = ref(*_ref_args, v=_ref.get('version')) -%}
+
+        {#
+            We want to get the string of the returned relation by calling .render() in order to skip sample/empty
+            mode rendering logic. However, people override the default ref macro, and often return a string instead
+            of a relation (like the ref macro does by default). Thus, to make sure we dont blow things up, we have
+            to ensure the resolved relation has a .render() method.
+        #}
+        {%- if resolved.render is defined and resolved.render is callable -%}
+            {%- set resolved = resolved.render() -%}
+        {%- endif -%}
+
         {%- if _ref.get('version') -%}
             {% do _ref_args.extend(["v" ~ _ref['version']]) %}
         {%- endif -%}

{dbt_adapters-1.14.3 → dbt_adapters-1.14.5}/tests/unit/fixtures/adapter.py

@@ -22,7 +22,7 @@ class BaseAdapterStub(BaseAdapter):
     """
 
     ConnectionManager = ConnectionManagerStub
-    CATALOG_INTEGRATIONS = {"managed": CatalogIntegrationStub}
+    CATALOG_INTEGRATIONS = [CatalogIntegrationStub]
 
     ###
     # Abstract methods for database-specific values, attributes, and types

{dbt_adapters-1.14.3 → dbt_adapters-1.14.5}/tests/unit/test_catalogs.py

@@ -1,4 +1,5 @@
 from dataclasses import dataclass
+from types import SimpleNamespace
 from typing import Any, Dict, Optional
 
 import pytest
@@ -7,38 +8,72 @@ from dbt.adapters.catalogs import (
     CatalogIntegration,
     CatalogIntegrationClient,
     CatalogIntegrationConfig,
+    CatalogRelation,
     DbtCatalogIntegrationAlreadyExistsError,
     DbtCatalogIntegrationNotFoundError,
     DbtCatalogIntegrationNotSupportedError,
 )
+from dbt.adapters.contracts.relation import RelationConfig
 
 
 @dataclass
-class FakeCatalogIntegrationConfig(CatalogIntegrationConfig):
+class FakeCatalogIntegrationConfig:
     name: str
     catalog_type: str
+    catalog_name: Optional[str] = None
     table_format: Optional[str] = None
     external_volume: Optional[str] = None
     adapter_properties: Optional[Dict[str, Any]] = None
 
 
+@dataclass
+class FakeRelationConfig:
+    resource_type = ""
+    name = ""
+    description = ""
+    database = ""
+    schema = ""
+    identifier = ""
+    compiled_code = None
+    meta = {}
+    tags = []
+    quoting_dict = {}
+    config = None
+    catalog_name = None
+    external_volume: str = "fake_relation_volume"
+
+
+class FakeCatalogIntegration(CatalogIntegration):
+    catalog_type: str = "fake"
+    allows_writes: bool = False
+    table_format: str = "fake_format"
+
+    def build_relation(self, config: RelationConfig) -> CatalogRelation:
+        return SimpleNamespace(
+            catalog_name=self.catalog_name,
+            table_format=self.table_format,
+            external_volume=config.external_volume or self.external_volume,
+        )
+
+
 @pytest.fixture(scope="function")
 def fake_client() -> CatalogIntegrationClient:
-    return CatalogIntegrationClient({"fake": CatalogIntegration})
+    return CatalogIntegrationClient([FakeCatalogIntegration])
 
 
 @pytest.fixture
 def fake_catalog() -> CatalogIntegrationConfig:
     return FakeCatalogIntegrationConfig(
-        name="test_integration",
+        name="fake_integration",
         catalog_type="fake",
+        external_volume="fake_volume",
     )
 
 
 @pytest.fixture
 def fake_unsupported_catalog() -> CatalogIntegrationConfig:
     return FakeCatalogIntegrationConfig(
-        name="test_integration",
+        name="fake_integration",
         catalog_type="banana",
     )
 
@@ -83,3 +118,13 @@ def test_adding_unsupported_catalog_integration(
     assert e.value.catalog_type == fake_unsupported_catalog.catalog_type
     assert fake_unsupported_catalog.catalog_type in str(e.value)
     assert fake_catalog.catalog_type in str(e.value)
+
+
+def test_build_relation(fake_client, fake_catalog):
+    fake_client.add(fake_catalog)
+    catalog = fake_client.get("fake_integration")
+    relation_config = FakeRelationConfig()
+    relation = catalog.build_relation(relation_config)
+    assert relation.catalog_name == catalog.catalog_name
+    assert relation.table_format == catalog.table_format
+    assert relation.external_volume == relation_config.external_volume

dbt_adapters-1.14.3/src/dbt/adapters/__about__.py

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

dbt_adapters-1.14.3/src/dbt/adapters/record/cursor/execute.py

@@ -1,20 +0,0 @@
-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"