dbt-adapters 1.0.0b1__tar.gz → 1.0.8b3__tar.gz

{dbt_adapters-1.0.0b1 → dbt_adapters-1.0.8b3}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: dbt-adapters
-Version: 1.0.0b1
+Version: 1.0.8b3
 Summary: The set of adapter protocols and base functionality that supports integration with dbt-core
 Project-URL: Homepage, https://github.com/dbt-labs/dbt-adapters
 Project-URL: Documentation, https://docs.getdbt.com

dbt_adapters-1.0.8b3/dbt/adapters/__about__.py

@@ -0,0 +1 @@
+version = "1.0.8b3"

{dbt_adapters-1.0.0b1 → dbt_adapters-1.0.8b3}/dbt/adapters/base/connections.py

@@ -18,9 +18,9 @@ from typing import (
     Tuple,
     Type,
     Union,
+    TYPE_CHECKING,
 )
 
-import agate
 from dbt_common.events.contextvars import get_node_info
 from dbt_common.events.functions import fire_event
 from dbt_common.exceptions import DbtInternalError, NotImplementedError
@@ -48,6 +48,9 @@ from dbt.adapters.events.types import (
 )
 from dbt.adapters.exceptions import FailedToConnectError, InvalidConnectionError
 
+if TYPE_CHECKING:
+    import agate
+
 
 SleepTime = Union[int, float]  # As taken by time.sleep.
 AdapterHandle = Any  # Adapter connection handle objects can be any class.
@@ -162,9 +165,7 @@ class BaseConnectionManager(metaclass=abc.ABCMeta):
             conn.handle = LazyHandle(self.open)
             # Add the connection to thread_connections for this thread
             self.set_thread_connection(conn)
-            fire_event(
-                NewConnection(conn_name=conn_name, conn_type=self.TYPE, node_info=get_node_info())
-            )
+            fire_event(NewConnection(conn_name=conn_name, conn_type=self.TYPE, node_info=get_node_info()))
         else:  # existing connection either wasn't open or didn't have the right name
             if conn.state != "open":
                 conn.handle = LazyHandle(self.open)
@@ -396,7 +397,7 @@ class BaseConnectionManager(metaclass=abc.ABCMeta):
         auto_begin: bool = False,
         fetch: bool = False,
         limit: Optional[int] = None,
-    ) -> Tuple[AdapterResponse, agate.Table]:
+    ) -> Tuple[AdapterResponse, "agate.Table"]:
         """Execute the given SQL.
 
         :param str sql: The sql to execute.

{dbt_adapters-1.0.0b1 → dbt_adapters-1.0.8b3}/dbt/adapters/base/impl.py

@@ -20,16 +20,9 @@ from typing import (
     Type,
     TypedDict,
     Union,
+    TYPE_CHECKING,
 )
 
-import agate
-from dbt_common.clients.agate_helper import (
-    Integer,
-    empty_table,
-    get_column_value_uncased,
-    merge_tables,
-    table_from_rows,
-)
 from dbt_common.clients.jinja import CallableMacroGenerator
 from dbt_common.contracts.constraints import (
     ColumnLevelConstraint,
@@ -94,6 +87,9 @@ from dbt.adapters.exceptions import (
 )
 from dbt.adapters.protocol import AdapterConfig, MacroContextGeneratorCallable
 
+if TYPE_CHECKING:
+    import agate
+
 
 GET_CATALOG_MACRO_NAME = "get_catalog"
 GET_CATALOG_RELATIONS_MACRO_NAME = "get_catalog_relations"
@@ -107,7 +103,14 @@ class ConstraintSupport(str, Enum):
     NOT_SUPPORTED = "not_supported"
 
 
-def _expect_row_value(key: str, row: agate.Row):
+def _parse_callback_empty_table(*args, **kwargs) -> Tuple[str, "agate.Table"]:
+    # Lazy load agate_helper to avoid importing agate when it is not necessary.
+    from dbt_common.clients.agate_helper import empty_table
+
+    return "", empty_table()
+
+
+def _expect_row_value(key: str, row: "agate.Row"):
     if key not in row.keys():
         raise DbtInternalError(
             'Got a row without "{}" column, columns: {}'.format(key, row.keys())
@@ -117,13 +120,13 @@ def _expect_row_value(key: str, row: agate.Row):
 
 def _catalog_filter_schemas(
     used_schemas: FrozenSet[Tuple[str, str]]
-) -> Callable[[agate.Row], bool]:
+) -> Callable[["agate.Row"], bool]:
     """Return a function that takes a row and decides if the row should be
     included in the catalog output.
     """
     schemas = frozenset((d.lower(), s.lower()) for d, s in used_schemas)
 
-    def test(row: agate.Row) -> bool:
+    def test(row: "agate.Row") -> bool:
         table_database = _expect_row_value("table_database", row)
         table_schema = _expect_row_value("table_schema", row)
         # the schema may be present but None, which is not an error and should
@@ -254,6 +257,8 @@ class BaseAdapter(metaclass=AdapterMeta):
         ConstraintType.foreign_key: ConstraintSupport.ENFORCED,
     }
 
+    MAX_SCHEMA_METADATA_RELATIONS = 100
+
     # This static member variable can be overriden in concrete adapter
     # implementations to indicate adapter support for optional capabilities.
     _capabilities = CapabilityDict({})
@@ -323,14 +328,14 @@ class BaseAdapter(metaclass=AdapterMeta):
             if self.connections.query_header is not None:
                 self.connections.query_header.reset()
 
-    @available.parse(lambda *a, **k: ("", empty_table()))
+    @available.parse(_parse_callback_empty_table)
     def execute(
         self,
         sql: str,
         auto_begin: bool = False,
         fetch: bool = False,
         limit: Optional[int] = None,
-    ) -> Tuple[AdapterResponse, agate.Table]:
+    ) -> Tuple[AdapterResponse, "agate.Table"]:
         """Execute the given SQL. This is a thin wrapper around
         ConnectionManager.execute.
 
@@ -340,7 +345,7 @@ class BaseAdapter(metaclass=AdapterMeta):
         :param bool fetch: If set, fetch results.
         :param Optional[int] limit: If set, only fetch n number of rows
         :return: A tuple of the query status and results (empty if fetch=False).
-        :rtype: Tuple[AdapterResponse, agate.Table]
+        :rtype: Tuple[AdapterResponse, "agate.Table"]
         """
         return self.connections.execute(sql=sql, auto_begin=auto_begin, fetch=fetch, limit=limit)
 
@@ -368,8 +373,8 @@ class BaseAdapter(metaclass=AdapterMeta):
         ]
         return columns
 
-    @available.parse(lambda *a, **k: ("", empty_table()))
-    def get_partitions_metadata(self, table: str) -> Tuple[agate.Table]:
+    @available.parse(_parse_callback_empty_table)
+    def get_partitions_metadata(self, table: str) -> Tuple["agate.Table"]:
         """
         TODO: Can we move this to dbt-bigquery?
         Obtain partitions metadata for a BigQuery partitioned table.
@@ -377,7 +382,7 @@ class BaseAdapter(metaclass=AdapterMeta):
         :param str table: a partitioned table id, in standard SQL format.
         :return: a partition metadata tuple, as described in
             https://cloud.google.com/bigquery/docs/creating-partitioned-tables#getting_partition_metadata_using_meta_tables.
-        :rtype: agate.Table
+        :rtype: "agate.Table"
         """
         if hasattr(self.connections, "get_partitions_metadata"):
             return self.connections.get_partitions_metadata(table=table)
@@ -421,7 +426,9 @@ class BaseAdapter(metaclass=AdapterMeta):
         populate.
         """
         return {
-            self.Relation.create_from(quoting=self.config, relation_config=relation_config).without_identifier()
+            self.Relation.create_from(
+                quoting=self.config, relation_config=relation_config
+            ).without_identifier()
             for relation_config in relation_configs
         }
 
@@ -663,7 +670,7 @@ class BaseAdapter(metaclass=AdapterMeta):
     # Methods about grants
     ###
     @available
-    def standardize_grants_dict(self, grants_table: agate.Table) -> dict:
+    def standardize_grants_dict(self, grants_table: "agate.Table") -> dict:
         """Translate the result of `show grants` (or equivalent) to match the
         grants which a user would configure in their project.
 
@@ -938,7 +945,7 @@ class BaseAdapter(metaclass=AdapterMeta):
     ###
     @classmethod
     @abc.abstractmethod
-    def convert_text_type(cls, agate_table: agate.Table, col_idx: int) -> str:
+    def convert_text_type(cls, agate_table: "agate.Table", col_idx: int) -> str:
         """Return the type in the database that best maps to the agate.Text
         type for the given agate table and column index.
 
@@ -950,7 +957,7 @@ class BaseAdapter(metaclass=AdapterMeta):
 
     @classmethod
     @abc.abstractmethod
-    def convert_number_type(cls, agate_table: agate.Table, col_idx: int) -> str:
+    def convert_number_type(cls, agate_table: "agate.Table", col_idx: int) -> str:
         """Return the type in the database that best maps to the agate.Number
         type for the given agate table and column index.
 
@@ -961,7 +968,7 @@ class BaseAdapter(metaclass=AdapterMeta):
         raise NotImplementedError("`convert_number_type` is not implemented for this adapter!")
 
     @classmethod
-    def convert_integer_type(cls, agate_table: agate.Table, col_idx: int) -> str:
+    def convert_integer_type(cls, agate_table: "agate.Table", col_idx: int) -> str:
         """Return the type in the database that best maps to the agate.Number
         type for the given agate table and column index.
 
@@ -973,7 +980,7 @@ class BaseAdapter(metaclass=AdapterMeta):
 
     @classmethod
     @abc.abstractmethod
-    def convert_boolean_type(cls, agate_table: agate.Table, col_idx: int) -> str:
+    def convert_boolean_type(cls, agate_table: "agate.Table", col_idx: int) -> str:
         """Return the type in the database that best maps to the agate.Boolean
         type for the given agate table and column index.
 
@@ -985,7 +992,7 @@ class BaseAdapter(metaclass=AdapterMeta):
 
     @classmethod
     @abc.abstractmethod
-    def convert_datetime_type(cls, agate_table: agate.Table, col_idx: int) -> str:
+    def convert_datetime_type(cls, agate_table: "agate.Table", col_idx: int) -> str:
         """Return the type in the database that best maps to the agate.DateTime
         type for the given agate table and column index.
 
@@ -997,7 +1004,7 @@ class BaseAdapter(metaclass=AdapterMeta):
 
     @classmethod
     @abc.abstractmethod
-    def convert_date_type(cls, agate_table: agate.Table, col_idx: int) -> str:
+    def convert_date_type(cls, agate_table: "agate.Table", col_idx: int) -> str:
         """Return the type in the database that best maps to the agate.Date
         type for the given agate table and column index.
 
@@ -1009,7 +1016,7 @@ class BaseAdapter(metaclass=AdapterMeta):
 
     @classmethod
     @abc.abstractmethod
-    def convert_time_type(cls, agate_table: agate.Table, col_idx: int) -> str:
+    def convert_time_type(cls, agate_table: "agate.Table", col_idx: int) -> str:
         """Return the type in the database that best maps to the
         agate.TimeDelta type for the given agate table and column index.
 
@@ -1021,11 +1028,14 @@ class BaseAdapter(metaclass=AdapterMeta):
 
     @available
     @classmethod
-    def convert_type(cls, agate_table: agate.Table, col_idx: int) -> Optional[str]:
+    def convert_type(cls, agate_table: "agate.Table", col_idx: int) -> Optional[str]:
         return cls.convert_agate_type(agate_table, col_idx)
 
     @classmethod
-    def convert_agate_type(cls, agate_table: agate.Table, col_idx: int) -> Optional[str]:
+    def convert_agate_type(cls, agate_table: "agate.Table", col_idx: int) -> Optional[str]:
+        import agate
+        from dbt_common.clients.agate_helper import Integer
+
         agate_type: Type = agate_table.column_types[col_idx]
         conversions: List[Tuple[Type, Callable[..., str]]] = [
             (Integer, cls.convert_integer_type),
@@ -1052,6 +1062,7 @@ class BaseAdapter(metaclass=AdapterMeta):
         project: Optional[str] = None,
         context_override: Optional[Dict[str, Any]] = None,
         kwargs: Optional[Dict[str, Any]] = None,
+        needs_conn: bool = False,
     ) -> AttrDict:
         """Look macro_name up in the manifest and execute its results.
 
@@ -1064,6 +1075,10 @@ class BaseAdapter(metaclass=AdapterMeta):
             execution context.
         :param kwargs: An optional dict of keyword args used to pass to the
             macro.
+        : param needs_conn: A boolean that indicates whether the specified macro
+            requires an open connection to execute. If needs_conn is True, a
+            connection is expected and opened if necessary. Otherwise (and by default),
+            no connection is expected prior to executing the macro.
         """
 
         if kwargs is None:
@@ -1096,17 +1111,23 @@ class BaseAdapter(metaclass=AdapterMeta):
 
         macro_function = CallableMacroGenerator(macro, macro_context)
 
+        if needs_conn:
+            connection = self.connections.get_thread_connection()
+            self.connections.open(connection)
+
         with self.connections.exception_handler(f"macro {macro_name}"):
             result = macro_function(**kwargs)
         return result
 
     @classmethod
     def _catalog_filter_table(
-        cls, table: agate.Table, used_schemas: FrozenSet[Tuple[str, str]]
-    ) -> agate.Table:
+        cls, table: "agate.Table", used_schemas: FrozenSet[Tuple[str, str]]
+    ) -> "agate.Table":
         """Filter the table as appropriate for catalog entries. Subclasses can
         override this to change filtering rules on a per-adapter basis.
         """
+        from dbt_common.clients.agate_helper import table_from_rows
+
         # force database + schema to be strings
         table = table_from_rows(
             table.rows,
@@ -1120,7 +1141,7 @@ class BaseAdapter(metaclass=AdapterMeta):
         information_schema: InformationSchema,
         schemas: Set[str],
         used_schemas: FrozenSet[Tuple[str, str]],
-    ) -> agate.Table:
+    ) -> "agate.Table":
         kwargs = {"information_schema": information_schema, "schemas": schemas}
         table = self.execute_macro(GET_CATALOG_MACRO_NAME, kwargs=kwargs)
 
@@ -1132,7 +1153,7 @@ class BaseAdapter(metaclass=AdapterMeta):
         information_schema: InformationSchema,
         relations: List[BaseRelation],
         used_schemas: FrozenSet[Tuple[str, str]],
-    ) -> agate.Table:
+    ) -> "agate.Table":
         kwargs = {
             "information_schema": information_schema,
             "relations": relations,
@@ -1148,10 +1169,10 @@ class BaseAdapter(metaclass=AdapterMeta):
         used_schemas: FrozenSet[Tuple[str, str]],
         relations: Optional[Set[BaseRelation]] = None,
     ):
-        catalogs: agate.Table
+        catalogs: "agate.Table"
         if (
             relations is None
-            or len(relations) > 100
+            or len(relations) > self.MAX_SCHEMA_METADATA_RELATIONS
             or not self.supports(Capability.SchemaMetadataByRelations)
         ):
             # Do it the traditional way. We get the full catalog.
@@ -1171,7 +1192,7 @@ class BaseAdapter(metaclass=AdapterMeta):
                 for r in relations
             }
 
-            def in_map(row: agate.Row):
+            def in_map(row: "agate.Row"):
                 d = _expect_row_value("table_database", row)
                 s = _expect_row_value("table_schema", row)
                 i = _expect_row_value("table_name", row)
@@ -1184,16 +1205,16 @@ class BaseAdapter(metaclass=AdapterMeta):
 
         return catalogs, exceptions
 
-    def row_matches_relation(self, row: agate.Row, relations: Set[BaseRelation]):
+    def row_matches_relation(self, row: "agate.Row", relations: Set[BaseRelation]):
         pass
 
     def get_catalog(
         self,
         relation_configs: Iterable[RelationConfig],
         used_schemas: FrozenSet[Tuple[str, str]],
-    ) -> Tuple[agate.Table, List[Exception]]:
+    ) -> Tuple["agate.Table", List[Exception]]:
         with executor(self.config) as tpe:
-            futures: List[Future[agate.Table]] = []
+            futures: List[Future["agate.Table"]] = []
             schema_map: SchemaSearchMap = self._get_catalog_schemas(relation_configs)
             for info, schemas in schema_map.items():
                 if len(schemas) == 0:
@@ -1209,9 +1230,9 @@ class BaseAdapter(metaclass=AdapterMeta):
 
     def get_catalog_by_relations(
         self, used_schemas: FrozenSet[Tuple[str, str]], relations: Set[BaseRelation]
-    ) -> Tuple[agate.Table, List[Exception]]:
+    ) -> Tuple["agate.Table", List[Exception]]:
         with executor(self.config) as tpe:
-            futures: List[Future[agate.Table]] = []
+            futures: List[Future["agate.Table"]] = []
             relations_by_schema = self._get_catalog_relations_by_info_schema(relations)
             for info_schema in relations_by_schema:
                 name = ".".join([str(info_schema.database), "information_schema"])
@@ -1241,6 +1262,8 @@ class BaseAdapter(metaclass=AdapterMeta):
         macro_resolver: Optional[MacroResolverProtocol] = None,
     ) -> Tuple[Optional[AdapterResponse], FreshnessResponse]:
         """Calculate the freshness of sources in dbt, and return it"""
+        import agate
+
         kwargs: Dict[str, Any] = {
             "source": source,
             "loaded_at_field": loaded_at_field,
@@ -1251,8 +1274,8 @@ class BaseAdapter(metaclass=AdapterMeta):
         # in older versions of dbt-core, the 'collect_freshness' macro returned the table of results directly
         # starting in v1.5, by default, we return both the table and the adapter response (metadata about the query)
         result: Union[
-            AttrDict,  # current: contains AdapterResponse + agate.Table
-            agate.Table,  # previous: just table
+            AttrDict,  # current: contains AdapterResponse + "agate.Table"
+            "agate.Table",  # previous: just table
         ]
         result = self.execute_macro(
             FRESHNESS_MACRO_NAME, kwargs=kwargs, macro_resolver=macro_resolver
@@ -1283,46 +1306,110 @@ class BaseAdapter(metaclass=AdapterMeta):
         }
         return adapter_response, freshness
 
+    def calculate_freshness_from_metadata_batch(
+        self,
+        sources: List[BaseRelation],
+        macro_resolver: Optional[MacroResolverProtocol] = None,
+    ) -> Tuple[List[Optional[AdapterResponse]], Dict[BaseRelation, FreshnessResponse]]:
+        """
+        Given a list of sources (BaseRelations), calculate the metadata-based freshness in batch.
+        This method should _not_ execute a warehouse query per source, but rather batch up
+        the sources into as few requests as possible to minimize the number of roundtrips required
+        to compute metadata-based freshness for each input source.
+
+        :param sources: The list of sources to calculate metadata-based freshness for
+        :param macro_resolver: An optional macro_resolver to use for get_relation_last_modified
+        :return: a tuple where:
+            * the first element is a list of optional AdapterResponses indicating the response
+              for each request the method made to compute the freshness for the provided sources.
+            * the second element is a dictionary mapping an input source BaseRelation to a FreshnessResponse,
+              if it was possible to calculate a FreshnessResponse for the source.
+        """
+        # Track schema, identifiers of sources for lookup from batch query
+        schema_identifier_to_source = {
+            (
+                source.path.get_lowered_part(ComponentName.Schema),
+                source.path.get_lowered_part(ComponentName.Identifier),
+            ): source
+            for source in sources
+        }
+
+        # Group metadata sources by information schema -- one query per information schema will be necessary
+        sources_by_info_schema: Dict[InformationSchema, List[BaseRelation]] = self._get_catalog_relations_by_info_schema(sources)
+
+        freshness_responses: Dict[BaseRelation, FreshnessResponse] = {}
+        adapter_responses: List[Optional[AdapterResponse]] = []
+        for (
+            information_schema,
+            sources_for_information_schema,
+        ) in sources_by_info_schema.items():
+            result = self.execute_macro(
+                GET_RELATION_LAST_MODIFIED_MACRO_NAME,
+                kwargs={
+                    "information_schema": information_schema,
+                    "relations": sources_for_information_schema,
+                },
+                macro_resolver=macro_resolver,
+                needs_conn=True,
+            )
+            adapter_response, table = result.response, result.table  # type: ignore[attr-defined]
+            adapter_responses.append(adapter_response)
+
+            for row in table:
+                raw_relation, freshness_response = self._parse_freshness_row(row, table)
+                source_relation_for_result = schema_identifier_to_source[raw_relation]
+                freshness_responses[source_relation_for_result] = freshness_response
+
+        return adapter_responses, freshness_responses
+
     def calculate_freshness_from_metadata(
         self,
         source: BaseRelation,
         macro_resolver: Optional[MacroResolverProtocol] = None,
     ) -> Tuple[Optional[AdapterResponse], FreshnessResponse]:
-        kwargs: Dict[str, Any] = {
-            "information_schema": source.information_schema_only(),
-            "relations": [source],
-        }
-        result = self.execute_macro(
-            GET_RELATION_LAST_MODIFIED_MACRO_NAME,
-            kwargs=kwargs,
+        adapter_responses, freshness_responses = self.calculate_freshness_from_metadata_batch(
+            sources=[source],
             macro_resolver=macro_resolver,
         )
-        adapter_response, table = result.response, result.table  # type: ignore[attr-defined]
+        adapter_response = adapter_responses[0] if adapter_responses else None
+        return adapter_response, freshness_responses[source]
 
-        try:
-            row = table[0]
-            last_modified_val = get_column_value_uncased("last_modified", row)
-            snapshotted_at_val = get_column_value_uncased("snapshotted_at", row)
-        except Exception:
-            raise MacroResultError(GET_RELATION_LAST_MODIFIED_MACRO_NAME, table)
-
-        if last_modified_val is None:
+    def _create_freshness_response(
+        self, last_modified: Optional[datetime], snapshotted_at: Optional[datetime]
+    ) -> FreshnessResponse:
+        if last_modified is None:
             # Interpret missing value as "infinitely long ago"
             max_loaded_at = datetime(1, 1, 1, 0, 0, 0, tzinfo=pytz.UTC)
         else:
-            max_loaded_at = _utc(last_modified_val, None, "last_modified")
-
-        snapshotted_at = _utc(snapshotted_at_val, None, "snapshotted_at")
+            max_loaded_at = _utc(last_modified, None, "last_modified")
 
+        snapshotted_at = _utc(snapshotted_at, None, "snapshotted_at")
         age = (snapshotted_at - max_loaded_at).total_seconds()
-
         freshness: FreshnessResponse = {
             "max_loaded_at": max_loaded_at,
             "snapshotted_at": snapshotted_at,
             "age": age,
         }
 
-        return adapter_response, freshness
+        return freshness
+
+    def _parse_freshness_row(self, row: "agate.Row", table: "agate.Table") -> Tuple[Any, FreshnessResponse]:
+        from dbt_common.clients.agate_helper import get_column_value_uncased
+
+        try:
+            last_modified_val = get_column_value_uncased("last_modified", row)
+            snapshotted_at_val = get_column_value_uncased("snapshotted_at", row)
+            identifier = get_column_value_uncased("identifier", row)
+            schema = get_column_value_uncased("schema", row)
+        except Exception:
+            raise MacroResultError(GET_RELATION_LAST_MODIFIED_MACRO_NAME, table)
+
+        freshness_response = self._create_freshness_response(
+            last_modified_val,
+            snapshotted_at_val
+        )
+        raw_relation = schema.lower().strip(), identifier.lower().strip()
+        return raw_relation, freshness_response
 
     def pre_model_hook(self, config: Mapping[str, Any]) -> Any:
         """A hook for running some operation before the model materialization
@@ -1636,10 +1723,12 @@ join diff_count using (id)
 
 
 def catch_as_completed(
-    futures,  # typing: List[Future[agate.Table]]
-) -> Tuple[agate.Table, List[Exception]]:
-    # catalogs: agate.Table = agate.Table(rows=[])
-    tables: List[agate.Table] = []
+    futures,  # typing: List[Future["agate.Table"]]
+) -> Tuple["agate.Table", List[Exception]]:
+    from dbt_common.clients.agate_helper import merge_tables
+
+    # catalogs: "agate.Table" =".Table(rows=[])
+    tables: List["agate.Table"] = []
     exceptions: List[Exception] = []
 
     for future in as_completed(futures):

{dbt_adapters-1.0.0b1 → dbt_adapters-1.0.8b3}/dbt/adapters/base/relation.py

@@ -52,13 +52,13 @@ class BaseRelation(FakeAPIObject, Hashable):
     # adding a relation type here also requires defining the associated rename macro
     # e.g. adding RelationType.View in dbt-postgres requires that you define:
     # include/postgres/macros/relations/view/rename.sql::postgres__get_rename_view_sql()
-    renameable_relations: SerializableIterable = ()
+    renameable_relations: SerializableIterable = field(default_factory=frozenset)
 
     # register relation types that are atomically replaceable, e.g. they have "create or replace" syntax
     # adding a relation type here also requires defining the associated replace macro
     # e.g. adding RelationType.View in dbt-postgres requires that you define:
     # include/postgres/macros/relations/view/replace.sql::postgres__get_replace_view_sql()
-    replaceable_relations: SerializableIterable = ()
+    replaceable_relations: SerializableIterable = field(default_factory=frozenset)
 
     def _is_exactish_match(self, field: ComponentName, value: str) -> bool:
         if self.dbt_created and self.quote_policy.get_part(field) is False:

{dbt_adapters-1.0.0b1 → dbt_adapters-1.0.8b3}/dbt/adapters/capability.py

@@ -13,6 +13,9 @@ class Capability(str, Enum):
     TableLastModifiedMetadata = "TableLastModifiedMetadata"
     """Indicates support for determining the time of the last table modification by querying database metadata."""
 
+    TableLastModifiedMetadataBatch = "TableLastModifiedMetadataBatch"
+    """Indicates support for performantly determining the time of the last table modification by querying database metadata in batch."""
+
 
 class Support(str, Enum):
     Unknown = "Unknown"

{dbt_adapters-1.0.0b1 → dbt_adapters-1.0.8b3}/dbt/adapters/contracts/relation.py

@@ -48,11 +48,15 @@ class MaterializationConfig(Mapping, ABC):
 
 
 class RelationConfig(Protocol):
+    resource_type: str
     name: str
+    description: str
     database: str
     schema: str
     identifier: str
     compiled_code: Optional[str]
+    meta: Dict[str, Any]
+    tags: List[str]
     quoting_dict: Dict[str, bool]
     config: Optional[MaterializationConfig]
 

{dbt_adapters-1.0.0b1 → dbt_adapters-1.0.8b3}/dbt/adapters/events/adapter_types.proto

@@ -515,3 +515,13 @@ message ConstraintNotSupportedMsg {
     AdapterCommonEventInfo info = 1;
     ConstraintNotSupported data = 2;
 }
+
+// E050
+message TypeCodeNotFound {
+    int32 type_code = 1;
+}
+
+message TypeCodeNotFoundMsg {
+    AdapterCommonEventInfo info = 1;
+    TypeCodeNotFound data = 2;
+}