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

sqlspec/__init__.py

@@ -82,6 +82,7 @@ from sqlspec.observability import (
 )
 from sqlspec.typing import ConnectionT, PoolT, SchemaT, StatementParameters, SupportedSchemaModel
 from sqlspec.utils.logging import suppress_erroneous_sqlglot_log_messages
+from sqlspec.utils.uuids import nanoid, uuid4, uuid6, uuid7
 
 if TYPE_CHECKING:
     from sqlspec import dialects
@@ -159,11 +160,15 @@ __all__ = (
     "loader",
     "matches_param_type",
     "migrations",
+    "nanoid",
     "register_param_type",
     "resolve_param_type",
     "sql",
     "typing",
     "utils",
+    "uuid4",
+    "uuid6",
+    "uuid7",
 )
 
 suppress_erroneous_sqlglot_log_messages()

sqlspec/_typing.py

@@ -102,7 +102,6 @@ __all__ = (
     "Struct",
     "StructStub",
     "T",
-    "T_co",
     "Tracer",
     "TypeAdapter",
     "TypeAdapterStub",
@@ -139,7 +138,6 @@ class DataclassProtocol(Protocol):
 
 
 T = TypeVar("T")
-T_co = TypeVar("T_co", covariant=True)
 
 # Always define stub types for type checking
 

sqlspec/adapters/adbc/config.py

@@ -8,19 +8,23 @@ from sqlspec.adapters.adbc._typing import AdbcConnection, AdbcCursor, AdbcSessio
 from sqlspec.adapters.adbc.core import (
     apply_driver_features,
     build_connection_config,
-    build_postgres_extension_probe_names,
     detect_postgres_extensions,
     get_statement_config,
     is_postgres_dialect,
     resolve_dialect_from_config,
     resolve_dialect_name,
     resolve_driver_connect_func,
-    resolve_postgres_extension_state,
-    resolve_runtime_statement_config,
 )
 from sqlspec.adapters.adbc.driver import AdbcDriver, AdbcExceptionHandler
 from sqlspec.config import ExtensionConfigs, NoPoolSyncConfig
 from sqlspec.core import StatementConfig
+from sqlspec.core.capabilities import TypeCoercionCapabilities
+from sqlspec.core.config_runtime import (
+    build_postgres_extension_probe_names,
+    is_postgres_extension_active,
+    resolve_postgres_extension_state,
+    resolve_runtime_statement_config,
+)
 from sqlspec.driver._sync import SyncPoolConnectionContext, SyncPoolSessionFactory
 from sqlspec.exceptions import ImproperConfigurationError
 from sqlspec.extensions.events import EventRuntimeHints
@@ -81,20 +85,20 @@ class AdbcDriverFeatures(TypedDict):
     Attributes:
         json_serializer: JSON serialization function to use.
             Callable that takes Any and returns str (JSON string).
-        Default: sqlspec.utils.serializers.to_json
+            Default: sqlspec.utils.serializers.to_json
         enable_cast_detection: Enable cast-aware parameter processing.
             When True, detects SQL casts and applies appropriate
             serialization. Currently used for PostgreSQL JSONB handling.
-        Default: True
+            Default: True
         enable_strict_type_coercion: Enforce strict type coercion rules.
             When True, raises errors for unsupported type conversions.
             When False, attempts best-effort conversion.
-        Default: False
+            Default: False
         strict_type_coercion: Alias for enable_strict_type_coercion.
         enable_arrow_extension_types: Enable PyArrow extension type support.
             When True, preserves Arrow extension type metadata when reading data.
             When False, falls back to storage types.
-        Default: True
+            Default: True
         arrow_extension_types: Alias for enable_arrow_extension_types.
         enable_pgvector: Enable automatic pgvector extension detection.
             When True and the resolved dialect is PostgreSQL, queries ``pg_extension``
@@ -104,6 +108,10 @@ class AdbcDriverFeatures(TypedDict):
             When True and the resolved dialect is PostgreSQL, queries ``pg_extension``
             on the first connection to check for the ``pg_search`` extension.
             Defaults to True. Independent of enable_pgvector.
+        enable_pg_textsearch: Enable pg_textsearch extension detection for BM25 search.
+            When True and the resolved dialect is PostgreSQL, queries ``pg_extension``
+            on the first connection to check for the ``pg_textsearch`` extension.
+            Defaults to True.
         enable_events: Enable database event channel support.
             Defaults to True when extension_config["events"] is configured.
             Provides pub/sub capabilities via table-backed queue (ADBC has no native pub/sub).
@@ -111,7 +119,7 @@ class AdbcDriverFeatures(TypedDict):
         on_connection_create: Callback executed when a connection is created.
             Receives the raw ADBC connection for low-level driver configuration.
         events_backend: Event channel backend selection.
-        Only option: "poll_queue" (durable table-backed queue with lease-based retries and acknowledgements).
+            Only option: "poll_queue" (durable table-backed queue with lease-based retries and acknowledgements).
             ADBC does not have native pub/sub, so poll_queue is the only backend.
             Defaults to "poll_queue".
     """
@@ -124,6 +132,7 @@ class AdbcDriverFeatures(TypedDict):
     arrow_extension_types: NotRequired[bool]
     enable_pgvector: NotRequired[bool]
     enable_paradedb: NotRequired[bool]
+    enable_pg_textsearch: NotRequired[bool]
     enable_events: NotRequired[bool]
     on_connection_create: "NotRequired[Callable[[AdbcConnection], None]]"
     events_backend: NotRequired[Literal["poll_queue"]]
@@ -188,7 +197,11 @@ class AdbcConfig(NoPoolSyncConfig[AdbcConnection, AdbcDriver]):
     supports_native_row_streaming: "ClassVar[bool]" = True
     supports_native_parquet_export: "ClassVar[bool]" = True
     supports_native_parquet_import: "ClassVar[bool]" = True
+    supports_reliable_rowcount: ClassVar[bool] = False
     storage_partition_strategies: "ClassVar[tuple[str, ...]]" = ("fixed", "rows_per_chunk")
+    type_coercion_capabilities: "ClassVar[TypeCoercionCapabilities]" = TypeCoercionCapabilities(
+        datetime_binding="native", timestamp_precision="microsecond", json_columns_decoded=False, uuid_binding="native"
+    )
     _connection_context_class: "ClassVar[type[AdbcConnectionContext]]" = AdbcConnectionContext
     _session_factory_class: "ClassVar[type[_AdbcSessionConnectionHandler]]" = _AdbcSessionConnectionHandler
     _session_context_class: "ClassVar[type[AdbcSessionContext]]" = AdbcSessionContext
@@ -196,6 +209,7 @@ class AdbcConfig(NoPoolSyncConfig[AdbcConnection, AdbcDriver]):
     __slots__ = (
         "_default_session_config",
         "_paradedb_available",
+        "_pg_textsearch_available",
         "_pgvector_available",
         "_resolved_dialect",
         "_user_connection_hook",
@@ -230,6 +244,7 @@ class AdbcConfig(NoPoolSyncConfig[AdbcConnection, AdbcDriver]):
         self.connection_config = normalize_connection_config(connection_config)
         self._pgvector_available: bool | None = None
         self._paradedb_available: bool | None = None
+        self._pg_textsearch_available: bool | None = None
 
         self._resolved_dialect = resolve_dialect_from_config(self.connection_config)
 
@@ -284,20 +299,10 @@ class AdbcConfig(NoPoolSyncConfig[AdbcConnection, AdbcDriver]):
             msg = f"Could not configure connection using driver '{err_driver_name}'. Error: {e}"
             raise ImproperConfigurationError(msg) from e
 
-    def _update_dialect_for_extensions(self) -> None:
-        """Update statement_config dialect based on detected extensions.
-
-        Priority: paradedb > pgvector > postgres (default).
-        Only switches when current dialect is ``postgres``.
-        """
-        current_dialect = self.statement_config.dialect or "postgres"
-        if current_dialect != "postgres":
-            return
-
-        if self._paradedb_available:
-            self.statement_config = self.statement_config.replace(dialect="paradedb")
-        elif self._pgvector_available:
-            self.statement_config = self.statement_config.replace(dialect="pgvector")
+    @property
+    def pg_textsearch_available(self) -> bool:
+        """Return True if the pg_textsearch extension is available."""
+        return bool(self._pg_textsearch_available)
 
     def _detect_extensions_if_needed(self) -> None:
         """Detect postgres extensions on first call, caching results.
@@ -312,13 +317,17 @@ class AdbcConfig(NoPoolSyncConfig[AdbcConnection, AdbcDriver]):
         if not is_postgres_dialect(dialect):
             self._pgvector_available = False
             self._paradedb_available = False
+            self._pg_textsearch_available = False
             return
 
         connection = self.create_connection()
         try:
             probe_names = build_postgres_extension_probe_names(self.driver_features)
-            pgvector_available, paradedb_available = detect_postgres_extensions(
-                connection, enable_pgvector="vector" in probe_names, enable_paradedb="pg_search" in probe_names
+            pgvector_available, paradedb_available, pg_textsearch_available = detect_postgres_extensions(
+                connection,
+                enable_pgvector="vector" in probe_names,
+                enable_paradedb="pg_search" in probe_names,
+                enable_pg_textsearch="pg_textsearch" in probe_names,
             )
         finally:
             connection.close()
@@ -328,9 +337,12 @@ class AdbcConfig(NoPoolSyncConfig[AdbcConnection, AdbcDriver]):
             detected_extensions.add("vector")
         if paradedb_available:
             detected_extensions.add("pg_search")
+        if pg_textsearch_available:
+            detected_extensions.add("pg_textsearch")
         self.statement_config, self._pgvector_available, self._paradedb_available = resolve_postgres_extension_state(
             self.statement_config, self.driver_features, detected_extensions
         )
+        self._pg_textsearch_available = is_postgres_extension_active(self.driver_features, "pg_textsearch")
 
     def provide_connection(self, *args: Any, **kwargs: Any) -> "AdbcConnectionContext":
         """Provide a connection context manager.

sqlspec/adapters/adbc/core.py

@@ -21,9 +21,11 @@ from sqlspec.core import (
 )
 from sqlspec.core.config_runtime import (
     build_postgres_extension_probe_names,
+    is_postgres_extension_active,
     resolve_postgres_extension_state,
     resolve_runtime_statement_config,
 )
+from sqlspec.core.parameters import type_coercion_dispatcher
 from sqlspec.exceptions import (
     CheckViolationError,
     DatabaseConnectionError,
@@ -44,7 +46,6 @@ from sqlspec.exceptions import (
     map_sqlstate_to_exception,
 )
 from sqlspec.typing import PGVECTOR_INSTALLED, Empty
-from sqlspec.utils.dispatch import TypeDispatcher
 from sqlspec.utils.module_loader import import_string
 from sqlspec.utils.serializers import to_json
 from sqlspec.utils.type_converters import build_uuid_coercions
@@ -55,6 +56,7 @@ if TYPE_CHECKING:
     from collections.abc import Callable, Mapping
 
     from sqlspec.core import SQL
+    from sqlspec.utils.dispatch import TypeDispatcher
 
 __all__ = (
     "_prepare_batch_with_casts",
@@ -73,6 +75,7 @@ __all__ = (
     "get_statement_config",
     "handle_postgres_rollback",
     "is_postgres_dialect",
+    "is_postgres_extension_active",
     "normalize_driver_path",
     "normalize_postgres_empty_parameters",
     "normalize_script_rowcount",
@@ -171,7 +174,6 @@ _BIGQUERY_DB_KWARGS_FIELDS: "tuple[str, ...]" = ("project_id", "dataset_id", "to
 _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"
-_TYPE_COERCION_DISPATCHERS: "dict[tuple[tuple[type, Callable[[Any], Any]], ...], TypeDispatcher[Callable[[Any], Any]]]" = {}
 _SQLSTATE_CLASS_CODE_LEN = 2
 _SQLSTATE_DESCRIPTIONS: dict[str, str] = {
     "23": "integrity constraint violation",
@@ -231,29 +233,32 @@ def detect_dialect(connection: Any, logger: Any | None = None, *, fallback_diale
 
 
 def detect_postgres_extensions(
-    connection: Any, *, enable_pgvector: bool = False, enable_paradedb: bool = False
-) -> "tuple[bool, bool]":
-    """Detect pgvector and paradedb extensions on a postgres connection.
+    connection: Any, *, enable_pgvector: bool = False, enable_paradedb: bool = False, enable_pg_textsearch: bool = False
+) -> "tuple[bool, bool, bool]":
+    """Detect pgvector, paradedb, and pg_textsearch extensions on a postgres connection.
 
-    Queries ``pg_extension`` for the ``vector`` and ``pg_search`` extensions.
+    Queries ``pg_extension`` for the ``vector``, ``pg_search``, and ``pg_textsearch`` extensions.
     Returns cached-friendly booleans suitable for storing on the config instance.
 
     Args:
         connection: ADBC connection to a PostgreSQL database.
         enable_pgvector: Whether to check for the pgvector extension.
         enable_paradedb: Whether to check for the pg_search extension.
+        enable_pg_textsearch: Whether to check for the pg_textsearch extension.
 
     Returns:
-        Tuple of ``(pgvector_available, paradedb_available)``.
+        Tuple of ``(pgvector_available, paradedb_available, pg_textsearch_available)``.
     """
     extensions: list[str] = []
     if enable_pgvector:
         extensions.append("vector")
     if enable_paradedb:
         extensions.append("pg_search")
+    if enable_pg_textsearch:
+        extensions.append("pg_textsearch")
 
     if not extensions:
-        return False, False
+        return False, False, False
 
     try:
         cursor = connection.cursor()
@@ -261,11 +266,11 @@ def detect_postgres_extensions(
             cursor.execute("SELECT extname FROM pg_extension WHERE extname = ANY($1::text[])", [extensions])
             rows = cursor.fetchall()
             detected: set[str] = {row[0] for row in rows} if rows else set()
-            return "vector" in detected, "pg_search" in detected
+            return "vector" in detected, "pg_search" in detected, "pg_textsearch" in detected
         finally:
             cursor.close()
     except Exception:
-        return False, False
+        return False, False, False
 
 
 def normalize_driver_path(driver_name: str) -> str:
@@ -455,15 +460,21 @@ def resolve_dialect_name(dialect: Any) -> str:
     """Return the normalized dialect name string."""
     if dialect is None:
         return ""
+    if isinstance(dialect, str):
+        return dialect.lower()
+    if isinstance(dialect, type) and issubclass(dialect, sqlglot.Dialect):
+        return dialect.__name__.lower()
+    if isinstance(dialect, sqlglot.Dialect):
+        return type(dialect).__name__.lower()
     return str(dialect)
 
 
 def is_postgres_dialect(dialect_name: str) -> bool:
     """Return True when the dialect indicates PostgreSQL.
 
-    Includes pgvector and paradedb which are PostgreSQL extension dialects.
+    Includes pgvector, paradedb, and pg_textsearch extension dialects.
     """
-    return dialect_name in {"postgres", "postgresql", "pgvector", "paradedb"}
+    return dialect_name in {"postgres", "postgresql", "pgvector", "paradedb", "pg_textsearch", "pgtextsearch"}
 
 
 def handle_postgres_rollback(dialect: str, cursor: Any, logger: Any | None = None) -> None:
@@ -726,7 +737,8 @@ def build_profile() -> "DriverParameterProfile":
 def get_statement_config(detected_dialect: str) -> StatementConfig:
     """Create statement configuration for the specified dialect."""
     default_style, supported_styles = DIALECT_PARAMETER_STYLES.get(
-        detected_dialect, (ParameterStyle.QMARK, [ParameterStyle.QMARK])
+        "postgres" if is_postgres_dialect(detected_dialect) else detected_dialect,
+        (ParameterStyle.QMARK, [ParameterStyle.QMARK]),
     )
 
     sqlglot_dialect = "postgres" if detected_dialect == "postgresql" else detected_dialect
@@ -744,7 +756,7 @@ def get_statement_config(detected_dialect: str) -> StatementConfig:
         parameter_overrides["preserve_parameter_format"] = False
         parameter_overrides["supported_execution_parameter_styles"] = {ParameterStyle.QMARK, ParameterStyle.NUMERIC}
 
-    if detected_dialect in {"postgres", "postgresql"}:
+    if is_postgres_dialect(detected_dialect):
         parameter_overrides["ast_transformer"] = build_null_pruning_transform(dialect=sqlglot_dialect)
 
     return build_statement_config_from_profile(
@@ -775,6 +787,7 @@ def apply_driver_features(
     processed_features.setdefault("enable_arrow_extension_types", processed_features["arrow_extension_types"])
     processed_features.setdefault("enable_pgvector", PGVECTOR_INSTALLED)
     processed_features.setdefault("enable_paradedb", True)
+    processed_features.setdefault("enable_pg_textsearch", True)
 
     if json_serializer is not None:
         statement_config = _apply_adbc_json_serializer(statement_config, json_serializer)
@@ -898,7 +911,7 @@ def prepare_parameters_with_casts(
     if isinstance(parameters, (list, tuple)):
         converter = get_adbc_type_converter(dialect)
         type_map = statement_config.parameter_config.type_coercion_map
-        dispatcher = _type_coercion_dispatcher(type_map) if type_map else None
+        dispatcher = type_coercion_dispatcher(tuple(type_map.items())) if type_map else None
         return _prepare_parameter_sequence_with_casts(
             parameters, parameter_casts, type_map, dispatcher, converter, json_encoder
         )
@@ -1211,18 +1224,6 @@ def _apply_adbc_json_serializer(
     return statement_config.replace(parameter_config=updated_parameter_config.replace(type_coercion_map=updated_map))
 
 
-def _type_coercion_dispatcher(type_map: "dict[type, Callable[[Any], Any]]") -> "TypeDispatcher[Callable[[Any], Any]]":
-    fallback_items = tuple(type_map.items())
-    dispatcher = _TYPE_COERCION_DISPATCHERS.get(fallback_items)
-    if dispatcher is not None:
-        return dispatcher
-
-    dispatcher = TypeDispatcher["Callable[[Any], Any]"]()
-    dispatcher.register_all(fallback_items)
-    _TYPE_COERCION_DISPATCHERS[fallback_items] = dispatcher
-    return dispatcher
-
-
 def _prepare_parameter_sequence_with_casts(
     parameters: "list[Any] | tuple[Any, ...]",
     parameter_casts: "dict[int, str]",
@@ -1287,7 +1288,7 @@ def _prepare_batch_with_casts(
     json_encoder = statement_config.parameter_config.json_serializer or json_serializer
     converter = get_adbc_type_converter(dialect)
     type_map = statement_config.parameter_config.type_coercion_map
-    dispatcher = _type_coercion_dispatcher(type_map) if type_map else None
+    dispatcher = type_coercion_dispatcher(tuple(type_map.items())) if type_map else None
     return [
         _prepare_parameter_sequence_with_casts(row, parameter_casts, type_map, dispatcher, converter, json_encoder)
         if isinstance(row, (list, tuple))

sqlspec/adapters/adbc/driver.py

@@ -59,6 +59,7 @@ if TYPE_CHECKING:
 __all__ = ("AdbcCursor", "AdbcDriver", "AdbcExceptionHandler", "AdbcSessionContext")
 
 logger = get_logger("sqlspec.adapters.adbc")
+_DIALECTS_WITHOUT_SAVEPOINTS = frozenset({"bigquery", "duckdb", "snowflake"})
 
 _MULTI_ROW_BIND_UNSUPPORTED = "Binding multiple rows at once is not supported"
 
@@ -377,6 +378,33 @@ class AdbcDriver(SyncDriverAdapterBase):
         finally:
             self._transaction_active = False
 
+    def create_savepoint(self, name: str) -> None:
+        """Create a savepoint within the current transaction.
+
+        Raises:
+            NotImplementedError: If the connected database does not support savepoints.
+        """
+        self._require_savepoints()
+        super().create_savepoint(name)
+
+    def release_savepoint(self, name: str) -> None:
+        """Release a previously created savepoint.
+
+        Raises:
+            NotImplementedError: If the connected database does not support savepoints.
+        """
+        self._require_savepoints()
+        super().release_savepoint(name)
+
+    def rollback_to_savepoint(self, name: str) -> None:
+        """Roll back the current transaction to a previously created savepoint.
+
+        Raises:
+            NotImplementedError: If the connected database does not support savepoints.
+        """
+        self._require_savepoints()
+        super().rollback_to_savepoint(name)
+
     def set_migration_session_schema(self, schema: str) -> None:
         """Set the PostgreSQL search path for migration SQL when using ADBC PostgreSQL."""
         if not self._is_postgres:
@@ -516,19 +544,13 @@ class AdbcDriver(SyncDriverAdapterBase):
                 arrow_schema=arrow_schema,
             )
 
-        # Use ADBC cursor for native Arrow
         with self.with_cursor(self.connection) as cursor, exc_handler:
             if cursor is None:
                 msg = "Failed to create cursor"
                 raise DatabaseConnectionError(msg)
 
-            # Get compiled SQL and parameters
             sql, driver_params = self._compiled_sql(prepared_statement, config)
-
-            # Execute query
             cursor.execute(sql, driver_params or ())
-
-            # Fetch as Arrow table (zero-copy!)
             arrow_table = cursor.fetch_arrow_table()
 
             arrow_result = build_arrow_result_from_table(
@@ -566,7 +588,6 @@ class AdbcDriver(SyncDriverAdapterBase):
     ) -> "StorageBridgeJob":
         """Stream query results to storage via the Arrow fast path."""
 
-        _ = kwargs
         self._require_capability("arrow_export_enabled")
         arrow_result = self.select_to_arrow(statement, *parameters, statement_config=statement_config, **kwargs)
         sync_pipeline = self._storage_pipeline()
@@ -729,6 +750,11 @@ class AdbcDriver(SyncDriverAdapterBase):
         """
         return self._transaction_active
 
+    def _require_savepoints(self) -> None:
+        if self._dialect_name in _DIALECTS_WITHOUT_SAVEPOINTS:
+            msg = f"ADBC {self._dialect_name} connections do not support savepoints."
+            raise NotImplementedError(msg)
+
     @staticmethod
     def _detect_flightsql_connection(connection: "AdbcConnection") -> bool:
         try:

sqlspec/adapters/adbc/type_converter.py

@@ -34,7 +34,15 @@ class ADBCOutputConverter:
         Returns:
             Converted value appropriate for the dialect.
         """
-        if self.dialect in {"postgres", "postgresql", "pgvector", "paradedb", "bigquery"}:
+        if self.dialect in {
+            "postgres",
+            "postgresql",
+            "pgvector",
+            "paradedb",
+            "pg_textsearch",
+            "pgtextsearch",
+            "bigquery",
+        }:
             return to_json(value)
         return value
 
@@ -51,7 +59,7 @@ class ADBCOutputConverter:
             Converted list parameter appropriate for the dialect.
         """
         items = list(value)
-        if self.dialect in {"postgres", "postgresql", "pgvector", "paradedb"}:
+        if self.dialect in {"postgres", "postgresql", "pgvector", "paradedb", "pg_textsearch", "pgtextsearch"}:
             return [item if item is not None else None for item in items]
         return items
 

sqlspec/adapters/aiomysql/config.py

@@ -18,6 +18,7 @@ from sqlspec.adapters.aiomysql._typing import (
 from sqlspec.adapters.aiomysql.core import apply_driver_features, default_statement_config
 from sqlspec.adapters.aiomysql.driver import AiomysqlDriver, AiomysqlExceptionHandler
 from sqlspec.config import AsyncDatabaseConfig, ExtensionConfigs
+from sqlspec.core import TypeCoercionCapabilities
 from sqlspec.driver._async import AsyncPoolConnectionContext, AsyncPoolSessionFactory
 from sqlspec.exceptions import ImproperConfigurationError
 from sqlspec.extensions.events import EventRuntimeHints
@@ -35,7 +36,6 @@ if TYPE_CHECKING:
 __all__ = ("AiomysqlConfig", "AiomysqlConnectionParams", "AiomysqlDriverFeatures", "AiomysqlPoolParams")
 
 _POOL_ONLY_CONFIG_KEYS = frozenset({"maxsize", "minsize", "pool_recycle"})
-_AIOMYSQL_LOCAL_INFILE_GATE = "allow_local_infile"
 aiomysql: "AiomysqlModule" = cast("AiomysqlModule", AiomysqlModule)
 
 
@@ -84,28 +84,19 @@ class AiomysqlPoolParams(AiomysqlConnectionParams):
     pool_recycle: NotRequired[int]
 
 
-def _normalize_local_infile(connection_config: "Mapping[str, Any]", *, strip_consent_gate: bool) -> "dict[str, Any]":
-    """Normalize aiomysql local-infile settings and SQLSpec's consent gate."""
+def _normalize_local_infile(connection_config: "Mapping[str, Any]") -> "dict[str, Any]":
+    """Normalize aiomysql local-infile aliases to the native connection flag."""
     config = dict(connection_config)
 
     config.pop("enable_local_infile", None)
-    allow_local_infile = bool(config.get(_AIOMYSQL_LOCAL_INFILE_GATE, False))
-    local_infile = bool(config.get("local_infile", False))
-    if local_infile and not allow_local_infile:
-        msg = (
-            "Aiomysql local_infile=True requires allow_local_infile=True because "
-            "LOAD DATA LOCAL INFILE can read client files."
-        )
-        raise ImproperConfigurationError(msg)
-    config["local_infile"] = bool(local_infile and allow_local_infile)
-    if strip_consent_gate:
-        config.pop(_AIOMYSQL_LOCAL_INFILE_GATE, None)
+    allow_local_infile = bool(config.pop("allow_local_infile", False))
+    config["local_infile"] = bool(config.get("local_infile", False) or allow_local_infile)
     return config
 
 
 def _normalize_connection_kwargs(connection_config: "Mapping[str, Any]") -> "dict[str, Any]":
     """Build aiomysql.connect-compatible kwargs from SQLSpec connection config."""
-    config = _normalize_local_infile(connection_config, strip_consent_gate=True)
+    config = _normalize_local_infile(connection_config)
 
     for key in _POOL_ONLY_CONFIG_KEYS:
         config.pop(key, None)
@@ -222,6 +213,9 @@ class AiomysqlConfig(AsyncDatabaseConfig[AiomysqlConnection, "AiomysqlPool", Aio
     supports_native_arrow_import: ClassVar[bool] = True
     supports_native_parquet_import: ClassVar[bool] = True
     supports_native_row_streaming: ClassVar[bool] = True
+    type_coercion_capabilities: ClassVar[TypeCoercionCapabilities] = TypeCoercionCapabilities(
+        datetime_binding="native", timestamp_precision="microsecond", json_columns_decoded=False, uuid_binding="text"
+    )
     _connection_context_class: "ClassVar[type[AiomysqlConnectionContext]]" = AiomysqlConnectionContext
     _session_factory_class: "ClassVar[type[_AiomysqlSessionFactory]]" = _AiomysqlSessionFactory
     _session_context_class: "ClassVar[type[AiomysqlSessionContext]]" = AiomysqlSessionContext
@@ -253,9 +247,7 @@ class AiomysqlConfig(AsyncDatabaseConfig[AiomysqlConnection, "AiomysqlPool", Aio
             observability_config: Adapter-level observability overrides for lifecycle hooks and observers
             **kwargs: Additional keyword arguments
         """
-        connection_config = _normalize_local_infile(
-            normalize_connection_config(connection_config), strip_consent_gate=False
-        )
+        connection_config = _normalize_local_infile(normalize_connection_config(connection_config))
 
         connection_config.setdefault("host", "localhost")
         connection_config.setdefault("port", 3306)
@@ -271,11 +263,9 @@ class AiomysqlConfig(AsyncDatabaseConfig[AiomysqlConnection, "AiomysqlPool", Aio
         # Track initialized connections to ensure callback runs exactly once per physical connection
         self._initialized_connections: WeakSet[Any] = WeakSet()
 
+        features_dict.setdefault("enable_local_infile_bulk_load", connection_config["local_infile"])
         if features_dict.get("enable_local_infile_bulk_load") and not connection_config.get("local_infile"):
-            msg = (
-                "enable_local_infile_bulk_load requires local_infile=True and "
-                "allow_local_infile=True in connection_config."
-            )
+            msg = "enable_local_infile_bulk_load requires local_infile=True or allow_local_infile=True in connection_config."
             raise ImproperConfigurationError(msg)
 
         super().__init__(

sqlspec/adapters/aiosqlite/config.py

@@ -23,6 +23,7 @@ from sqlspec.adapters.aiosqlite.pool import (
 )
 from sqlspec.adapters.aiosqlite.type_converter import register_type_handlers
 from sqlspec.config import AsyncDatabaseConfig, ExtensionConfigs
+from sqlspec.core.capabilities import TypeCoercionCapabilities
 from sqlspec.driver._async import AsyncPoolConnectionContext, AsyncPoolSessionFactory
 from sqlspec.exceptions import ImproperConfigurationError
 from sqlspec.utils.config_tools import normalize_connection_config
@@ -251,6 +252,9 @@ class AiosqliteConfig(AsyncDatabaseConfig["AiosqliteConnection", AiosqliteConnec
     supports_native_parquet_export: "ClassVar[bool]" = True
     supports_native_parquet_import: "ClassVar[bool]" = True
     supports_native_row_streaming: "ClassVar[bool]" = True
+    type_coercion_capabilities: "ClassVar[TypeCoercionCapabilities]" = TypeCoercionCapabilities(
+        datetime_binding="iso_text", timestamp_precision="microsecond", json_columns_decoded=False, uuid_binding="text"
+    )
     _connection_context_class: "ClassVar[type[AiosqliteConnectionContext]]" = AiosqliteConnectionContext
     _session_factory_class: "ClassVar[type[_AiosqliteSessionFactory]]" = _AiosqliteSessionFactory
     _session_context_class: "ClassVar[type[AiosqliteSessionContext]]" = AiosqliteSessionContext

sqlspec/adapters/aiosqlite/core.py

@@ -68,6 +68,7 @@ _TIME_TO_ISO = time_iso_convert
 _DECIMAL_TO_STRING = build_decimal_converter(mode="string")
 
 SQLITE_CONSTRAINT_UNIQUE_CODE = 2067
+SQLITE_CONSTRAINT_PRIMARYKEY_CODE = 1555
 SQLITE_CONSTRAINT_FOREIGNKEY_CODE = 787
 SQLITE_CONSTRAINT_NOTNULL_CODE = 1811
 SQLITE_CONSTRAINT_CHECK_CODE = 531
@@ -348,6 +349,12 @@ def create_mapped_exception(error: BaseException, *, logger: Any | None = None)
         error_name = None
     error_msg = str(error).lower()
 
+    if error_code in (SQLITE_CONSTRAINT_UNIQUE_CODE, SQLITE_CONSTRAINT_PRIMARYKEY_CODE) or error_name in (
+        "SQLITE_CONSTRAINT_UNIQUE",
+        "SQLITE_CONSTRAINT_PRIMARYKEY",
+    ):
+        return _create_aiosqlite_error(error, error_code, UniqueViolationError, "unique constraint violation")
+
     # Check for busy/locked conditions first (deadlock-like scenarios in SQLite)
     # SQLITE_BUSY means another process has the database locked
     # SQLITE_LOCKED means another connection has the table/rows locked
@@ -385,8 +392,6 @@ def create_mapped_exception(error: BaseException, *, logger: Any | None = None)
             return _create_aiosqlite_error(error, None, SQLParsingError, "SQL syntax error")
         return _create_aiosqlite_error(error, None, SQLSpecError, "database error")
 
-    if error_code == SQLITE_CONSTRAINT_UNIQUE_CODE or error_name == "SQLITE_CONSTRAINT_UNIQUE":
-        return _create_aiosqlite_error(error, error_code, UniqueViolationError, "unique constraint violation")
     if error_code == SQLITE_CONSTRAINT_FOREIGNKEY_CODE or error_name == "SQLITE_CONSTRAINT_FOREIGNKEY":
         return _create_aiosqlite_error(error, error_code, ForeignKeyViolationError, "foreign key constraint violation")
     if error_code == SQLITE_CONSTRAINT_NOTNULL_CODE or error_name == "SQLITE_CONSTRAINT_NOTNULL":

sqlspec/adapters/arrow_odbc/config.py

@@ -14,6 +14,7 @@ from sqlspec.adapters.arrow_odbc.core import (
 )
 from sqlspec.adapters.arrow_odbc.driver import ArrowOdbcDriver
 from sqlspec.config import ExtensionConfigs, NoPoolSyncConfig
+from sqlspec.core.capabilities import TypeCoercionCapabilities
 from sqlspec.driver._sync import SyncPoolConnectionContext, SyncPoolSessionFactory
 from sqlspec.exceptions import ImproperConfigurationError
 from sqlspec.extensions.events import EventRuntimeHints
@@ -137,6 +138,10 @@ class ArrowOdbcConfig(NoPoolSyncConfig[ArrowOdbcConnection, ArrowOdbcDriver]):
     supports_native_row_streaming: "ClassVar[bool]" = True
     supports_native_parquet_export: "ClassVar[bool]" = False
     supports_native_parquet_import: "ClassVar[bool]" = False
+    supports_reliable_rowcount: "ClassVar[bool]" = False
+    type_coercion_capabilities: "ClassVar[TypeCoercionCapabilities]" = TypeCoercionCapabilities(
+        datetime_binding="iso_text", timestamp_precision="microsecond", json_columns_decoded=False, uuid_binding="text"
+    )
     _connection_context_class: "ClassVar[type[ArrowOdbcConnectionContext]]" = ArrowOdbcConnectionContext
     _session_factory_class: "ClassVar[type[_ArrowOdbcSessionConnectionHandler]]" = _ArrowOdbcSessionConnectionHandler
     _session_context_class: "ClassVar[type[ArrowOdbcSessionContext]]" = ArrowOdbcSessionContext