dbt-adapters 1.14.1__py3-none-any.whl → 1.14.4__py3-none-any.whl

dbt/adapters/__about__.py

@@ -1 +1 @@
-version = "1.14.1"
+version = "1.14.4"

dbt/adapters/base/impl.py

@@ -24,6 +24,13 @@ from typing import (
     TYPE_CHECKING,
 )
 import pytz
+
+from dbt.adapters.record.base import (
+    AdapterExecuteRecord,
+    AdapterGetPartitionsMetadataRecord,
+    AdapterConvertTypeRecord,
+    AdapterStandardizeGrantsDictRecord,
+)
 from dbt_common.behavior_flags import Behavior, BehaviorFlag
 from dbt_common.clients.jinja import CallableMacroGenerator
 from dbt_common.contracts.constraints import (
@@ -42,6 +49,7 @@ from dbt_common.exceptions import (
     NotImplementedError,
     UnexpectedNullError,
 )
+from dbt_common.record import auto_record_function, record_function, supports_replay
 from dbt_common.utils import (
     AttrDict,
     cast_to_str,
@@ -65,6 +73,12 @@ from dbt.adapters.base.relation import (
 )
 from dbt.adapters.cache import RelationsCache, _make_ref_key_dict
 from dbt.adapters.capability import Capability, CapabilityDict
+from dbt.adapters.catalogs import (
+    CatalogIntegration,
+    CatalogIntegrationClient,
+    CatalogIntegrationConfig,
+    CatalogRelation,
+)
 from dbt.adapters.contracts.connection import Credentials
 from dbt.adapters.contracts.macros import MacroResolverProtocol
 from dbt.adapters.contracts.relation import RelationConfig
@@ -220,6 +234,7 @@ class SnapshotStrategy(TypedDict):
     hard_deletes: Optional[str]
 
 
+@supports_replay
 class BaseAdapter(metaclass=AdapterMeta):
     """The BaseAdapter provides an abstract base class for adapters.
 
@@ -269,6 +284,7 @@ class BaseAdapter(metaclass=AdapterMeta):
     Relation: Type[BaseRelation] = BaseRelation
     Column: Type[BaseColumn] = BaseColumn
     ConnectionManager: Type[BaseConnectionManager]
+    CATALOG_INTEGRATIONS: Iterable[Type[CatalogIntegration]] = []
 
     # A set of clobber config fields accepted by this adapter
     # for use in materializations
@@ -295,6 +311,21 @@ class BaseAdapter(metaclass=AdapterMeta):
         self._macro_resolver: Optional[MacroResolverProtocol] = None
         self._macro_context_generator: Optional[MacroContextGeneratorCallable] = None
         self.behavior = DEFAULT_BASE_BEHAVIOR_FLAGS  # type: ignore
+        self._catalog_client = CatalogIntegrationClient(self.CATALOG_INTEGRATIONS)
+
+    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
@@ -383,6 +414,9 @@ class BaseAdapter(metaclass=AdapterMeta):
                 self.connections.query_header.reset()
 
     @available.parse(_parse_callback_empty_table)
+    @record_function(
+        AdapterExecuteRecord, method=True, index_on_thread_id=True, id_field_name="thread_id"
+    )
     def execute(
         self,
         sql: str,
@@ -414,6 +448,7 @@ class BaseAdapter(metaclass=AdapterMeta):
         """
         raise NotImplementedError("`validate_sql` is not implemented for this adapter!")
 
+    @auto_record_function("AdapterGetColumnSchemaFromQuery", group="Available")
     @available.parse(lambda *a, **k: [])
     def get_column_schema_from_query(self, sql: str) -> List[BaseColumn]:
         """Get a list of the Columns with names and data types from the given sql."""
@@ -427,6 +462,12 @@ class BaseAdapter(metaclass=AdapterMeta):
         ]
         return columns
 
+    @record_function(
+        AdapterGetPartitionsMetadataRecord,
+        method=True,
+        index_on_thread_id=True,
+        id_field_name="thread_id",
+    )
     @available.parse(_parse_callback_empty_table)
     def get_partitions_metadata(self, table: str) -> Tuple["agate.Table"]:
         """
@@ -576,6 +617,7 @@ class BaseAdapter(metaclass=AdapterMeta):
                 self.cache.clear()
             self._relations_cache_for_schemas(relation_configs, required_schemas)
 
+    @auto_record_function("AdapterCacheAdded", group="Available")
     @available
     def cache_added(self, relation: Optional[BaseRelation]) -> str:
         """Cache a new relation in dbt. It will show up in `list relations`."""
@@ -586,6 +628,7 @@ class BaseAdapter(metaclass=AdapterMeta):
         # so jinja doesn't render things
         return ""
 
+    @auto_record_function("AdapterCacheDropped", group="Available")
     @available
     def cache_dropped(self, relation: Optional[BaseRelation]) -> str:
         """Drop a relation in dbt. It will no longer show up in
@@ -597,6 +640,7 @@ class BaseAdapter(metaclass=AdapterMeta):
         self.cache.drop(relation)
         return ""
 
+    @auto_record_function("AdapterCacheRenamed", group="Available")
     @available
     def cache_renamed(
         self,
@@ -637,6 +681,7 @@ class BaseAdapter(metaclass=AdapterMeta):
         """Get a list of existing schemas in database"""
         raise NotImplementedError("`list_schemas` is not implemented for this adapter!")
 
+    @auto_record_function("AdapterCheckSchemaExists", group="Available")
     @available.parse(lambda *a, **k: False)
     def check_schema_exists(self, database: str, schema: str) -> bool:
         """Check if a schema exists.
@@ -651,6 +696,7 @@ class BaseAdapter(metaclass=AdapterMeta):
     ###
     # Abstract methods about relations
     ###
+    @auto_record_function("AdapterDropRelation", group="Available")
     @abc.abstractmethod
     @available.parse_none
     def drop_relation(self, relation: BaseRelation) -> None:
@@ -660,12 +706,14 @@ class BaseAdapter(metaclass=AdapterMeta):
         """
         raise NotImplementedError("`drop_relation` is not implemented for this adapter!")
 
+    @auto_record_function("AdapterTruncateRelation", group="Available")
     @abc.abstractmethod
     @available.parse_none
     def truncate_relation(self, relation: BaseRelation) -> None:
         """Truncate the given relation."""
         raise NotImplementedError("`truncate_relation` is not implemented for this adapter!")
 
+    @auto_record_function("AdapterRenameRelation", group="Available")
     @abc.abstractmethod
     @available.parse_none
     def rename_relation(self, from_relation: BaseRelation, to_relation: BaseRelation) -> None:
@@ -675,6 +723,7 @@ class BaseAdapter(metaclass=AdapterMeta):
         """
         raise NotImplementedError("`rename_relation` is not implemented for this adapter!")
 
+    @auto_record_function("AdapterGetColumnsInRelation", group="Available")
     @abc.abstractmethod
     @available.parse_list
     def get_columns_in_relation(self, relation: BaseRelation) -> List[BaseColumn]:
@@ -687,6 +736,7 @@ class BaseAdapter(metaclass=AdapterMeta):
             "`get_catalog_for_single_relation` is not implemented for this adapter!"
         )
 
+    @auto_record_function("AdapterGetColumnsInTable", group="Available")
     @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."""
@@ -729,6 +779,12 @@ class BaseAdapter(metaclass=AdapterMeta):
     ###
     # Methods about grants
     ###
+    @record_function(
+        AdapterStandardizeGrantsDictRecord,
+        method=True,
+        index_on_thread_id=True,
+        id_field_name="thread_id",
+    )
     @available
     def standardize_grants_dict(self, grants_table: "agate.Table") -> dict:
         """Translate the result of `show grants` (or equivalent) to match the
@@ -743,6 +799,7 @@ class BaseAdapter(metaclass=AdapterMeta):
         :return: A standardized dictionary matching the `grants` config
         :rtype: dict
         """
+
         grants_dict: Dict[str, List[str]] = {}
         for row in grants_table:
             grantee = row["grantee"]
@@ -756,6 +813,7 @@ class BaseAdapter(metaclass=AdapterMeta):
     ###
     # Provided methods about relations
     ###
+    @auto_record_function("AdapterGetMissingColumns", group="Available")
     @available.parse_list
     def get_missing_columns(
         self, from_relation: BaseRelation, to_relation: BaseRelation
@@ -787,6 +845,7 @@ class BaseAdapter(metaclass=AdapterMeta):
 
         return [col for (col_name, col) in from_columns.items() if col_name in missing_columns]
 
+    @auto_record_function("AdapterValidSnapshotTarget", group="Available")
     @available.parse_none
     def valid_snapshot_target(
         self, relation: BaseRelation, column_names: Optional[Dict[str, str]] = None
@@ -819,10 +878,12 @@ class BaseAdapter(metaclass=AdapterMeta):
         if missing:
             raise SnapshotTargetNotSnapshotTableError(missing)
 
+    @auto_record_function("AdapterAssertValidSnapshotTargetGivenStrategy", group="Available")
     @available.parse_none
     def assert_valid_snapshot_target_given_strategy(
         self, relation: BaseRelation, column_names: Dict[str, str], strategy: SnapshotStrategy
     ) -> None:
+
         # Assert everything we can with the legacy function.
         self.valid_snapshot_target(relation, column_names)
 
@@ -841,10 +902,12 @@ class BaseAdapter(metaclass=AdapterMeta):
             if missing:
                 raise SnapshotTargetNotSnapshotTableError(missing)
 
+    @auto_record_function("AdapterExpandTargetColumnTypes", group="Available")
     @available.parse_none
     def expand_target_column_types(
         self, from_relation: BaseRelation, to_relation: BaseRelation
     ) -> None:
+
         if not isinstance(from_relation, self.Relation):
             raise MacroArgTypeError(
                 method_name="expand_target_column_types",
@@ -935,8 +998,10 @@ class BaseAdapter(metaclass=AdapterMeta):
 
         return matches
 
+    @auto_record_function("AdapterGetRelation", group="Available")
     @available.parse_none
     def get_relation(self, database: str, schema: str, identifier: str) -> Optional[BaseRelation]:
+
         relations_list = self.list_relations(database, schema)
 
         matches = self._make_match(relations_list, database, schema, identifier)
@@ -954,9 +1019,11 @@ class BaseAdapter(metaclass=AdapterMeta):
 
         return None
 
+    @auto_record_function("AdapterAlreadyExists", group="Available")
     @available.deprecated("get_relation", lambda *a, **k: False)
     def already_exists(self, schema: str, name: str) -> bool:
         """DEPRECATED: Return if a model already exists in the database"""
+
         database = self.config.credentials.database
         relation = self.get_relation(database, schema, name)
         return relation is not None
@@ -965,12 +1032,14 @@ class BaseAdapter(metaclass=AdapterMeta):
     # ODBC FUNCTIONS -- these should not need to change for every adapter,
     #                   although some adapters may override them
     ###
+    @auto_record_function("AdapterCreateSchema", group="Available")
     @abc.abstractmethod
     @available.parse_none
     def create_schema(self, relation: BaseRelation):
         """Create the given schema if it does not exist."""
         raise NotImplementedError("`create_schema` is not implemented for this adapter!")
 
+    @auto_record_function("AdapterDropSchema", group="Available")
     @abc.abstractmethod
     @available.parse_none
     def drop_schema(self, relation: BaseRelation):
@@ -979,11 +1048,13 @@ class BaseAdapter(metaclass=AdapterMeta):
 
     @available
     @classmethod
+    @auto_record_function("AdapterQuote", group="Available")
     @abc.abstractmethod
     def quote(cls, identifier: str) -> str:
         """Quote the given identifier, as appropriate for the database."""
         raise NotImplementedError("`quote` is not implemented for this adapter!")
 
+    @auto_record_function("AdapterQuoteAsConfigured", group="Available")
     @available
     def quote_as_configured(self, identifier: str, quote_key: str) -> str:
         """Quote or do not quote the given identifer as configured in the
@@ -992,6 +1063,7 @@ class BaseAdapter(metaclass=AdapterMeta):
         The quote key should be one of 'database' (on bigquery, 'profile'),
         'identifier', or 'schema', or it will be treated as if you set `True`.
         """
+
         try:
             key = ComponentName(quote_key)
         except ValueError:
@@ -1003,8 +1075,10 @@ class BaseAdapter(metaclass=AdapterMeta):
         else:
             return identifier
 
+    @auto_record_function("AdapterQuoteSeedColumn", group="Available")
     @available
     def quote_seed_column(self, column: str, quote_config: Optional[bool]) -> str:
+
         quote_columns: bool = True
         if isinstance(quote_config, bool):
             quote_columns = quote_config
@@ -1107,7 +1181,11 @@ class BaseAdapter(metaclass=AdapterMeta):
 
     @available
     @classmethod
+    @record_function(
+        AdapterConvertTypeRecord, method=True, index_on_thread_id=True, id_field_name="thread_id"
+    )
     def convert_type(cls, agate_table: "agate.Table", col_idx: int) -> Optional[str]:
+
         return cls.convert_agate_type(agate_table, col_idx)
 
     @classmethod
@@ -1709,7 +1787,9 @@ class BaseAdapter(metaclass=AdapterMeta):
 
     @available
     @classmethod
-    def render_raw_columns_constraints(cls, raw_columns: Dict[str, Dict[str, Any]]) -> List:
+    @auto_record_function("AdapterRenderRawColumnConstraints", group="Available")
+    def render_raw_columns_constraints(cls, raw_columns: Dict[str, Dict[str, Any]]) -> List[str]:
+
         rendered_column_constraints = []
 
         for v in raw_columns.values():
@@ -1763,7 +1843,9 @@ class BaseAdapter(metaclass=AdapterMeta):
 
     @available
     @classmethod
+    @auto_record_function("AdapterRenderRawModelConstraints", group="Available")
     def render_raw_model_constraints(cls, raw_constraints: List[Dict[str, Any]]) -> List[str]:
+
         return [c for c in map(cls.render_raw_model_constraint, raw_constraints) if c is not None]
 
     @classmethod
@@ -1835,7 +1917,7 @@ class BaseAdapter(metaclass=AdapterMeta):
 
     @available.parse_none
     @classmethod
-    def get_hard_deletes_behavior(cls, config):
+    def get_hard_deletes_behavior(cls, config: Dict[str, str]) -> str:
         """Check the hard_deletes config enum, and the legacy invalidate_hard_deletes
         config flag in order to determine which behavior should be used for deleted
         records in a snapshot. The default is to ignore them."""

dbt/adapters/base/relation.py

@@ -60,6 +60,7 @@ class BaseRelation(FakeAPIObject, Hashable):
     require_alias: bool = (
         True  # used to govern whether to add an alias when render_limited is called
     )
+    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
@@ -305,6 +306,13 @@ class BaseRelation(FakeAPIObject, Hashable):
 
         config_quoting = relation_config.quoting_dict
         config_quoting.pop("column", None)
+
+        catalog_name = (
+            relation_config.catalog_name
+            if hasattr(relation_config, "catalog_name")
+            else relation_config.config.get("catalog", None)  # type: ignore
+        )
+
         # precedence: kwargs quoting > relation config quoting > base quoting > default quoting
         quote_policy = deep_merge(
             cls.get_default_quote_policy().to_dict(omit_none=True),
@@ -318,6 +326,7 @@ class BaseRelation(FakeAPIObject, Hashable):
             schema=relation_config.schema,
             identifier=relation_config.identifier,
             quote_policy=quote_policy,
+            catalog_name=catalog_name,
             **kwargs,
         )
 

dbt/adapters/catalogs/__init__.py

@@ -0,0 +1,11 @@
+from dbt.adapters.catalogs._client import CatalogIntegrationClient
+from dbt.adapters.catalogs._exceptions import (
+    DbtCatalogIntegrationAlreadyExistsError,
+    DbtCatalogIntegrationNotFoundError,
+    DbtCatalogIntegrationNotSupportedError,
+)
+from dbt.adapters.catalogs._integration import (
+    CatalogIntegration,
+    CatalogIntegrationConfig,
+    CatalogRelation,
+)

dbt/adapters/catalogs/_client.py

@@ -0,0 +1,54 @@
+from typing import Dict, Iterable, Type
+
+from dbt.adapters.catalogs._exceptions import (
+    DbtCatalogIntegrationAlreadyExistsError,
+    DbtCatalogIntegrationNotFoundError,
+    DbtCatalogIntegrationNotSupportedError,
+)
+from dbt.adapters.catalogs._integration import (
+    CatalogIntegration,
+    CatalogIntegrationConfig,
+)
+
+
+class CatalogIntegrationClient:
+    """
+    A repository class that manages catalog integrations
+
+    This class manages all types of catalog integrations,
+    supporting operations like registering new integrations and retrieving existing ones.
+    There is only one instance of this class per adapter.
+
+    Attributes:
+        __supported_catalogs (Dict[str, Type[CatalogIntegration]]): a dictionary of supported
+            catalog types mapped to their corresponding factory classes
+        __catalog_integrations (Dict[str, CatalogIntegration]): a dictionary of catalog
+            integration names mapped to their instances
+    """
+
+    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, 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/catalogs/_exceptions.py

@@ -0,0 +1,32 @@
+from typing import Iterable
+
+from dbt_common.exceptions import DbtConfigError
+
+
+class DbtCatalogIntegrationAlreadyExistsError(DbtConfigError):
+    def __init__(self, catalog_name: str) -> None:
+        self.catalog_name = catalog_name
+        msg = f"Catalog already exists: {self.catalog_name}."
+        super().__init__(msg)
+
+
+class DbtCatalogIntegrationNotFoundError(DbtConfigError):
+    def __init__(self, catalog_name: str, existing_catalog_names: Iterable[str]) -> None:
+        self.catalog_name = catalog_name
+        msg = (
+            f"Catalog not found."
+            f"Received: {self.catalog_name}"
+            f"Expected one of: {', '.join(existing_catalog_names)}?"
+        )
+        super().__init__(msg)
+
+
+class DbtCatalogIntegrationNotSupportedError(DbtConfigError):
+    def __init__(self, catalog_type: str, supported_catalog_types: Iterable[str]) -> None:
+        self.catalog_type = catalog_type
+        msg = (
+            f"Catalog type is not supported."
+            f"Received: {catalog_type}"
+            f"Expected one of: {', '.join(supported_catalog_types)}"
+        )
+        super().__init__(msg)

dbt/adapters/catalogs/_integration.py

@@ -0,0 +1,110 @@
+import abc
+from typing import Any, Dict, Optional
+from typing_extensions import Protocol
+
+from dbt.adapters.contracts.relation import RelationConfig
+
+
+class CatalogIntegrationConfig(Protocol):
+    """
+    Represents the user configuration required to describe a catalog integration
+
+    This class serves as a blueprint for catalog integration configurations,
+    providing details about the catalog type, name, and other optional
+    properties necessary for integration. It is designed to be used with
+    any implementation that requires a catalog configuration protocol,
+    ensuring a standardized structure and attributes are in place.
+
+    Attributes:
+        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: Dict[str, Any]
+
+
+class CatalogRelation(Protocol):
+    catalog_name: Optional[str]
+    table_format: Optional[str]
+    external_volume: Optional[str]
+
+
+class CatalogIntegration(abc.ABC):
+    """
+    Represent a catalog integration for a given user config
+
+    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 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 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 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
+    """
+
+    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
+
+        self.name: str = config.name
+        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/contracts/relation.py

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

dbt/adapters/events/adapter_types.proto

@@ -39,6 +39,7 @@ message AdapterNodeInfo {
     string node_finished_at = 8;
     google.protobuf.Struct meta = 9;
     AdapterNodeRelation node_relation = 10;
+    string node_checksum = 11;
 }
 
 // ReferenceKey