sqlspec 0.63.0__py3-none-any.whl → 0.64.0__py3-none-any.whl

sqlspec/__init__.py

@@ -13,79 +13,98 @@ _warnings.filterwarnings(
 )
 del _warnings
 
+from importlib import import_module
+from importlib.machinery import EXTENSION_SUFFIXES
 from typing import TYPE_CHECKING, Any
 
-from sqlspec import adapters, base, builder, core, driver, exceptions, extensions, loader, migrations, typing, utils
 from sqlspec.__metadata__ import __version__
-from sqlspec.base import SQLSpec
-from sqlspec.builder import (
-    Column,
-    ColumnExpression,
-    CreateTable,
-    Delete,
-    DropTable,
-    FunctionColumn,
-    Insert,
-    Merge,
-    QueryBuilder,
-    Select,
-    SQLFactory,
-    Update,
-    sql,
-)
-from sqlspec.config import AsyncDatabaseConfig, SyncDatabaseConfig
-from sqlspec.core import (
-    SQL,
-    ArrowResult,
-    CacheConfig,
-    CacheStats,
-    ParameterConverter,
-    ParameterDeclaration,
-    ParameterProcessor,
-    ParameterStyle,
-    ParameterStyleConfig,
-    ParamTypeMatcher,
-    ProcessedState,
-    SQLResult,
-    StackOperation,
-    StackResult,
-    Statement,
-    StatementConfig,
-    StatementStack,
-    matches_param_type,
-    register_param_type,
-    resolve_param_type,
-)
-from sqlspec.core import filters as filters
-from sqlspec.driver import AsyncDriverAdapterBase, ExecutionResult, SyncDriverAdapterBase
-from sqlspec.exceptions import StackExecutionError
-from sqlspec.extensions.events import (
-    AsyncEventChannel,
-    AsyncEventListener,
-    EventMessage,
-    SyncEventChannel,
-    SyncEventListener,
-)
-from sqlspec.loader import SQLFile, SQLFileLoader
-from sqlspec.observability import (
-    LoggingConfig,
-    ObservabilityConfig,
-    ObservabilityRuntime,
-    RedactionConfig,
-    StatementEvent,
-    StatementObserver,
-    TelemetryConfig,
-    create_event,
-    create_statement_observer,
-    default_statement_observer,
-    format_statement_event,
-)
-from sqlspec.typing import ConnectionT, PoolT, SchemaT, StatementParameters, SupportedSchemaModel
+from sqlspec.utils import logging as _logging
 from sqlspec.utils.logging import suppress_erroneous_sqlglot_log_messages
-from sqlspec.utils.uuids import nanoid, uuid4, uuid6, uuid7
+
+_COMPILED = (_logging.__file__ or "").endswith(tuple(EXTENSION_SUFFIXES))
 
 if TYPE_CHECKING:
-    from sqlspec import dialects
+    from sqlspec import (
+        adapters,
+        base,
+        builder,
+        core,
+        dialects,
+        driver,
+        exceptions,
+        extensions,
+        loader,
+        migrations,
+        typing,
+        utils,
+    )
+    from sqlspec import config as config
+    from sqlspec import observability as observability
+    from sqlspec.base import SQLSpec
+    from sqlspec.builder import (
+        Column,
+        ColumnExpression,
+        CreateTable,
+        Delete,
+        DropTable,
+        FunctionColumn,
+        Insert,
+        Merge,
+        QueryBuilder,
+        Select,
+        SQLFactory,
+        Update,
+        sql,
+    )
+    from sqlspec.config import AsyncDatabaseConfig, SyncDatabaseConfig
+    from sqlspec.core import (
+        SQL,
+        ArrowResult,
+        CacheConfig,
+        CacheStats,
+        ParameterConverter,
+        ParameterDeclaration,
+        ParameterProcessor,
+        ParameterStyle,
+        ParameterStyleConfig,
+        ParamTypeMatcher,
+        ProcessedState,
+        SQLResult,
+        StackOperation,
+        StackResult,
+        Statement,
+        StatementConfig,
+        StatementStack,
+        matches_param_type,
+        register_param_type,
+        resolve_param_type,
+    )
+    from sqlspec.core import filters as filters
+    from sqlspec.driver import AsyncDriverAdapterBase, ExecutionResult, SyncDriverAdapterBase
+    from sqlspec.exceptions import StackExecutionError
+    from sqlspec.extensions.events import (
+        AsyncEventChannel,
+        AsyncEventListener,
+        EventMessage,
+        SyncEventChannel,
+        SyncEventListener,
+    )
+    from sqlspec.loader import SQLFile, SQLFileLoader
+    from sqlspec.observability import (
+        LoggingConfig,
+        ObservabilityConfig,
+        ObservabilityRuntime,
+        RedactionConfig,
+        StatementEvent,
+        StatementObserver,
+        TelemetryConfig,
+        create_event,
+        create_statement_observer,
+        default_statement_observer,
+        format_statement_event,
+    )
+    from sqlspec.typing import ConnectionT, PoolT, SchemaT, StatementParameters, SupportedSchemaModel
+    from sqlspec.utils.uuids import nanoid, uuid4, uuid6, uuid7
 
 __all__ = (
     "SQL",
@@ -174,10 +193,111 @@ __all__ = (
 suppress_erroneous_sqlglot_log_messages()
 
 
-def __getattr__(name: str) -> "Any":
-    if name == "dialects":
-        import importlib
+_EXPORTS: dict[str, tuple[str, str | None]] = {
+    "ArrowResult": ("sqlspec.core", "ArrowResult"),
+    "AsyncDatabaseConfig": ("sqlspec.config", "AsyncDatabaseConfig"),
+    "AsyncDriverAdapterBase": ("sqlspec.driver", "AsyncDriverAdapterBase"),
+    "AsyncEventChannel": ("sqlspec.extensions.events", "AsyncEventChannel"),
+    "AsyncEventListener": ("sqlspec.extensions.events", "AsyncEventListener"),
+    "CacheConfig": ("sqlspec.core", "CacheConfig"),
+    "CacheStats": ("sqlspec.core", "CacheStats"),
+    "Column": ("sqlspec.builder", "Column"),
+    "ColumnExpression": ("sqlspec.builder", "ColumnExpression"),
+    "ConnectionT": ("sqlspec.typing", "ConnectionT"),
+    "CreateTable": ("sqlspec.builder", "CreateTable"),
+    "Delete": ("sqlspec.builder", "Delete"),
+    "DropTable": ("sqlspec.builder", "DropTable"),
+    "EventMessage": ("sqlspec.extensions.events", "EventMessage"),
+    "ExecutionResult": ("sqlspec.driver", "ExecutionResult"),
+    "FunctionColumn": ("sqlspec.builder", "FunctionColumn"),
+    "Insert": ("sqlspec.builder", "Insert"),
+    "LoggingConfig": ("sqlspec.observability", "LoggingConfig"),
+    "Merge": ("sqlspec.builder", "Merge"),
+    "ObservabilityConfig": ("sqlspec.observability", "ObservabilityConfig"),
+    "ObservabilityRuntime": ("sqlspec.observability", "ObservabilityRuntime"),
+    "ParamTypeMatcher": ("sqlspec.core", "ParamTypeMatcher"),
+    "ParameterConverter": ("sqlspec.core", "ParameterConverter"),
+    "ParameterDeclaration": ("sqlspec.core", "ParameterDeclaration"),
+    "ParameterProcessor": ("sqlspec.core", "ParameterProcessor"),
+    "ParameterStyle": ("sqlspec.core", "ParameterStyle"),
+    "ParameterStyleConfig": ("sqlspec.core", "ParameterStyleConfig"),
+    "PoolT": ("sqlspec.typing", "PoolT"),
+    "ProcessedState": ("sqlspec.core", "ProcessedState"),
+    "QueryBuilder": ("sqlspec.builder", "QueryBuilder"),
+    "RedactionConfig": ("sqlspec.observability", "RedactionConfig"),
+    "SQL": ("sqlspec.core", "SQL"),
+    "SQLFactory": ("sqlspec.builder", "SQLFactory"),
+    "SQLFile": ("sqlspec.loader", "SQLFile"),
+    "SQLFileLoader": ("sqlspec.loader", "SQLFileLoader"),
+    "SQLResult": ("sqlspec.core", "SQLResult"),
+    "SQLSpec": ("sqlspec.base", "SQLSpec"),
+    "SchemaT": ("sqlspec.typing", "SchemaT"),
+    "Select": ("sqlspec.builder", "Select"),
+    "StackExecutionError": ("sqlspec.exceptions", "StackExecutionError"),
+    "StackOperation": ("sqlspec.core", "StackOperation"),
+    "StackResult": ("sqlspec.core", "StackResult"),
+    "Statement": ("sqlspec.core", "Statement"),
+    "StatementConfig": ("sqlspec.core", "StatementConfig"),
+    "StatementEvent": ("sqlspec.observability", "StatementEvent"),
+    "StatementObserver": ("sqlspec.observability", "StatementObserver"),
+    "StatementParameters": ("sqlspec.typing", "StatementParameters"),
+    "StatementStack": ("sqlspec.core", "StatementStack"),
+    "SupportedSchemaModel": ("sqlspec.typing", "SupportedSchemaModel"),
+    "SyncDatabaseConfig": ("sqlspec.config", "SyncDatabaseConfig"),
+    "SyncDriverAdapterBase": ("sqlspec.driver", "SyncDriverAdapterBase"),
+    "SyncEventChannel": ("sqlspec.extensions.events", "SyncEventChannel"),
+    "SyncEventListener": ("sqlspec.extensions.events", "SyncEventListener"),
+    "TelemetryConfig": ("sqlspec.observability", "TelemetryConfig"),
+    "Update": ("sqlspec.builder", "Update"),
+    "adapters": ("sqlspec.adapters", None),
+    "base": ("sqlspec.base", None),
+    "builder": ("sqlspec.builder", None),
+    "config": ("sqlspec.config", None),
+    "core": ("sqlspec.core", None),
+    "create_event": ("sqlspec.observability", "create_event"),
+    "create_statement_observer": ("sqlspec.observability", "create_statement_observer"),
+    "default_statement_observer": ("sqlspec.observability", "default_statement_observer"),
+    "dialects": ("sqlspec.dialects", None),
+    "driver": ("sqlspec.driver", None),
+    "exceptions": ("sqlspec.exceptions", None),
+    "extensions": ("sqlspec.extensions", None),
+    "filters": ("sqlspec.core", "filters"),
+    "format_statement_event": ("sqlspec.observability", "format_statement_event"),
+    "loader": ("sqlspec.loader", None),
+    "matches_param_type": ("sqlspec.core", "matches_param_type"),
+    "migrations": ("sqlspec.migrations", None),
+    "nanoid": ("sqlspec.utils.uuids", "nanoid"),
+    "observability": ("sqlspec.observability", None),
+    "register_param_type": ("sqlspec.core", "register_param_type"),
+    "resolve_param_type": ("sqlspec.core", "resolve_param_type"),
+    "sql": ("sqlspec.builder._factory", "sql"),
+    "typing": ("sqlspec.typing", None),
+    "utils": ("sqlspec.utils", None),
+    "uuid4": ("sqlspec.utils.uuids", "uuid4"),
+    "uuid6": ("sqlspec.utils.uuids", "uuid6"),
+    "uuid7": ("sqlspec.utils.uuids", "uuid7"),
+}
+
+
+def __getattr__(name: str) -> Any:
+    target = _EXPORTS.get(name)
+    if target is None:
+        msg = f"module {__name__!r} has no attribute {name!r}"
+        raise AttributeError(msg)
+    module_name, attribute = target
+    module = import_module(module_name)
+    value = module if attribute is None else getattr(module, attribute)
+    globals()[name] = value
+    return value
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()) | _EXPORTS.keys())
+
 
-        return importlib.import_module("sqlspec.dialects")
-    msg = f"module {__name__!r} has no attribute {name!r}"
-    raise AttributeError(msg)
+# Native cross-module initialization is not protected by Python import locks.
+# Retain eager exports in compiled wheels until mypyc supports lazy concurrency.
+if _COMPILED:
+    for _name in __all__:
+        if _name not in globals():
+            __getattr__(_name)

sqlspec/_typing.py

@@ -336,10 +336,6 @@ def attrs_define_stub(*args: Any, **kwargs: Any) -> Any:  # noqa: ARG001
     return _attrs_define_identity
 
 
-def _attrs_define_identity(cls: Any) -> Any:
-    return cls
-
-
 def attrs_field_stub(*args: Any, **kwargs: Any) -> Any:  # noqa: ARG001
     """Placeholder implementation"""
     return None
@@ -751,3 +747,7 @@ def __dir__() -> "list[str]":
     """Expose the public surface for autocomplete and ``dir()``."""
 
     return sorted(set(globals()) | set(__all__))
+
+
+def _attrs_define_identity(cls: Any) -> Any:
+    return cls

sqlspec/adapters/adbc/_typing.py

@@ -9,9 +9,13 @@ import contextlib
 from typing import TYPE_CHECKING, Any
 
 from adbc_driver_manager import Error as _AdbcNativeError
+from adbc_driver_manager import NotSupportedError as AdbcNotSupportedError
+from adbc_driver_manager import OperationalError as AdbcOperationalError
 from adbc_driver_manager.dbapi import Connection
 from adbc_driver_manager.dbapi import Cursor as _AdbcRawCursor
 
+from sqlspec.typing import import_optional_attr
+
 _AdbcConnection = Connection
 
 if TYPE_CHECKING:
@@ -19,6 +23,8 @@ if TYPE_CHECKING:
     from types import TracebackType
     from typing import TypeAlias
 
+    from adbc_driver_flightsql import DatabaseOptions as AdbcFlightSqlDatabaseOptions
+
     from sqlspec.adapters.adbc.driver import AdbcDriver
     from sqlspec.core import StatementConfig
 
@@ -31,7 +37,16 @@ if not TYPE_CHECKING:
     AdbcRawCursor = _AdbcRawCursor
     AdbcNativeError = _AdbcNativeError
 
-__all__ = ("AdbcConnection", "AdbcCursor", "AdbcNativeError", "AdbcRawCursor", "AdbcSessionContext")
+__all__ = (
+    "AdbcConnection",
+    "AdbcCursor",
+    "AdbcFlightSqlDatabaseOptions",
+    "AdbcNativeError",
+    "AdbcNotSupportedError",
+    "AdbcOperationalError",
+    "AdbcRawCursor",
+    "AdbcSessionContext",
+)
 
 
 class AdbcCursor:
@@ -77,7 +92,7 @@ class AdbcSessionContext:
     def __init__(
         self,
         acquire_connection: "Callable[[], Any]",
-        release_connection: "Callable[[Any], Any]",
+        release_connection: "Callable[..., Any]",
         statement_config: "StatementConfig",
         driver_features: "dict[str, Any]",
         prepare_driver: "Callable[[AdbcDriver], AdbcDriver]",
@@ -108,6 +123,18 @@ class AdbcSessionContext:
         self, exc_type: "type[BaseException] | None", exc_val: "BaseException | None", exc_tb: "TracebackType | None"
     ) -> "bool | None":
         if self._connection is not None:
-            self._release_connection(self._connection)
+            self._release_connection(self._connection, exc_type=exc_type, exc_val=exc_val, exc_tb=exc_tb)
             self._connection = None
         return None
+
+
+def __getattr__(name: str) -> Any:
+    """Load Flight SQL options only when that optional driver is used."""
+    if name != "AdbcFlightSqlDatabaseOptions":
+        msg = f"module {__name__!r} has no attribute {name!r}"
+        raise AttributeError(msg)
+    value = import_optional_attr("adbc_driver_flightsql", "DatabaseOptions")
+    if value is None:
+        msg = "Cannot import DatabaseOptions from adbc_driver_flightsql"
+        raise ImportError(msg)
+    return value

sqlspec/adapters/adbc/config.py

@@ -25,7 +25,7 @@ from sqlspec.core.config_runtime import (
     resolve_postgres_extension_state,
     resolve_runtime_statement_config,
 )
-from sqlspec.driver._sync import SyncPoolConnectionContext, SyncPoolSessionFactory
+from sqlspec.driver import SyncPoolConnectionContext, SyncPoolSessionFactory
 from sqlspec.exceptions import ImproperConfigurationError
 from sqlspec.extensions.events import EventRuntimeHints
 from sqlspec.utils.config_tools import normalize_connection_config
@@ -44,6 +44,11 @@ class AdbcConnectionParams(TypedDict):
     """ADBC connection parameters."""
 
     uri: NotRequired[str]
+    dsn: NotRequired[str]
+    url: NotRequired[str]
+    connection_string: NotRequired[str]
+    db: NotRequired[str]
+    path: NotRequired[str]
     driver_name: NotRequired[str]
     db_kwargs: NotRequired[dict[str, Any]]
     conn_kwargs: NotRequired[dict[str, Any]]
@@ -241,7 +246,41 @@ class AdbcConfig(NoPoolSyncConfig[AdbcConnection, AdbcDriver]):
             observability_config: Adapter-level observability overrides for lifecycle hooks and observers
             **kwargs: Additional keyword arguments passed to the base configuration.
         """
-        self.connection_config = normalize_connection_config(connection_config)
+        config_dict = normalize_connection_config(connection_config)
+        if "uri" not in config_dict:
+            uri = (
+                config_dict.pop("url", None)
+                or config_dict.pop("dsn", None)
+                or config_dict.pop("connection_string", None)
+            )
+            if uri is not None:
+                config_dict["uri"] = uri
+        else:
+            config_dict.pop("url", None)
+            config_dict.pop("dsn", None)
+            config_dict.pop("connection_string", None)
+
+        driver_name = config_dict.get("driver_name")
+        if (driver_name in {"sqlite", "adbc_driver_sqlite"} or driver_name is None) and "uri" not in config_dict:
+            db_path = (
+                config_dict.pop("database", None)
+                or config_dict.pop("db", None)
+                or config_dict.pop("path", None)
+                or config_dict.pop("file", None)
+            )
+            if db_path is not None:
+                config_dict["uri"] = db_path
+        elif driver_name in {"duckdb", "adbc_driver_duckdb"} and "path" not in config_dict:
+            duck_path = (
+                config_dict.pop("database", None)
+                or config_dict.pop("db", None)
+                or config_dict.pop("file", None)
+                or config_dict.pop("path", None)
+            )
+            if duck_path is not None:
+                config_dict["path"] = duck_path
+
+        self.connection_config = config_dict
         self._pgvector_available: bool | None = None
         self._paradedb_available: bool | None = None
         self._pg_textsearch_available: bool | None = None

sqlspec/adapters/adbc/core.py

@@ -76,6 +76,7 @@ __all__ = (
     "handle_postgres_rollback",
     "is_postgres_dialect",
     "is_postgres_extension_active",
+    "is_shared_object_driver",
     "normalize_driver_path",
     "normalize_postgres_empty_parameters",
     "normalize_script_rowcount",
@@ -170,7 +171,13 @@ _PARAMETER_STYLES_BY_KEYWORD: "tuple[tuple[str, tuple[tuple[str, ...], str]], ..
     ("snowflake", (("qmark", "numeric"), "qmark")),
 )
 
-_BIGQUERY_DB_KWARGS_FIELDS: "tuple[str, ...]" = ("project_id", "dataset_id", "token")
+_BIGQUERY_DB_KWARGS_OPTIONS: "tuple[tuple[str, str], ...]" = (
+    ("project_id", "adbc.bigquery.sql.project_id"),
+    ("dataset_id", "adbc.bigquery.sql.dataset_id"),
+    ("token", "adbc.bigquery.sql.auth.refresh_token"),
+)
+_SHARED_OBJECT_SUFFIXES: "tuple[str, ...]" = (".so", ".dylib", ".dll")
+_DRIVER_MANAGER_CONNECT: Final[str] = "adbc_driver_manager.dbapi.connect"
 _FLIGHTSQL_DB_KWARGS_FIELDS: "tuple[str, ...]" = ("username", "password")
 _FLIGHTSQL_TLS_SKIP_VERIFY_KEY: Final[str] = "adbc.flight.sql.client_option.tls_skip_verify"
 _FLIGHTSQL_AUTHORIZATION_HEADER_KEY: Final[str] = "adbc.flight.sql.authorization_header"
@@ -273,9 +280,27 @@ def detect_postgres_extensions(
         return False, False, False
 
 
+def is_shared_object_driver(driver_name: str) -> bool:
+    """Return whether a driver name points at a shared library rather than a module.
+
+    Args:
+        driver_name: Raw driver name or path from configuration.
+
+    Returns:
+        True when the value is a filesystem path to a driver shared object.
+    """
+    stripped = driver_name.strip()
+    if not stripped:
+        return False
+    lowered = stripped.lower()
+    return lowered.endswith(_SHARED_OBJECT_SUFFIXES) or "/" in stripped or "\\" in stripped
+
+
 def normalize_driver_path(driver_name: str) -> str:
     """Normalize a driver name to an importable connect function path."""
     stripped = driver_name.strip()
+    if is_shared_object_driver(stripped):
+        return _DRIVER_MANAGER_CONNECT
     if stripped.endswith(".dbapi.connect"):
         return stripped
     if stripped.endswith(".dbapi"):
@@ -320,6 +345,8 @@ def driver_kind_from_uri(uri: str) -> "str | None":
 def resolve_driver_name(driver_name: str | None, uri: str | None) -> str:
     """Resolve and normalize the driver name."""
     if isinstance(driver_name, str):
+        if is_shared_object_driver(driver_name):
+            return _DRIVER_MANAGER_CONNECT
         lowered_driver = driver_name.lower()
         alias = _DRIVER_ALIASES.get(lowered_driver)
         if alias is not None:
@@ -336,7 +363,13 @@ def resolve_driver_name(driver_name: str | None, uri: str | None) -> str:
 
 def resolve_driver_name_from_config(connection_config: "Mapping[str, Any]") -> str:
     """Resolve and normalize the driver name from a connection config mapping."""
-    return resolve_driver_name(connection_config.get("driver_name"), connection_config.get("uri"))
+    uri = (
+        connection_config.get("uri")
+        or connection_config.get("url")
+        or connection_config.get("dsn")
+        or connection_config.get("connection_string")
+    )
+    return resolve_driver_name(connection_config.get("driver_name"), uri)
 
 
 def resolve_driver_connect_func(driver_name: str | None, uri: str | None) -> "Callable[..., Any]":
@@ -360,9 +393,14 @@ def resolve_driver_connect_func(driver_name: str | None, uri: str | None) -> "Ca
 
 
 def resolve_dialect_from_driver_path(driver_path: str) -> str:
-    """Get the SQL dialect type based on the driver path."""
+    """Get the SQL dialect type based on the driver path.
+
+    Only the final path segment is considered, because a directory on the way to
+    the driver can carry the name of an unrelated database.
+    """
+    candidate = driver_path.replace("\\", "/").rsplit("/", 1)[-1] or driver_path
     for keyword, dialect in _DRIVER_PATH_KEYWORDS_TO_DIALECT:
-        if keyword in driver_path:
+        if keyword in candidate:
             return dialect
     return "sqlite"
 
@@ -382,7 +420,15 @@ def resolve_dialect_from_config(connection_config: "Mapping[str, Any]") -> str:
     if isinstance(driver_name, str) and driver_name.lower() in {"gizmosql", "gizmo"}:
         return "duckdb"
 
-    uri = connection_config.get("uri")
+    if isinstance(driver_name, str) and is_shared_object_driver(driver_name):
+        return resolve_dialect_from_driver_path(driver_name.lower())
+
+    uri = (
+        connection_config.get("uri")
+        or connection_config.get("url")
+        or connection_config.get("dsn")
+        or connection_config.get("connection_string")
+    )
     if isinstance(uri, str):
         lowered_uri = uri.lower()
         if lowered_uri.startswith(("gizmosql://", "gizmo://", "grpc+tls://")):
@@ -422,6 +468,15 @@ def build_connection_config(connection_config: "Mapping[str, Any]") -> "dict[str
     """
     config = dict(connection_config)
 
+    if "uri" not in config:
+        uri_alias = config.pop("url", None) or config.pop("dsn", None) or config.pop("connection_string", None)
+        if uri_alias is not None:
+            config["uri"] = uri_alias
+    else:
+        config.pop("url", None)
+        config.pop("dsn", None)
+        config.pop("connection_string", None)
+
     driver_name = config.get("driver_name")
     uri = config.get("uri")
     driver_kind: str | None = None
@@ -430,6 +485,29 @@ def build_connection_config(connection_config: "Mapping[str, Any]") -> "dict[str
     if driver_kind is None and isinstance(uri, str):
         driver_kind = driver_kind_from_uri(uri)
 
+    if (driver_kind == "sqlite" or driver_kind is None) and "uri" not in config:
+        db_path = (
+            config.pop("database", None)
+            or config.pop("db", None)
+            or config.pop("path", None)
+            or config.pop("file", None)
+        )
+        if db_path is not None:
+            config["uri"] = db_path
+            uri = db_path
+            if driver_kind is None:
+                driver_kind = "sqlite"
+
+    if driver_kind == "duckdb" and "path" not in config:
+        duck_path = (
+            config.pop("database", None)
+            or config.pop("db", None)
+            or config.pop("file", None)
+            or config.pop("path", None)
+        )
+        if duck_path is not None:
+            config["path"] = duck_path
+
     if isinstance(uri, str) and driver_kind == "sqlite" and uri.startswith("sqlite://"):
         config["uri"] = uri[9:]
     if isinstance(uri, str) and driver_kind == "duckdb" and uri.startswith("duckdb://"):
@@ -440,18 +518,29 @@ def build_connection_config(connection_config: "Mapping[str, Any]") -> "dict[str
     if legacy_entrypoint is not None:
         config.setdefault("entrypoint", legacy_entrypoint)
 
+    uses_driver_manager = (
+        resolve_driver_name(
+            driver_name if isinstance(driver_name, str) else None, uri if isinstance(uri, str) else None
+        )
+        == _DRIVER_MANAGER_CONNECT
+    )
+    if not uses_driver_manager:
+        config.pop("entrypoint", None)
+
     if driver_kind in {"gizmosql", "flightsql"}:
         _lift_flightsql_db_kwargs(config)
     elif driver_kind == "bigquery":
         db_kwargs = config.get("db_kwargs")
         db_kwargs_dict: dict[str, Any] = dict(db_kwargs) if isinstance(db_kwargs, dict) else {}
-        for param in _BIGQUERY_DB_KWARGS_FIELDS:
+        for param, option in _BIGQUERY_DB_KWARGS_OPTIONS:
             if param in config:
-                db_kwargs_dict[param] = config.pop(param)
+                db_kwargs_dict[option] = config.pop(param)
         if db_kwargs_dict:
             config["db_kwargs"] = db_kwargs_dict
 
     config.pop("driver_name", None)
+    if uses_driver_manager and isinstance(driver_name, str) and "driver" not in config:
+        config["driver"] = driver_name.strip()
 
     return config
 
@@ -1299,7 +1388,7 @@ def _prepare_batch_with_casts(
 
 def _resolve_flightsql_db_kwargs_keys() -> "tuple[str, str]":
     try:
-        from adbc_driver_flightsql import DatabaseOptions
+        from sqlspec.adapters.adbc._typing import AdbcFlightSqlDatabaseOptions as DatabaseOptions
     except ImportError:
         return _FLIGHTSQL_TLS_SKIP_VERIFY_KEY, _FLIGHTSQL_AUTHORIZATION_HEADER_KEY
     return DatabaseOptions.TLS_SKIP_VERIFY.value, DatabaseOptions.AUTHORIZATION_HEADER.value