dbt-adapters 1.0.0b1__tar.gz → 1.0.0b2__tar.gz

{dbt_adapters-1.0.0b1 → dbt_adapters-1.0.0b2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: dbt-adapters
-Version: 1.0.0b1
+Version: 1.0.0b2
 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.0b2/dbt/adapters/__about__.py

@@ -0,0 +1 @@
+version = "1.0.0b2"

{dbt_adapters-1.0.0b1 → dbt_adapters-1.0.0b2}/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.0b2}/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),
@@ -1102,11 +1112,13 @@ class BaseAdapter(metaclass=AdapterMeta):
 
     @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 +1132,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 +1144,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 +1160,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 +1183,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 +1196,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 +1221,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 +1253,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 +1265,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
@@ -1300,6 +1314,8 @@ class BaseAdapter(metaclass=AdapterMeta):
         adapter_response, table = result.response, result.table  # type: ignore[attr-defined]
 
         try:
+            from dbt_common.clients.agate_helper import get_column_value_uncased
+
             row = table[0]
             last_modified_val = get_column_value_uncased("last_modified", row)
             snapshotted_at_val = get_column_value_uncased("snapshotted_at", row)
@@ -1636,10 +1652,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.0b2}/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.0b2}/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.0b2}/dbt/adapters/factory.py

@@ -100,9 +100,7 @@ class AdapterContainer:
         adapter_name = config.credentials.type
         adapter_type = self.get_adapter_class_by_name(adapter_name)
         adapter_version = self._adapter_version(adapter_name)
-        fire_event(
-            AdapterRegistered(adapter_name=adapter_name, adapter_version=adapter_version)
-        )
+        fire_event(AdapterRegistered(adapter_name=adapter_name, adapter_version=adapter_version))
         with self.lock:
             if adapter_name in self.adapters:
                 # this shouldn't really happen...

{dbt_adapters-1.0.0b1 → dbt_adapters-1.0.0b2}/dbt/adapters/protocol.py

@@ -10,10 +10,10 @@ from typing import (
     Type,
     TypeVar,
     Tuple,
+    TYPE_CHECKING,
 )
 from typing_extensions import Protocol
 
-import agate
 from dbt_common.clients.jinja import MacroProtocol
 from dbt_common.contracts.config.base import BaseConfig
 
@@ -25,6 +25,9 @@ from dbt.adapters.contracts.connection import (
 from dbt.adapters.contracts.macros import MacroResolverProtocol
 from dbt.adapters.contracts.relation import HasQuoting, Policy, RelationConfig
 
+if TYPE_CHECKING:
+    import agate
+
 
 @dataclass
 class AdapterConfig(BaseConfig):
@@ -169,5 +172,5 @@ class AdapterProtocol(  # type: ignore[misc]
 
     def execute(
         self, sql: str, auto_begin: bool = False, fetch: bool = False
-    ) -> Tuple[AdapterResponse, agate.Table]:
+    ) -> Tuple[AdapterResponse, "agate.Table"]:
         ...

{dbt_adapters-1.0.0b1 → dbt_adapters-1.0.0b2}/dbt/adapters/relation_configs/config_base.py

@@ -1,9 +1,11 @@
 from dataclasses import dataclass
-from typing import Dict, Union
+from typing import Dict, Union, TYPE_CHECKING
 
-import agate
 from dbt_common.utils import filter_null_values
 
+if TYPE_CHECKING:
+    import agate
+
 
 """
 This is what relation metadata from the database looks like. It's a dictionary because there will be
@@ -18,7 +20,7 @@ like name. But it also can have multiple indexes, which needs to be a separate q
     ])
 }
 """
-RelationResults = Dict[str, Union[agate.Row, agate.Table]]
+RelationResults = Dict[str, Union["agate.Row", "agate.Table"]]
 
 
 @dataclass(frozen=True)

{dbt_adapters-1.0.0b1 → dbt_adapters-1.0.0b2}/dbt/adapters/sql/connections.py

@@ -1,9 +1,7 @@
 import abc
 import time
-from typing import Any, Dict, Iterable, List, Optional, Tuple
+from typing import Any, Dict, Iterable, List, Optional, Tuple, TYPE_CHECKING
 
-import agate
-from dbt_common.clients.agate_helper import empty_table, table_from_data_flat
 from dbt_common.events.contextvars import get_node_info
 from dbt_common.events.functions import fire_event
 from dbt_common.exceptions import DbtInternalError, NotImplementedError
@@ -22,6 +20,9 @@ from dbt.adapters.events.types import (
     SQLQueryStatus,
 )
 
+if TYPE_CHECKING:
+    import agate
+
 
 class SQLConnectionManager(BaseConnectionManager):
     """The default connection manager with some common SQL methods implemented.
@@ -126,7 +127,9 @@ class SQLConnectionManager(BaseConnectionManager):
         return [dict(zip(column_names, row)) for row in rows]
 
     @classmethod
-    def get_result_from_cursor(cls, cursor: Any, limit: Optional[int]) -> agate.Table:
+    def get_result_from_cursor(cls, cursor: Any, limit: Optional[int]) -> "agate.Table":
+        from dbt_common.clients.agate_helper import table_from_data_flat
+
         data: List[Any] = []
         column_names: List[str] = []
 
@@ -146,7 +149,9 @@ class SQLConnectionManager(BaseConnectionManager):
         auto_begin: bool = False,
         fetch: bool = False,
         limit: Optional[int] = None,
-    ) -> Tuple[AdapterResponse, agate.Table]:
+    ) -> Tuple[AdapterResponse, "agate.Table"]:
+        from dbt_common.clients.agate_helper import empty_table
+
         sql = self._add_query_comment(sql)
         _, cursor = self.add_query(sql, auto_begin)
         response = self.get_response(cursor)

{dbt_adapters-1.0.0b1 → dbt_adapters-1.0.0b2}/dbt/adapters/sql/impl.py

@@ -1,6 +1,5 @@
-from typing import Any, List, Optional, Tuple, Type
+from typing import Any, List, Optional, Tuple, Type, TYPE_CHECKING
 
-import agate
 from dbt_common.events.functions import fire_event
 
 from dbt.adapters.base import BaseAdapter, BaseRelation, available
@@ -23,6 +22,9 @@ DROP_RELATION_MACRO_NAME = "drop_relation"
 ALTER_COLUMN_TYPE_MACRO_NAME = "alter_column_type"
 VALIDATE_SQL_MACRO_NAME = "validate_sql"
 
+if TYPE_CHECKING:
+    import agate
+
 
 class SQLAdapter(BaseAdapter):
     """The default adapter with the common agate conversions and some SQL
@@ -65,33 +67,35 @@ class SQLAdapter(BaseAdapter):
         return self.connections.add_query(sql, auto_begin, bindings, abridge_sql_log)
 
     @classmethod
-    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 "text"
 
     @classmethod
-    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:
+        import agate
+
         # TODO CT-211
         decimals = agate_table.aggregate(agate.MaxPrecision(col_idx))  # type: ignore[attr-defined]
         return "float8" if decimals else "integer"
 
     @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 "integer"
 
     @classmethod
-    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 "boolean"
 
     @classmethod
-    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 "timestamp without time zone"
 
     @classmethod
-    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 "date"
 
     @classmethod
-    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 "time"
 
     @classmethod

{dbt_adapters-1.0.0b1 → dbt_adapters-1.0.0b2}/dbt/include/global_project/macros/relations/materialized_view/drop.sql

@@ -5,7 +5,7 @@ actually executes the drop, and `get_drop_sql`, which returns the template.
 */ #}
 
 {% macro drop_materialized_view(relation) -%}
-    {{ return(adapter.dispatch('drop_materialized_view', 'dbt')(relation)) }}
+    {{- adapter.dispatch('drop_materialized_view', 'dbt')(relation) -}}
 {%- endmacro %}
 
 

{dbt_adapters-1.0.0b1 → dbt_adapters-1.0.0b2}/dbt/include/global_project/macros/relations/table/drop.sql

@@ -5,7 +5,7 @@ actually executes the drop, and `get_drop_sql`, which returns the template.
 */ #}
 
 {% macro drop_table(relation) -%}
-    {{ return(adapter.dispatch('drop_table', 'dbt')(relation)) }}
+    {{- adapter.dispatch('drop_table', 'dbt')(relation) -}}
 {%- endmacro %}
 
 

{dbt_adapters-1.0.0b1 → dbt_adapters-1.0.0b2}/dbt/include/global_project/macros/relations/view/drop.sql

@@ -5,7 +5,7 @@ actually executes the drop, and `get_drop_sql`, which returns the template.
 */ #}
 
 {% macro drop_view(relation) -%}
-    {{ return(adapter.dispatch('drop_view', 'dbt')(relation)) }}
+    {{- adapter.dispatch('drop_view', 'dbt')(relation) -}}
 {%- endmacro %}
 
 

{dbt_adapters-1.0.0b1 → dbt_adapters-1.0.0b2}/pyproject.toml

@@ -142,6 +142,7 @@ files = [
 ]
 exclude = [
     "dbt/adapters/events/adapter_types_pb2.py",
+    "dbt-tests-adapter/dbt/__init__.py",  # overlaps with `dbt/__init__.py` as expected for namespaces
     "venv",
 ]
 [[tool.mypy.overrides]]

dbt_adapters-1.0.0b1/dbt/adapters/__about__.py

@@ -1 +0,0 @@
-version = "1.0.0b1"