sqlspec 0.56.2__tar.gz → 0.58.0__tar.gz

{sqlspec-0.56.2 → sqlspec-0.58.0}/.pre-commit-config.yaml

@@ -1,6 +1,13 @@
 default_language_version:
   python: "3"
 repos:
+  - repo: local
+    hooks:
+      - id: no-future-annotations
+        name: Disallow future annotations in package code
+        entry: python tools/hooks/no_future_annotations.py
+        language: python
+        files: ^sqlspec/.*\.py$
   - repo: https://github.com/compilerla/conventional-pre-commit
     rev: v4.4.0
     hooks:
@@ -12,14 +19,15 @@ repos:
       - id: check-ast
       - id: check-case-conflict
       - id: check-toml
+      - id: check-yaml
       - id: debug-statements
       - id: end-of-file-fixer
       - id: mixed-line-ending
       - id: trailing-whitespace
-  - repo: https://github.com/charliermarsh/ruff-pre-commit
+  - repo: https://github.com/astral-sh/ruff-pre-commit
     rev: "v0.16.0"
     hooks:
-      - id: ruff
+      - id: ruff-check
         args: ["--fix"]
       - id: ruff-format
   - repo: https://github.com/codespell-project/codespell

{sqlspec-0.56.2 → sqlspec-0.58.0}/CONTRIBUTING.rst

@@ -5,7 +5,7 @@ Setting up the environment
 --------------------------
 
 1. Run ``make install-uv`` to install `uv <https://docs.astral.sh/uv/>`_ if not already installed
-1. Run ``make install`` to install all dependencies and pre-commit hooks
+1. Run ``make install`` to install all dependencies
 
 
 Code contributions
@@ -36,7 +36,11 @@ Guidelines for writing code
 - All code should be fully `typed <https://peps.python.org/pep-0484/>`_. This is enforced via
   `mypy <https://mypy.readthedocs.io/en/stable/>`_.
 - All code should be tested. This is enforced via `pytest <https://docs.pytest.org/en/stable/>`_.
-- All code should be properly formatted. This is enforced via `black <https://black.readthedocs.io/en/stable/>`_ and `Ruff <https://docs.astral.sh/ruff/>`_.
+- All code should be properly formatted. This is enforced via `Ruff <https://docs.astral.sh/ruff/>`_.
+- Package modules must not import ``__future__.annotations``. Prek checks this with an AST-based local hook.
+- ``make lint`` applies Ruff fixes and formatting, runs every Prek hook, checks types and slots, and audits workflows with zizmor.
+- Prek runs only through the explicit lint command; project setup does not install Git hook shims.
+- Dependency resolution uses a seven-day cooldown by default, with Litestar ecosystem packages exempt so coordinated releases remain testable.
 
 Logging
 ++++++++
@@ -63,6 +67,9 @@ Run the smallest relevant test file first, then run the repository gates:
    make test
    make coverage
 
+The repository-wide coverage floor is temporarily 76%. Every new commit must
+keep its changed code at or above 90% coverage.
+
 Mypyc and performance gates
 +++++++++++++++++++++++++++
 

{sqlspec-0.56.2 → sqlspec-0.58.0}/Makefile

@@ -44,7 +44,7 @@ install-uv:                                         ## Install latest version of
 	@echo "${OK} UV installed successfully"
 
 .PHONY: install
-install: destroy clean                              ## Install the project, dependencies, and pre-commit
+install: destroy clean                              ## Install the project and dependencies
 	@echo "${INFO} Starting fresh installation..."
 	@uv python pin 3.10 >/dev/null 2>&1
 	@uv venv >/dev/null 2>&1
@@ -66,7 +66,7 @@ install-compiled: destroy clean                  ## Install with mypyc compilati
 .PHONY: destroy
 destroy:                                            ## Destroy the virtual environment
 	@echo "${INFO} Destroying virtual environment... 🗑️"
-	@uv run pre-commit clean >/dev/null 2>&1
+	@uv run --no-sync prek cache clean >/dev/null 2>&1 || true
 	@rm -rf .venv
 	@find sqlspec \( -name '*.so' -o -name '*.c' \) -delete >/dev/null 2>&1 || true
 	@echo "${OK} Virtual environment destroyed 🗑️"
@@ -80,8 +80,8 @@ upgrade:                                            ## Upgrade all dependencies
 	@echo "${INFO} Updating all dependencies... 🔄"
 	@uv lock --upgrade
 	@echo "${OK} Dependencies updated 🔄"
-	@uv run pre-commit autoupdate
-	@echo "${OK} Updated Pre-commit hooks 🔄"
+	@uv run prek update --cooldown-days 7
+	@echo "${OK} Updated Prek hooks 🔄"
 	@uv lock >/dev/null 2>&1
 
 .PHONY: lock
@@ -192,7 +192,7 @@ coverage:                                           ## Run tests with coverage r
 		uv run pytest --cov --cov-append --cov-report= --cov-fail-under=0 -n 1 --dist=loadgroup --quiet \
 			"tests/integration/adapters/$${family}"
 	done
-	@uv run coverage report --fail-under=100 >/dev/null
+	@uv run coverage report --fail-under=76 >/dev/null
 	@uv run coverage html >/dev/null 2>&1
 	@uv run coverage xml >/dev/null 2>&1
 	@echo "${OK} Coverage report generated ✨"
@@ -229,11 +229,11 @@ type-check: mypy pyright                            ## Run all type checking
 # Linting and Formatting
 # -----------------------------------------------------------------------------
 
-.PHONY: pre-commit
-pre-commit:                                        ## Run pre-commit hooks
-	@echo "${INFO} Running pre-commit checks... 🔎"
-	@uv run pre-commit run --color=always --all-files
-	@echo "${OK} Pre-commit checks passed ✨"
+.PHONY: prek
+prek:                                              ## Run Prek hooks
+	@echo "${INFO} Running Prek checks... 🔎"
+	@uv run prek run --color=always --all-files
+	@echo "${OK} Prek checks passed ✨"
 
 .PHONY: slotscheck
 slotscheck:                                        ## Run slotscheck
@@ -245,10 +245,17 @@ slotscheck:                                        ## Run slotscheck
 fix:                                               ## Run code formatters
 	@echo "${INFO} Running code formatters... 🔧"
 	@uv run ruff check --fix --unsafe-fixes
+	@uv run ruff format
 	@echo "${OK} Code formatting complete ✨"
 
+.PHONY: zizmor
+zizmor:                                            ## Audit GitHub Actions workflows
+	@echo "${INFO} Auditing GitHub Actions workflows... 🔐"
+	@uv run --locked zizmor --strict-collection .github/workflows
+	@echo "${OK} GitHub Actions audit passed ✨"
+
 .PHONY: lint
-lint: fix pre-commit type-check slotscheck             ## Run all linting checks
+lint: fix prek type-check slotscheck zizmor         ## Run all linting checks
 	@echo "${OK} All linting checks passed ✨"
 
 .PHONY: check-all

{sqlspec-0.56.2 → sqlspec-0.58.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlspec
-Version: 0.56.2
+Version: 0.58.0
 Summary: SQL Experiments in Python
 Project-URL: Discord, https://discord.gg/litestar
 Project-URL: Issue, https://github.com/litestar-org/sqlspec/issues/

{sqlspec-0.56.2 → sqlspec-0.58.0}/pyproject.toml

@@ -24,7 +24,7 @@ maintainers = [{ name = "Litestar Developers", email = "hello@litestar.dev" }]
 name = "sqlspec"
 readme = "README.md"
 requires-python = ">=3.10, <4.0"
-version = "0.56.2"
+version = "0.58.0"
 
 [project.urls]
 Discord = "https://discord.gg/litestar"
@@ -122,10 +122,11 @@ extras = [
 ]
 lint = [
   "mypy>=2.0.0",
-  "pre-commit>=3.5.0",
+  "prek>=0.4.11",
   "pyright>=1.1.386",
-  "ruff>=0.7.1",
+  "ruff>=0.16.0",
   "slotscheck>=0.16.5",
+  "zizmor>=1.28.0",
   "types-Pygments",
   "types-colorama",
   "types-cffi",
@@ -169,6 +170,7 @@ sqlspec-dark = "tools.sphinx_ext.pygments_styles:SQLSpecDarkStyle"
 sqlspec-light = "tools.sphinx_ext.pygments_styles:SQLSpecLightStyle"
 
 [tool.uv]
+exclude-newer = "7 days"
 # mysql-connector-python 9.7.0 dropped cp312/cp313/cp314 wheels (regression vs 9.6.0).
 # Override dependency metadata for every source that requests mysql-connector-python.
 # Keep the uncapped dependency on Python <3.12, and force the cap on Python >=3.12
@@ -178,6 +180,26 @@ override-dependencies = [
   "mysql-connector-python<9.7.0; python_version >= '3.12'",
 ]
 
+[tool.uv.exclude-newer-package]
+advanced-alchemy = false
+litestar = false
+litestar-asyncapi = false
+litestar-asyncpg = false
+litestar-autowire = false
+litestar-email = false
+litestar-granian = false
+litestar-htmx = false
+litestar-mcp = false
+litestar-oracledb = false
+litestar-queues = false
+litestar-saq = false
+litestar-security = false
+litestar-vite = false
+polyfactory = false
+pytest-databases = false
+sqlglot = false
+sqlglotc = false
+
 [build-system]
 build-backend = "hatchling.build"
 requires = ["hatchling", "hatch-mypyc"]
@@ -224,7 +246,7 @@ exclude = [
   "sqlspec/core/_pagination.py",            # @dataclass mutates class at def time; annotations must survive mypyc for Litestar OpenAPI (#419)
 ]
 include = [
-  "sqlspec/base.py",                            # SQLSpec registry/session manager
+  "sqlspec/base.py",                               # SQLSpec registry/session manager
   "sqlspec/core/**/*.py",                          # Core module
   "sqlspec/builder/**/*.py",                       # Builder module
   "sqlspec/exceptions.py",                         # Exceptions module
@@ -240,12 +262,13 @@ include = [
   "sqlspec/storage/registry.py",                   # Safe storage registry/runtime routing
   "sqlspec/storage/errors.py",                     # Safe storage error normalization
   "sqlspec/storage/_paths.py",                     # Pure storage path handling
+  "sqlspec/storage/_arrow_stream.py",              # Pure Parquet streaming validation and row-group iteration
   "sqlspec/storage/pipeline.py",                   # Storage bridge orchestration with Arrow boundary split out
   "sqlspec/storage/backends/base.py",              # Storage backend runtime base classes
   "sqlspec/storage/backends/fsspec.py",            # fsspec backend import surface
   "sqlspec/storage/backends/local.py",             # Local storage backend
   "sqlspec/storage/backends/obstore.py",           # obstore backend import surface
-  "sqlspec/storage/_utils.py",                      # Storage optional dependency import helpers
+  "sqlspec/storage/_utils.py",                     # Storage optional dependency import helpers
   "sqlspec/service.py",                            # Service base classes
   "sqlspec/data_dictionary/**/*.py",               # Data dictionary registry, loader, and dialect helpers
   "sqlspec/extensions/prometheus/_observer.py",    # Prometheus statement observer
@@ -308,7 +331,7 @@ opt_level = "3"   # Maximum optimization (0-3)
 allow_dirty = true
 commit = false
 commit_args = "--no-verify"
-current_version = "0.56.2"
+current_version = "0.58.0"
 ignore_missing_files = false
 ignore_missing_version = false
 message = "chore(release): bump to v{new_version}"
@@ -550,7 +573,9 @@ preview = true
 skip-magic-trailing-comma = true
 
 [tool.ruff.lint]
+explicit-preview-rules = true
 extend-safe-fixes = ["TC"]
+extend-select = ["ASYNC119", "DOC402"]
 fixable = ["ALL"]
 ignore = [
   "A003",    # flake8-builtins - class attribute {name} is shadowing a python builtin
@@ -611,6 +636,7 @@ ignore = [
   "RUF067",  # ruff - init should only have import statements
   "PLW0717", # too many statements in try block
 ]
+preview = true
 select = ["ALL"]
 
 [tool.ruff.lint.pydocstyle]

{sqlspec-0.56.2 → sqlspec-0.58.0}/sqlspec/adapters/adbc/core.py

@@ -3,7 +3,7 @@
 import datetime
 import decimal
 from collections.abc import Sized
-from functools import lru_cache
+from functools import lru_cache, partial
 from typing import TYPE_CHECKING, Any, Final, cast
 from uuid import UUID
 
@@ -464,19 +464,51 @@ def is_postgres_dialect(dialect_name: str) -> bool:
 
 
 def handle_postgres_rollback(dialect: str, cursor: Any, logger: Any | None = None) -> None:
-    """Execute rollback for PostgreSQL after transaction failure.
+    """Clear an aborted PostgreSQL transaction after a statement failure.
+
+    The connection-level rollback is preferred because the driver refuses to
+    start a transaction on an errored connection, which a cursor needs in order
+    to issue a ``ROLLBACK`` statement.
 
     Args:
         dialect: Active dialect identifier.
-        cursor: Database cursor to execute rollback.
+        cursor: Database cursor whose connection should be rolled back.
         logger: Optional logger for diagnostics.
     """
     if not is_postgres_dialect(dialect):
         return
+
+    connection = getattr(cursor, "connection", None)
+    if connection is not None and _try_rollback(connection.rollback):
+        _log_rollback(logger)
+        return
+
+    if _try_rollback(partial(cursor.execute, "ROLLBACK")):
+        _log_rollback(logger)
+
+
+def _try_rollback(rollback: "Callable[[], Any]") -> bool:
+    """Run a rollback callable and report whether it succeeded.
+
+    Args:
+        rollback: Zero-argument callable performing the rollback.
+
+    Returns:
+        True if the rollback completed without raising.
+    """
     try:
-        cursor.execute("ROLLBACK")
+        rollback()
     except Exception:
-        return
+        return False
+    return True
+
+
+def _log_rollback(logger: "Any | None") -> None:
+    """Record that a PostgreSQL rollback completed.
+
+    Args:
+        logger: Optional logger for diagnostics.
+    """
     if logger is not None:
         logger.debug("PostgreSQL rollback executed after transaction failure")
 

{sqlspec-0.56.2 → sqlspec-0.58.0}/sqlspec/adapters/asyncpg/driver.py

@@ -2,9 +2,13 @@
 
 import re
 from collections import OrderedDict
+from collections.abc import Mapping
 from io import BytesIO
 from typing import TYPE_CHECKING, Any, Final, cast
 
+from sqlglot import exp, parse_one
+from sqlglot.errors import ParseError
+
 from sqlspec.adapters.asyncpg._typing import AsyncpgCursor, AsyncpgPostgresError, AsyncpgSessionContext
 from sqlspec.adapters.asyncpg.core import (
     PREPARED_STATEMENT_CACHE_SIZE,
@@ -36,7 +40,7 @@ from sqlspec.driver import (
     StackExecutionObserver,
     describe_stack_statement,
 )
-from sqlspec.exceptions import SQLSpecError, StackExecutionError
+from sqlspec.exceptions import ImproperConfigurationError, SQLSpecError, StackExecutionError
 from sqlspec.utils.logging import get_logger
 from sqlspec.utils.text import normalize_identifier, quote_identifier
 from sqlspec.utils.type_guards import has_sqlstate
@@ -333,20 +337,85 @@ class AsyncpgDriver(AsyncDriverAdapterBase):
         """Load Arrow data into a PostgreSQL table via COPY."""
         self._require_capability("arrow_import_enabled")
         arrow_table = self._coerce_arrow_table(source)
+        table_name, schema_name, quoted_target = self._copy_target(table)
         if overwrite:
             try:
-                await self.connection.execute(f"TRUNCATE TABLE {table}")
+                await self.connection.execute(f"TRUNCATE TABLE {quoted_target}")
             except AsyncpgPostgresError as exc:
                 msg = f"Failed to truncate table '{table}': {exc}"
                 raise SQLSpecError(msg) from exc
         columns, records = self._arrow_table_to_rows(arrow_table)
         if records:
-            await self.connection.copy_records_to_table(table, records=records, columns=columns)
+            await self.connection.copy_records_to_table(
+                table_name, records=records, columns=columns, schema_name=schema_name
+            )
         telemetry_payload = self._ingest_telemetry(arrow_table)
         telemetry_payload["destination"] = table
         self._attach_partition_telemetry(telemetry_payload, partitioner)
         return self._storage_job(telemetry_payload, telemetry)
 
+    async def load_from_records(
+        self,
+        table: str,
+        records: "Sequence[Mapping[str, Any]] | Sequence[Sequence[Any]]",
+        *,
+        columns: "list[str] | None" = None,
+        overwrite: bool = False,
+    ) -> "StorageBridgeJob":
+        """Load mapping or positional records directly with binary COPY."""
+        self._require_capability("arrow_import_enabled")
+        materialized = list(records)
+        if not materialized:
+            msg = "load_from_records requires at least one record."
+            raise ImproperConfigurationError(msg)
+
+        first = materialized[0]
+        if isinstance(first, Mapping):
+            resolved_columns = columns if columns is not None else list(first.keys())
+            expected_keys = set(resolved_columns)
+            copy_rows: list[tuple[Any, ...]] = []
+            for record in materialized:
+                if not isinstance(record, Mapping):
+                    msg = "load_from_records mapping records must all be mappings."
+                    raise ImproperConfigurationError(msg)
+                if set(record.keys()) != expected_keys:
+                    msg = "load_from_records mapping records must all share the same keys."
+                    raise ImproperConfigurationError(msg)
+                copy_rows.append(tuple(record[column] for column in resolved_columns))
+        else:
+            if columns is None:
+                msg = "load_from_records requires columns when records are positional sequences."
+                raise ImproperConfigurationError(msg)
+            resolved_columns = columns
+            copy_rows = []
+            for record in materialized:
+                if isinstance(record, Mapping):
+                    msg = "load_from_records positional records must all have the same shape."
+                    raise ImproperConfigurationError(msg)
+                row = tuple(record)
+                if len(row) != len(resolved_columns):
+                    msg = "load_from_records positional records must match the number of columns."
+                    raise ImproperConfigurationError(msg)
+                copy_rows.append(row)
+
+        table_name, schema_name, quoted_target = self._copy_target(table)
+        if overwrite:
+            try:
+                await self.connection.execute(f"TRUNCATE TABLE {quoted_target}")
+            except AsyncpgPostgresError as exc:
+                msg = f"Failed to truncate table '{table}': {exc}"
+                raise SQLSpecError(msg) from exc
+        await self.connection.copy_records_to_table(
+            table_name, records=copy_rows, columns=resolved_columns, schema_name=schema_name
+        )
+        telemetry_payload: StorageTelemetry = {
+            "bytes_processed": 0,
+            "destination": table,
+            "format": "records",
+            "rows_processed": len(copy_rows),
+        }
+        return self._storage_job(telemetry_payload)
+
     async def load_from_storage(
         self,
         table: str,
@@ -391,6 +460,43 @@ class AsyncpgDriver(AsyncDriverAdapterBase):
         """Resolve rowcount from asyncpg status for the direct execution path."""
         return parse_status(cursor)
 
+    @staticmethod
+    def _copy_target(table: str) -> "tuple[str, str | None, str]":
+        try:
+            parsed = parse_one(table, read="postgres", into=exp.Table)
+        except ParseError as exc:
+            msg = "AsyncPG COPY targets must be unqualified or schema-qualified table names."
+            raise ImproperConfigurationError(msg) from exc
+        schema_expression = parsed.args.get("db")
+        schema_identifier = schema_expression if isinstance(schema_expression, exp.Identifier) else None
+        if (
+            parsed.catalog
+            or not isinstance(parsed.this, exp.Identifier)
+            or not parsed.this.name
+            or parsed.this.name == "*"
+            or (schema_expression is not None and schema_identifier is None)
+            or (schema_identifier is not None and not schema_identifier.name)
+        ):
+            msg = "AsyncPG COPY targets must be unqualified or schema-qualified table names."
+            raise ImproperConfigurationError(msg)
+        table_identifier = parsed.this
+        table_name = (
+            table_identifier.name
+            if table_identifier.quoted
+            else normalize_identifier(table_identifier.name, "postgres")
+        )
+        schema_name = None
+        if schema_identifier is not None:
+            schema_name = (
+                schema_identifier.name
+                if schema_identifier.quoted
+                else normalize_identifier(schema_identifier.name, "postgres")
+            )
+        quoted_target = quote_identifier(table_name)
+        if schema_name is not None:
+            quoted_target = f"{quote_identifier(schema_name)}.{quoted_target}"
+        return table_name, schema_name, quoted_target
+
     async def _execute_stack_native(
         self, stack: "StatementStack", *, continue_on_error: bool
     ) -> "tuple[StackResult, ...]":

{sqlspec-0.56.2 → sqlspec-0.58.0}/sqlspec/adapters/oracledb/driver.py

@@ -80,7 +80,7 @@ if TYPE_CHECKING:
     from collections.abc import Sequence
 
     from sqlspec.builder import QueryBuilder
-    from sqlspec.core import ArrowResult, Statement, StatementConfig, StatementFilter
+    from sqlspec.core import ArrowResult, Statement, StatementFilter
     from sqlspec.core.stack import StackOperation
     from sqlspec.driver import ExecutionResult
     from sqlspec.storage import StorageBridgeJob, StorageDestination, StorageFormat, StorageTelemetry

{sqlspec-0.56.2 → sqlspec-0.58.0}/sqlspec/adapters/psqlpy/core.py

@@ -55,8 +55,6 @@ from sqlspec.utils.uuids import uuid_from_string
 if TYPE_CHECKING:
     from collections.abc import Callable, Mapping
 
-    from sqlspec.core import ParameterStyleConfig, StatementConfig
-
 __all__ = (
     "PsqlpyStreamSource",
     "apply_driver_features",

{sqlspec-0.56.2 → sqlspec-0.58.0}/sqlspec/adapters/psycopg/_typing.py

@@ -105,6 +105,14 @@ class PsycopgPipelineDriver(Protocol):
         kwargs: "dict[str, Any] | None" = None,
     ) -> "SQL": ...
 
+    def prepare_driver_parameters(
+        self,
+        parameters: Any,
+        statement_config: "StatementConfig",
+        is_many: bool = False,
+        prepared_statement: Any | None = None,
+    ) -> Any: ...
+
     def _compiled_sql(self, statement: "SQL", statement_config: "StatementConfig") -> "tuple[str, Any]": ...
 
 

{sqlspec-0.56.2 → sqlspec-0.58.0}/sqlspec/adapters/psycopg/driver.py

@@ -65,6 +65,8 @@ from sqlspec.utils.text import normalize_identifier, quote_identifier
 from sqlspec.utils.type_guards import is_readable, resolve_row_format
 
 if TYPE_CHECKING:
+    from collections import abc
+
     from sqlspec.adapters.psycopg._typing import PsycopgPipelineDriver
     from sqlspec.core import ArrowResult
     from sqlspec.driver import ExecutionResult
@@ -107,6 +109,15 @@ class PsycopgPipelineMixin:
 
     __slots__ = ()
 
+    def _prepare_records_for_arrow(
+        self, records: "abc.Sequence[abc.Mapping[str, Any]] | abc.Sequence[abc.Sequence[Any]]"
+    ) -> "abc.Sequence[abc.Mapping[str, Any]] | abc.Sequence[abc.Sequence[Any]]":
+        driver = cast("PsycopgPipelineDriver", self)
+        return cast(
+            "abc.Sequence[abc.Mapping[str, Any]] | abc.Sequence[abc.Sequence[Any]]",
+            driver.prepare_driver_parameters(records, driver.statement_config, is_many=True),
+        )
+
     def _prepare_pipeline_operations(self, stack: "StatementStack") -> "list[PreparedStackOperation] | None":
         prepared: list[PreparedStackOperation] = []
         for index, operation in enumerate(stack.operations):
@@ -485,6 +496,12 @@ class PsycopgSyncDriver(PsycopgPipelineMixin, SyncDriverAdapterBase):
             if exc_handler.pending_exception is not None:
                 raise exc_handler.pending_exception from None
         columns, records = self._arrow_table_to_rows(arrow_table)
+        prepared_records = cast(
+            "list[Any]",
+            self.prepare_driver_parameters(records, self.statement_config, is_many=True)
+            if records and self._arrow_rows_need_preparation(arrow_table)
+            else records,
+        )
         if records:
             copy_sql = build_copy_from_command(table, columns)
             exc_handler = self.handle_database_exceptions()
@@ -492,7 +509,7 @@ class PsycopgSyncDriver(PsycopgPipelineMixin, SyncDriverAdapterBase):
                 stack.enter_context(exc_handler)
                 cursor = stack.enter_context(self.with_cursor(self.connection))
                 copy_ctx = stack.enter_context(cursor.copy(copy_sql))
-                for record in records:
+                for record in prepared_records:
                     copy_ctx.write_row(record)
             if exc_handler.pending_exception is not None:
                 raise exc_handler.pending_exception from None
@@ -1010,6 +1027,12 @@ class PsycopgAsyncDriver(PsycopgPipelineMixin, AsyncDriverAdapterBase):
             if exc_handler.pending_exception is not None:
                 raise exc_handler.pending_exception from None
         columns, records = self._arrow_table_to_rows(arrow_table)
+        prepared_records = cast(
+            "list[Any]",
+            self.prepare_driver_parameters(records, self.statement_config, is_many=True)
+            if records and self._arrow_rows_need_preparation(arrow_table)
+            else records,
+        )
         if records:
             copy_sql = build_copy_from_command(table, columns)
             exc_handler = self.handle_database_exceptions()
@@ -1017,7 +1040,7 @@ class PsycopgAsyncDriver(PsycopgPipelineMixin, AsyncDriverAdapterBase):
                 await stack.enter_async_context(exc_handler)
                 cursor = await stack.enter_async_context(self.with_cursor(self.connection))
                 copy_ctx = await stack.enter_async_context(cursor.copy(copy_sql))
-                for record in records:
+                for record in prepared_records:
                     await copy_ctx.write_row(record)
             if exc_handler.pending_exception is not None:
                 raise exc_handler.pending_exception from None

{sqlspec-0.56.2 → sqlspec-0.58.0}/sqlspec/adapters/pymssql/pool.py

@@ -141,7 +141,11 @@ class PymssqlConnectionPool:
 
     @contextmanager
     def get_connection(self) -> "Generator[PymssqlConnection, None, None]":
-        """Get a thread-local connection."""
+        """Get a thread-local connection.
+
+        Yields:
+            A thread-local database connection.
+        """
         connection = self._get_thread_connection()
         try:
             yield connection

{sqlspec-0.56.2 → sqlspec-0.58.0}/sqlspec/adapters/pymysql/pool.py

@@ -143,7 +143,11 @@ class PyMysqlConnectionPool:
 
     @contextmanager
     def get_connection(self) -> "Generator[PyMysqlConnection, None, None]":
-        """Get a thread-local connection."""
+        """Get a thread-local connection.
+
+        Yields:
+            A thread-local database connection.
+        """
         connection = self._get_thread_connection()
         try:
             yield connection

{sqlspec-0.56.2 → sqlspec-0.58.0}/sqlspec/builder/_base.py

@@ -4,7 +4,7 @@ Provides abstract base classes and core functionality for SQL query builders.
 """
 
 import re
-from abc import ABC, abstractmethod
+from abc import abstractmethod
 from collections.abc import Callable, Iterable, Mapping
 from typing import Any, NoReturn, cast
 
@@ -115,7 +115,7 @@ class BuiltQuery:
         return hash((self.sql, frozenset(self.parameters.items()), self.dialect))
 
 
-class QueryBuilder(ABC):
+class QueryBuilder:
     """Abstract base class for SQL query builders.
 
     Provides common functionality for dialect handling, parameter management,

{sqlspec-0.56.2 → sqlspec-0.58.0}/sqlspec/cli.py

@@ -7,11 +7,12 @@ from typing import TYPE_CHECKING, Any, TypeAlias, cast
 import rich_click as click
 from click.core import ParameterSource
 from rich import get_console
+from rich.markup import escape
 from rich.prompt import Confirm, Prompt
 from rich.table import Table
 
 from sqlspec.config import AsyncDatabaseConfig, SyncDatabaseConfig
-from sqlspec.exceptions import ConfigResolverError
+from sqlspec.exceptions import SQLSpecError
 from sqlspec.utils.config_tools import discover_config_from_pyproject, resolve_config_sync
 from sqlspec.utils.module_loader import import_string
 from sqlspec.utils.sync_tools import run_
@@ -67,7 +68,7 @@ def get_sqlspec_group() -> "Group":
             console.print("\nSpecify config using one of:")
             console.print("  1. CLI flag:        sqlspec --config myapp.config:get_configs <command>")
             console.print("  2. Environment var: export SQLSPEC_CONFIG=myapp.config:get_configs")
-            console.print("  3. pyproject.toml:  [tool.sqlspec]")
+            console.print(f"  3. pyproject.toml:  {escape('[tool.sqlspec]')}")
             console.print('                      config = "myapp.config:get_configs"')
             ctx.exit(1)
 
@@ -111,8 +112,8 @@ def get_sqlspec_group() -> "Group":
                     execution_hint = "[dim cyan](async-capable)[/]" if is_async else "[dim](sync)[/]"
                     console.print(f"  [dim]•[/] {config_name}: {config_type} {execution_hint}")
 
-        except (ImportError, ConfigResolverError) as e:
-            console.print(f"[red]Error loading config: {e}[/]")
+        except (ImportError, SQLSpecError) as e:
+            console.print(f"[red]Error loading config: {escape(str(e))}[/]", emoji=False)
             ctx.exit(1)
         finally:
             if cwd_added and cwd in sys.path and sys.path[0] == cwd: