dbt-lakecompute 0.1.0.dev1__py3-none-any.whl

dbt/__init__.py

@@ -0,0 +1,3 @@
+from pkgutil import extend_path
+
+__path__ = extend_path(__path__, __name__)

dbt/adapters/lakecompute/__init__.py

@@ -0,0 +1,17 @@
+from dbt.adapters.base import AdapterPlugin
+
+from dbt.adapters.lakecompute.connections import (  # noqa: F401
+    LakeComputeAdapterResponse,
+    LakeComputeConnectionManager,
+)
+from dbt.adapters.lakecompute.credentials import LakeComputeCredentials  # noqa: F401
+from dbt.adapters.lakecompute.relation import LakeComputeRelation  # noqa: F401
+from dbt.adapters.lakecompute.impl import LakeComputeAdapter
+from dbt.include import lakecompute
+
+
+Plugin: AdapterPlugin = AdapterPlugin(
+    adapter=LakeComputeAdapter,  # type: ignore[arg-type]
+    credentials=LakeComputeCredentials,
+    include_path=lakecompute.PACKAGE_PATH,
+)

dbt/adapters/lakecompute/__version__.py

@@ -0,0 +1 @@
+version = "0.1.0.dev1"

dbt/adapters/lakecompute/auth.py

@@ -0,0 +1,80 @@
+"""Mapping from the profile's ``method`` to the driver's ``adbc.dbt.auth.*`` options."""
+
+from typing import Dict, TYPE_CHECKING
+
+from dbt.adapters.exceptions import FailedToConnectError
+
+from dbt.adapters.lakecompute.credentials import LakeComputeAuthMethod
+
+if TYPE_CHECKING:
+    from dbt.adapters.lakecompute.credentials import LakeComputeCredentials
+
+
+OPTION_AUTH_METHOD = "adbc.dbt.auth.method"
+OPTION_AUTH_TOKEN = "adbc.dbt.auth.token"
+OPTION_AUTH_API_KEY = "adbc.dbt.auth.api_key"
+OPTION_AUTH_OKTA_AUTH_URL = "adbc.dbt.auth.okta.auth_url"
+OPTION_AUTH_OKTA_TOKEN_URL = "adbc.dbt.auth.okta.token_url"
+OPTION_AUTH_OKTA_CLIENT_ID = "adbc.dbt.auth.okta.client_id"
+OPTION_AUTH_FIVETRAN_CREDENTIAL = "adbc.dbt.auth.fivetran.credential"
+OPTION_AUTH_FIVETRAN_AUTH_URL = "adbc.dbt.auth.fivetran.auth_url"
+
+
+REQUIRED_FIELD_BY_METHOD: Dict[str, str] = {
+    LakeComputeAuthMethod.TOKEN: "token",
+    LakeComputeAuthMethod.API_KEY: "api_key",
+    LakeComputeAuthMethod.FIVETRAN: "fivetran_credential",
+    # okta_browser needs no pre-shared secret: the browser flow supplies it
+    LakeComputeAuthMethod.OKTA_BROWSER: "",
+}
+
+
+def validate_auth_credentials(credentials: "LakeComputeCredentials") -> None:
+    """Raise if ``method`` is unknown or its required field is missing."""
+    method = credentials.method
+
+    if method not in REQUIRED_FIELD_BY_METHOD:
+        supported = ", ".join(sorted(REQUIRED_FIELD_BY_METHOD))
+        raise FailedToConnectError(
+            f"Unknown lakecompute auth method {method!r}. Supported methods: {supported}."
+        )
+
+    required = REQUIRED_FIELD_BY_METHOD[method]
+    if required and not getattr(credentials, required, None):
+        raise FailedToConnectError(
+            f"lakecompute auth method {method!r} requires `{required}` to be set in the profile."
+        )
+
+
+def auth_options(credentials: "LakeComputeCredentials") -> Dict[str, str]:
+    """Build the ``adbc.dbt.auth.*`` database options for this profile.
+
+    Optional fields are emitted only when present: the driver distinguishes "unset" from
+    "set to empty".
+    """
+    validate_auth_credentials(credentials)
+
+    method = credentials.method
+    options: Dict[str, str] = {OPTION_AUTH_METHOD: str(method)}
+
+    if method == LakeComputeAuthMethod.TOKEN:
+        options[OPTION_AUTH_TOKEN] = str(credentials.token)
+
+    elif method == LakeComputeAuthMethod.API_KEY:
+        options[OPTION_AUTH_API_KEY] = str(credentials.api_key)
+
+    elif method == LakeComputeAuthMethod.OKTA_BROWSER:
+        _set_if_present(options, OPTION_AUTH_OKTA_AUTH_URL, credentials.okta_auth_url)
+        _set_if_present(options, OPTION_AUTH_OKTA_TOKEN_URL, credentials.okta_token_url)
+        _set_if_present(options, OPTION_AUTH_OKTA_CLIENT_ID, credentials.okta_client_id)
+
+    elif method == LakeComputeAuthMethod.FIVETRAN:
+        options[OPTION_AUTH_FIVETRAN_CREDENTIAL] = str(credentials.fivetran_credential)
+        _set_if_present(options, OPTION_AUTH_FIVETRAN_AUTH_URL, credentials.fivetran_auth_url)
+
+    return options
+
+
+def _set_if_present(options: Dict[str, str], key: str, value: object) -> None:
+    if value is not None and value != "":
+        options[key] = str(value)

dbt/adapters/lakecompute/column.py

@@ -0,0 +1,56 @@
+"""Column types are kept as ``describe`` reports them; the base class would rebuild
+``VARCHAR`` as ``character varying(256)``."""
+
+from dataclasses import dataclass
+from typing import ClassVar, Dict
+
+from dbt.adapters.base.column import Column
+
+_STRING_TYPES = frozenset({"varchar", "text", "string", "char", "bpchar"})
+
+
+@dataclass
+class LakeComputeColumn(Column):
+    # no STRING -> TEXT translation: contracts compare the literal type names
+    TYPE_LABELS: ClassVar[Dict[str, str]] = {}
+
+    @property
+    def data_type(self) -> str:
+        return self.dtype
+
+    def _scalar_type_name(self) -> str:
+        """``decimal`` for ``DECIMAL(38,2)``; empty for a list or array like ``DECIMAL(38,2)[]``."""
+        if self.dtype.rstrip().endswith("]"):
+            return ""
+        return self.dtype.lower().split("(")[0].strip()
+
+    def is_string(self) -> bool:
+        return self._scalar_type_name() in _STRING_TYPES
+
+    def is_numeric(self) -> bool:
+        return self._scalar_type_name() in ("decimal", "numeric")
+
+    def is_float(self) -> bool:
+        return self.dtype.lower() in ("real", "float", "float4", "float8", "double")
+
+    def is_integer(self) -> bool:
+        return self.dtype.lower() in (
+            "tinyint",
+            "smallint",
+            "integer",
+            "int",
+            "bigint",
+            "hugeint",
+            "utinyint",
+            "usmallint",
+            "uinteger",
+            "ubigint",
+            "uhugeint",
+            "int1",
+            "int2",
+            "int4",
+            "int8",
+        )
+
+    def __repr__(self) -> str:
+        return "<LakeComputeColumn {} ({})>".format(self.name, self.data_type)

dbt/adapters/lakecompute/connections.py

@@ -0,0 +1,415 @@
+"""Connection management for lake compute.
+
+* One shared ``AdbcDatabase`` per target, one ``AdbcConnection`` per thread. Auth runs once
+  per database, and the driver allows concurrent ``NewConnection``.
+* Connections are built by hand with ``autocommit=True``. ``Connection.adbc_clone()`` would
+  hardcode ``autocommit=False``, and the service has no transactions, so ``begin``/``commit``
+  are no-ops and ``transaction_open`` stays ``False``.
+* ``get_response`` is pure: query metadata is read once and stashed on the cursor for the
+  caller and the structured query-status event.
+"""
+
+import atexit
+import threading
+import time
+from contextlib import contextmanager
+from dataclasses import dataclass
+from typing import Any, cast, Dict, Iterable, Iterator, Optional, Tuple, TYPE_CHECKING
+
+from dbt.adapters.contracts.connection import (
+    AdapterResponse,
+    Connection,
+    ConnectionState,
+)
+from dbt.adapters.events.logging import AdapterLogger
+from dbt.adapters.events.types import ConnectionUsed, SQLQuery, SQLQueryStatus
+from dbt.adapters.sql import SQLConnectionManager
+from dbt_common.events.contextvars import get_node_info
+from dbt_common.events.functions import fire_event
+from dbt_common.exceptions import DbtDatabaseError, DbtRuntimeError
+from dbt_common.invocation import get_invocation_id
+from dbt_common.utils import cast_to_str
+
+from dbt.adapters.lakecompute.credentials import LakeComputeCredentials
+from dbt.adapters.lakecompute.driver import ResolvedDriver, resolve_driver
+from dbt.adapters.lakecompute.type_mapping import data_type_code_to_name, normalize_value
+
+if TYPE_CHECKING:
+    import agate
+    from adbc_driver_manager import dbapi
+
+logger = AdapterLogger("LakeCompute")
+
+
+OPTION_LAST_QUERY_ID = "adbc.dbt.last_query_id"
+OPTION_LAST_WARNINGS = "adbc.dbt.last_warnings"
+OPTION_PROJECT = "adbc.dbt.project"
+OPTION_MODEL = "adbc.dbt.model"
+OPTION_RUN_ID = "adbc.dbt.run_id"
+
+_ATTR_QUERY_ID = "_lakecompute_query_id"
+_ATTR_WARNINGS = "_lakecompute_warnings"
+_ATTR_ACTIVE_STATEMENT = "_lakecompute_active_statement"
+
+
+@dataclass
+class LakeComputeAdapterResponse(AdapterResponse):
+    warning: Optional[str] = None
+
+
+# keyed by (path, entrypoint, sorted db_kwargs) so two targets never share a database
+_REGISTRY: Dict[Tuple[str, str, Tuple[Tuple[str, str], ...]], "dbapi._SharedDatabase"] = {}
+_REGISTRY_LOCK = threading.Lock()
+_CANCEL_LOCK = threading.Lock()
+
+
+def _close_all_databases() -> None:
+    """Release every shared database at interpreter exit.
+
+    Not wired into ``cleanup_all()``: dbt can call that mid-process, and dbt-tests-adapter
+    expects the databases to stay live.
+    """
+    with _REGISTRY_LOCK:
+        shared_databases = list(_REGISTRY.values())
+        _REGISTRY.clear()
+    for shared in shared_databases:
+        try:
+            shared.close()
+        except Exception as exc:  # pragma: no cover - best effort at shutdown
+            logger.debug(f"Error closing shared lakecompute database: {exc}")
+
+
+atexit.register(_close_all_databases)
+
+
+def _get_or_create_shared_database(resolved: ResolvedDriver) -> "dbapi._SharedDatabase":
+    """Return the refcounted ``_SharedDatabase`` for ``resolved``, creating it once."""
+    from adbc_driver_manager import _lib, dbapi
+
+    key = (resolved.path, resolved.entrypoint, tuple(sorted(resolved.db_kwargs.items())))
+    with _REGISTRY_LOCK:
+        if key not in _REGISTRY:
+            database = _lib.AdbcDatabase(
+                driver=resolved.path, entrypoint=resolved.entrypoint, **resolved.db_kwargs
+            )
+            _REGISTRY[key] = dbapi._SharedDatabase(database)
+        return _REGISTRY[key]
+
+
+def _new_thread_connection(shared: "dbapi._SharedDatabase") -> "dbapi.Connection":
+    """Build one autocommit ``dbapi.Connection`` over ``shared``.
+
+    ``Connection.__init__`` clones the ``_SharedDatabase`` itself, so do not pre-clone.
+    """
+    from adbc_driver_manager import _lib, dbapi
+
+    return dbapi.Connection(shared, _lib.AdbcConnection(shared._db), {}, autocommit=True)
+
+
+@contextmanager
+def _cancellable(connection: Connection, cursor: "dbapi.Cursor") -> Iterator[None]:
+    """Publish the in-flight statement on ``connection`` for the duration of the call.
+
+    ``cancel()`` needs the ``AdbcStatement``, because the driver only implements
+    statement-level cancel.
+    """
+    # A dbt connection belongs to one thread, so at most one statement is in flight on it.
+    with _CANCEL_LOCK:
+        setattr(connection, _ATTR_ACTIVE_STATEMENT, cursor.adbc_statement)
+    try:
+        yield
+    finally:
+        with _CANCEL_LOCK:
+            setattr(connection, _ATTR_ACTIVE_STATEMENT, None)
+
+
+class LakeComputeConnectionManager(SQLConnectionManager):
+    TYPE = "lakecompute"
+
+    def set_query_header(self, query_header_context: Dict[str, Any]) -> None:
+        # off unless the profile opts in; `_add_query_comment` is a no-op when this is None
+        credentials = cast(LakeComputeCredentials, self.profile.credentials)
+        if credentials.query_comment_enabled:
+            super().set_query_header(query_header_context)
+        else:
+            self.query_header = None
+
+    # The connection is autocommit and the service has no transactions. Like Athena and
+    # BigQuery, begin/commit do nothing, so `transaction_open` stays False and the base
+    # rollback/close paths never call `handle.rollback()`.
+
+    def begin(self) -> None:
+        pass
+
+    def commit(self) -> None:
+        pass
+
+    @classmethod
+    def open(cls, connection: Connection) -> Connection:
+        if connection.state == ConnectionState.OPEN:
+            logger.debug("Connection is already open, skipping open.")
+            return connection
+
+        credentials: LakeComputeCredentials = connection.credentials
+        resolved = resolve_driver(credentials)
+
+        from adbc_driver_manager import OperationalError
+
+        return cls.retry_connection(
+            connection,
+            connect=lambda: _new_thread_connection(_get_or_create_shared_database(resolved)),
+            logger=logger,
+            retry_limit=credentials.retries,
+            retryable_exceptions=(OperationalError,),
+        )
+
+    def cancel(self, connection: Connection) -> None:
+        """Cancel the statement currently in flight on ``connection``.
+
+        Statement-level, because the driver returns ``NOT_IMPLEMENTED`` for
+        ``AdbcConnectionCancel``. ``AdbcStatementCancel`` is safe to call from another thread.
+        A cancelled query surfaces on the blocked thread as ADBC ``INTERNAL`` with "... ended
+        with status Canceled", not as ``CANCELLED``.
+
+        The cancel runs under ``_CANCEL_LOCK``: ``AdbcStatement.cancel`` takes no lock of its
+        own, so without it the owning thread could leave ``_cancellable`` and release the
+        statement while the cancel is still inside the driver.
+        """
+        with _CANCEL_LOCK:
+            statement = getattr(connection, _ATTR_ACTIVE_STATEMENT, None)
+            if statement is None:
+                logger.debug(f"No in-flight lakecompute query to cancel on {connection.name}")
+                return
+            try:
+                statement.cancel()
+            except Exception as exc:
+                # don't mask the failure that prompted the cancel
+                logger.debug(f"Could not cancel lakecompute statement: {exc}")
+
+    @contextmanager
+    def exception_handler(self, sql: str) -> Iterator[None]:
+        try:
+            yield
+        except Exception as exc:
+            # no transaction, so no rollback_if_open() here
+            if isinstance(exc, DbtRuntimeError):
+                raise
+
+            status = getattr(getattr(exc, "status_code", None), "name", "UNKNOWN")
+            message = str(exc).strip()
+
+            if status in ("UNAUTHENTICATED", "UNAUTHORIZED"):
+                credentials = cast(LakeComputeCredentials, self.profile.credentials)
+                raise DbtDatabaseError(
+                    f"lakecompute rejected the credentials for auth method "
+                    f"'{credentials.method}': {message}"
+                ) from exc
+
+            if status in ("TIMEOUT", "CANCELLED"):
+                raise DbtDatabaseError(
+                    f"lakecompute query {status.lower()}: {message}. "
+                    f"Consider raising `timeout_seconds` in the profile."
+                ) from exc
+
+            raise DbtDatabaseError(message) from exc
+
+    def execute(
+        self,
+        sql: str,
+        auto_begin: bool = False,
+        fetch: bool = False,
+        limit: Optional[int] = None,
+    ) -> Tuple[AdapterResponse, "agate.Table"]:
+        """Run ``sql`` and, when asked, materialise its rows.
+
+        Keep the statement cancellable and translate driver errors until fetching finishes.
+        Each cursor owns an ``AdbcStatement`` and is closed before returning or raising.
+        """
+        from dbt_common.clients.agate_helper import empty_table
+
+        sql = self._add_query_comment(sql)
+        with self._query(sql, fetch=fetch, close_cursor=True) as (_, cursor):
+            table = self.get_result_from_cursor(cursor, limit) if fetch else empty_table()
+            return self.get_response(cursor), table
+
+    def add_select_query(self, sql: str) -> Tuple[Connection, "dbapi.Cursor"]:
+        # Same as execute: `get_column_schema_from_query` reads `cursor.description`, which is
+        # None on the no-fetch path. The cursor is handed back open, as the base contract says.
+        return self.add_query(self._add_query_comment(sql), fetch=True)
+
+    def add_query(
+        self,
+        sql: str,
+        auto_begin: bool = True,
+        bindings: Optional[Any] = None,
+        abridge_sql_log: bool = False,
+        retryable_exceptions: Tuple[type, ...] = tuple(),
+        retry_limit: int = 1,
+        *,
+        fetch: bool = False,
+    ) -> Tuple[Connection, "dbapi.Cursor"]:
+        """Send ``sql`` and return the cursor.
+
+        ``fetch`` is keyword-only so ``adapter.add_query(...)`` macro calls keep working. A
+        ``;``-joined batch is sent verbatim as one request; the service runs every statement.
+        """
+        if bindings is not None:
+            raise DbtRuntimeError(
+                "lakecompute does not support parameter binding; render literals into the SQL "
+                "instead."
+            )
+
+        # auto_begin and the retry arguments are accepted for signature compatibility only:
+        # there are no transactions, and queries are not retried.
+        with self._query(sql, abridge_sql_log, fetch=fetch) as (connection, cursor):
+            return connection, cursor
+
+    @contextmanager
+    def _query(
+        self,
+        sql: str,
+        abridge_sql_log: bool = False,
+        *,
+        fetch: bool = False,
+        close_cursor: bool = False,
+    ) -> Iterator[Tuple[Connection, "dbapi.Cursor"]]:
+        """Guard execution and optional result consumption as one operation.
+
+        ``add_query`` transfers ownership of a successful cursor to its caller. ``execute``
+        consumes it inside this context and requests cleanup on success too. Failures always
+        close the cursor, after deregistration has waited for any concurrent cancel.
+        """
+        connection = self.get_thread_connection()
+        fire_event(
+            ConnectionUsed(
+                conn_type=self.TYPE,
+                conn_name=cast_to_str(connection.name),
+                node_info=get_node_info(),
+            )
+        )
+
+        with self.exception_handler(sql):
+            log_sql = f"{sql[:512]}..." if abridge_sql_log else sql
+            fire_event(
+                SQLQuery(
+                    conn_name=cast_to_str(connection.name),
+                    sql=log_sql,
+                    node_info=get_node_info(),
+                )
+            )
+            started = time.perf_counter()
+
+            cursor: "dbapi.Cursor" = connection.handle.cursor()
+            try:
+                with _cancellable(connection, cursor):
+                    self._apply_statement_options(cursor)
+                    if fetch:
+                        cursor.execute(sql)
+                    else:
+                        # execute_update keeps rowcount without producing a result set.
+                        cursor.executemany(sql, None)
+
+                    self._collect_metadata(cursor)
+                    yield connection, cursor
+
+                    response = self.get_response(cursor)
+                    fire_event(
+                        SQLQueryStatus(
+                            status=str(response),
+                            elapsed=time.perf_counter() - started,
+                            node_info=get_node_info(),
+                            query_id=response.query_id,
+                        )
+                    )
+            except BaseException:
+                # Preserve the query error even if releasing the statement also fails.
+                try:
+                    cursor.close()
+                except Exception as exc:
+                    logger.debug(f"Error closing failed lakecompute cursor: {exc}")
+                raise
+            else:
+                if close_cursor:
+                    cursor.close()
+
+    def _apply_statement_options(self, cursor: "dbapi.Cursor") -> None:
+        """Set ``adbc.dbt.*`` attribution options on the statement.
+
+        Set after cursor construction so a rejected option cannot leave a half-built cursor,
+        and a rejection only logs: attribution must never fail a run.
+        """
+        options = self._statement_options()
+        if not options:
+            return
+        try:
+            cursor.adbc_statement.set_options(**options)
+        except Exception as exc:
+            logger.debug(f"lakecompute driver rejected statement options {sorted(options)}: {exc}")
+
+    def _statement_options(self) -> Dict[str, str]:
+        options: Dict[str, str] = {}
+
+        project_name = getattr(self.profile, "project_name", None)
+        if project_name:
+            options[OPTION_PROJECT] = str(project_name)
+
+        # empty for on-run-start/on-run-end hooks and for `dbt debug`
+        node_info = get_node_info() or {}
+        node_name = node_info.get("node_name")
+        if node_name:
+            options[OPTION_MODEL] = str(node_name)
+
+        invocation_id = get_invocation_id()
+        if invocation_id:
+            options[OPTION_RUN_ID] = str(invocation_id)
+
+        return options
+
+    @classmethod
+    def _collect_metadata(cls, cursor: "dbapi.Cursor") -> None:
+        # read now: a closed statement raises. Each read is best effort.
+        setattr(cursor, _ATTR_QUERY_ID, _try_get_option(cursor, OPTION_LAST_QUERY_ID))
+        setattr(cursor, _ATTR_WARNINGS, _try_get_option(cursor, OPTION_LAST_WARNINGS))
+
+    @classmethod
+    def get_response(cls, cursor: "dbapi.Cursor") -> LakeComputeAdapterResponse:
+        """Build the response; must stay pure (see the module docstring)."""
+        # dbapi reports -1 when the row count is unknown
+        rows_affected = cursor.rowcount if cursor.rowcount >= 0 else None
+
+        warning = getattr(cursor, _ATTR_WARNINGS, None)
+
+        message = "SUCCESS" if rows_affected is None else f"SUCCESS {rows_affected}"
+        if warning:
+            message = f"{message} [{warning}]"
+
+        return LakeComputeAdapterResponse(
+            _message=message,
+            code="SUCCESS",
+            rows_affected=rows_affected,
+            query_id=getattr(cursor, _ATTR_QUERY_ID, None),
+            warning=warning,
+        )
+
+    @classmethod
+    def data_type_code_to_name(cls, type_code: Any) -> str:
+        # Lives on the connection manager because `get_column_schema_from_query` calls it as
+        # `self.connections.data_type_code_to_name`. ADBC supplies a pyarrow DataType.
+        return data_type_code_to_name(type_code)
+
+    @classmethod
+    def process_results(
+        cls, column_names: Iterable[str], rows: Iterable[Any]
+    ) -> Iterator[Dict[str, Any]]:
+        for row in super().process_results(column_names, rows):
+            yield {key: normalize_value(value) for key, value in row.items()}
+
+
+def _try_get_option(cursor: "dbapi.Cursor", option: str) -> Optional[str]:
+    try:
+        value = cursor.adbc_statement.get_option(option)
+    except Exception:
+        return None
+    if value in (None, ""):
+        return None
+    return str(value)

dbt/adapters/lakecompute/credentials.py

@@ -0,0 +1,80 @@
+import os
+from dataclasses import dataclass
+from typing import Optional, Tuple
+
+from dbt.adapters.contracts.connection import Credentials
+from dbt_common.dataclass_schema import StrEnum
+
+DEFAULT_BASE_URL = "https://api.lake-compute.fivetran.com/"
+BASE_URL_ENV_VAR = "DBT_COMPUTE_BASE_URL"
+
+
+class LakeComputeAuthMethod(StrEnum):
+    TOKEN = "token"
+    API_KEY = "api_key"
+    OKTA_BROWSER = "okta_browser"
+    FIVETRAN = "fivetran"
+
+
+@dataclass
+class LakeComputeCredentials(Credentials):
+    """Profile fields for a ``type: lakecompute`` target.
+
+    Which auth fields are required depends on ``method``, so they are validated at connect
+    time (see ``auth.validate_auth_credentials``), where ``dbt debug`` can report them.
+    """
+
+    base_url: Optional[str] = None
+    method: str = LakeComputeAuthMethod.TOKEN
+
+    token: Optional[str] = None
+    api_key: Optional[str] = None
+    okta_auth_url: Optional[str] = None
+    okta_token_url: Optional[str] = None
+    okta_client_id: Optional[str] = None
+    fivetran_credential: Optional[str] = None
+    fivetran_auth_url: Optional[str] = None
+
+    warehouse: Optional[str] = None
+    dialect: Optional[str] = None
+    timeout_seconds: Optional[int] = None
+
+    retries: int = 1
+
+    driver_path: Optional[str] = None
+
+    query_comment_enabled: bool = False
+
+    _ALIASES = {"dbname": "database"}
+
+    @property
+    def type(self) -> str:
+        return "lakecompute"
+
+    @property
+    def unique_field(self) -> str:
+        return self.resolved_base_url
+
+    @property
+    def resolved_base_url(self) -> str:
+        """profile -> $DBT_COMPUTE_BASE_URL -> public endpoint."""
+        return self.base_url or os.getenv(BASE_URL_ENV_VAR) or DEFAULT_BASE_URL
+
+    def _connection_keys(self) -> Tuple[str, ...]:
+        # secrets (token, api_key, fivetran_credential) are deliberately absent
+        return (
+            "base_url",
+            "database",
+            "schema",
+            "method",
+            "warehouse",
+            "dialect",
+            "timeout_seconds",
+            "okta_auth_url",
+            "okta_token_url",
+            "okta_client_id",
+            "fivetran_auth_url",
+            "retries",
+            "driver_path",
+            "query_comment_enabled",
+        )