dbt-adapters 1.14.0__py3-none-any.whl → 1.14.3__py3-none-any.whl

dbt/adapters/__about__.py

@@ -1 +1 @@
-version = "1.14.0"
+version = "1.14.3"

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,11 @@ 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,
+)
 from dbt.adapters.contracts.connection import Credentials
 from dbt.adapters.contracts.macros import MacroResolverProtocol
 from dbt.adapters.contracts.relation import RelationConfig
@@ -220,6 +233,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 +283,7 @@ class BaseAdapter(metaclass=AdapterMeta):
     Relation: Type[BaseRelation] = BaseRelation
     Column: Type[BaseColumn] = BaseColumn
     ConnectionManager: Type[BaseConnectionManager]
+    CATALOG_INTEGRATIONS: Dict[str, Type[CatalogIntegration]] = {}
 
     # A set of clobber config fields accepted by this adapter
     # for use in materializations
@@ -295,6 +310,14 @@ 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: CatalogIntegrationConfig) -> CatalogIntegration:
+        return self._catalog_client.add(catalog)
+
+    @available
+    def get_catalog_integration(self, name: str) -> CatalogIntegration:
+        return self._catalog_client.get(name)
 
     ###
     # Methods to set / access a macro resolver
@@ -383,6 +406,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 +440,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 +454,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 +609,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 +620,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 +632,7 @@ class BaseAdapter(metaclass=AdapterMeta):
         self.cache.drop(relation)
         return ""
 
+    @auto_record_function("AdapterCacheRenamed", group="Available")
     @available
     def cache_renamed(
         self,
@@ -637,6 +673,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 +688,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 +698,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 +715,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 +728,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 +771,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 +791,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 +805,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 +837,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 +870,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 +894,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 +990,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 +1011,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 +1024,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 +1040,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 +1055,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 +1067,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 +1173,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
@@ -1224,7 +1294,7 @@ class BaseAdapter(metaclass=AdapterMeta):
         kwargs = {"information_schema": information_schema, "schemas": schemas}
         table = self.execute_macro(GET_CATALOG_MACRO_NAME, kwargs=kwargs)
 
-        results = self._catalog_filter_table(table, used_schemas)  # type: ignore[arg-type]
+        results = self._catalog_filter_table(table, used_schemas)
         return results
 
     def _get_one_catalog_by_relations(
@@ -1239,7 +1309,7 @@ class BaseAdapter(metaclass=AdapterMeta):
         }
         table = self.execute_macro(GET_CATALOG_RELATIONS_MACRO_NAME, kwargs=kwargs)
 
-        results = self._catalog_filter_table(table, used_schemas)  # type: ignore[arg-type]
+        results = self._catalog_filter_table(table, used_schemas)
         return results
 
     def get_filtered_catalog(
@@ -1435,7 +1505,7 @@ class BaseAdapter(metaclass=AdapterMeta):
                 macro_resolver=macro_resolver,
                 needs_conn=True,
             )
-            adapter_response, table = result.response, result.table  # type: ignore[attr-defined]
+            adapter_response, table = result.response, result.table
             adapter_responses.append(adapter_response)
 
             for row in table:
@@ -1709,7 +1779,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 +1835,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 +1909,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/meta.py

@@ -121,7 +121,7 @@ class AdapterMeta(abc.ABCMeta):
         # I'm not sure there is any benefit to it after poking around a bit,
         # but having it doesn't hurt on the python side (and omitting it could
         # hurt for obscure metaclass reasons, for all I know)
-        cls = abc.ABCMeta.__new__(mcls, name, bases, namespace, **kwargs)  # type: ignore
+        cls = abc.ABCMeta.__new__(mcls, name, bases, namespace, **kwargs)
 
         # this is very much inspired by ABCMeta's own implementation
 

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_name: 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
@@ -135,7 +136,7 @@ class BaseRelation(FakeAPIObject, Hashable):
             if str(self.path.get_lowered_part(k)).strip(self.quote_character) != v.lower().strip(
                 self.quote_character
             ):
-                approximate_match = False  # type: ignore[union-attr]
+                approximate_match = False
 
         if approximate_match and not exact_match:
             target = self.create(database=database, schema=schema, identifier=identifier)
@@ -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,10 @@
+from dbt.adapters.catalogs._client import CatalogIntegrationClient
+from dbt.adapters.catalogs._exceptions import (
+    DbtCatalogIntegrationAlreadyExistsError,
+    DbtCatalogIntegrationNotFoundError,
+    DbtCatalogIntegrationNotSupportedError,
+)
+from dbt.adapters.catalogs._integration import (
+    CatalogIntegration,
+    CatalogIntegrationConfig,
+)

dbt/adapters/catalogs/_client.py

@@ -0,0 +1,54 @@
+from typing import Dict, 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: Dict[str, Type[CatalogIntegration]]):
+        self.__supported_catalogs = 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 get(self, name: str) -> CatalogIntegration:
+        try:
+            return self.__catalog_integrations[name]
+        except KeyError:
+            raise DbtCatalogIntegrationNotFoundError(name, self.__catalog_integrations.keys())

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,75 @@
+from enum import Enum
+from typing import Any, Dict, Optional
+from typing_extensions import Protocol
+
+
+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 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
+        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
+        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
+            - 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
+        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
+    table_format: Optional[str]
+    external_volume: Optional[str]
+    adapter_properties: Optional[Dict[str, Any]]
+
+
+class CatalogIntegrationMode(Enum):
+    READ = "r"
+    WRITE = "w"
+
+
+class CatalogIntegration:
+    """
+    Represent a catalog integration for a given user config
+
+    This class should be subclassed 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
+        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
+        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
+        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
+            - 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
+    """
+
+    allows_writes: CatalogIntegrationMode = CatalogIntegrationMode.READ
+
+    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

dbt/adapters/contracts/connection.py

@@ -124,7 +124,7 @@ class LazyHandle:
 # and https://github.com/python/mypy/issues/5374
 # for why we have type: ignore. Maybe someday dataclasses + abstract classes
 # will work.
-@dataclass  # type: ignore
+@dataclass
 class Credentials(ExtensibleDbtClassMixin, Replaceable, metaclass=abc.ABCMeta):
     database: str
     schema: str

dbt/adapters/contracts/relation.py

@@ -58,6 +58,7 @@ class RelationConfig(Protocol):
     tags: List[str]
     quoting_dict: Dict[str, bool]
     config: Optional[MaterializationConfig]
+    catalog_name: 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