sqlspec 0.35.0__tar.gz → 0.36.0__tar.gz

{sqlspec-0.35.0 → sqlspec-0.36.0}/.gitignore

@@ -31,6 +31,7 @@ target/
 .python-version
 .ruff_cache
 /docs/_build/
+docs/autoapi/
 coverage.*
 setup.py
 tmp/
@@ -54,6 +55,6 @@ AGENTS.md
 docs-build
 .envs/
 .claude/*
-specs/
-.pre-commit-cache
 .gh-cache
+.gemini/
+specs/

{sqlspec-0.35.0 → sqlspec-0.36.0}/Makefile

@@ -250,12 +250,12 @@ docs-clean:                                        ## Clean documentation build
 .PHONY: docs-serve
 docs-serve: docs-clean                             ## Serve documentation locally
 	@echo "${INFO} Starting documentation server... 📚"
-	@uv run sphinx-autobuild docs docs/_build/ -j auto --watch sqlspec --watch docs --watch tests --watch CONTRIBUTING.rst --port 8002
+	@uv run sphinx-autobuild docs docs/_build/ -j 1 --watch sqlspec --watch docs --watch tests --watch CONTRIBUTING.rst --port 8002
 
 .PHONY: docs
 docs: docs-clean                                   ## Build documentation
 	@echo "${INFO} Building documentation... 📝"
-	@uv run sphinx-build -M html docs docs/_build/ -E -a -j auto -W --keep-going
+	@PYTHONWARNINGS="ignore::FutureWarning" uv run sphinx-build -M html docs docs/_build/ -E -a -j 1 -W --keep-going
 	@echo "${OK} Documentation built successfully"
 
 .PHONY: docs-linkcheck

{sqlspec-0.35.0 → sqlspec-0.36.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlspec
-Version: 0.35.0
+Version: 0.36.0
 Summary: SQL Experiments in Python
 Project-URL: Discord, https://discord.gg/litestar
 Project-URL: Issue, https://github.com/litestar-org/sqlspec/issues/
@@ -13,6 +13,7 @@ Requires-Python: <4.0,>=3.10
 Requires-Dist: mypy-extensions
 Requires-Dist: rich-click>=1.9.0
 Requires-Dist: sqlglot>=19.9.0
+Requires-Dist: tomli>=2.0.0; python_version < '3.11'
 Requires-Dist: typing-extensions
 Provides-Extra: adbc
 Requires-Dist: adbc-driver-manager; extra == 'adbc'
@@ -35,9 +36,6 @@ Requires-Dist: cattrs; extra == 'attrs'
 Provides-Extra: bigquery
 Requires-Dist: google-cloud-bigquery; extra == 'bigquery'
 Requires-Dist: google-cloud-storage; extra == 'bigquery'
-Provides-Extra: cli
-Requires-Dist: rich-click>=1.9.0; extra == 'cli'
-Requires-Dist: tomli>=2.0.0; (python_version < '3.11') and extra == 'cli'
 Provides-Extra: cloud-sql
 Requires-Dist: cloud-sql-python-connector; extra == 'cloud-sql'
 Provides-Extra: cockroachdb

{sqlspec-0.35.0 → sqlspec-0.36.0}/pyproject.toml

@@ -1,13 +1,19 @@
 [project]
 authors = [{ name = "Cody Fincher", email = "cody@litestar.dev" }]
-dependencies = ["typing-extensions", "sqlglot>=19.9.0", "mypy-extensions", "rich-click>=1.9.0"]
+dependencies = [
+  "typing-extensions",
+  "sqlglot>=19.9.0",
+  "mypy-extensions",
+  "rich-click>=1.9.0",
+  "tomli>=2.0.0; python_version < '3.11'",
+]
 description = "SQL Experiments in Python"
 license = "MIT"
 maintainers = [{ name = "Litestar Developers", email = "hello@litestar.dev" }]
 name = "sqlspec"
 readme = "README.md"
 requires-python = ">=3.10, <4.0"
-version = "0.35.0"
+version = "0.36.0"
 
 [project.urls]
 Discord = "https://discord.gg/litestar"
@@ -24,7 +30,6 @@ asyncmy = ["asyncmy"]
 asyncpg = ["asyncpg"]
 attrs = ["attrs", "cattrs"]
 bigquery = ["google-cloud-bigquery", "google-cloud-storage"]
-cli = ["rich-click>=1.9.0", "tomli>=2.0.0; python_version < '3.11'"]
 cloud-sql = ["cloud-sql-python-connector"]
 cockroachdb = ["psycopg[binary,pool]", "asyncpg"]
 duckdb = ["duckdb"]
@@ -70,18 +75,22 @@ doc = [
   "sphinx-autobuild>=2021.3.14",
   "sphinx-copybutton>=0.5.2",
   "sphinx-click>=6.0.0",
+  "click-extra[sphinx]",
   "sphinx-design>=0.5.0",
+  "sphinx-tabs",
+  "sphinx-datatables",
+  "sphinxcontrib-jquery",
   "sphinxcontrib-mermaid>=0.9.2",
   "sphinx-paramlinks>=0.6.0",
   "sphinx-togglebutton>=0.3.2",
   "sphinx-toolbox>=3.8.1",
   "myst-parser",
   "sphinx-autodoc-typehints",
-  "sphinx-contributors",
   "numpydoc",
-  "sphinx-autoapi",
   "sphinx-iconify",
   "sphinx-docsearch",
+  "jupyter-sphinx",
+  "nbsphinx",
 ]
 extras = [
   "adbc_driver_manager",
@@ -213,7 +222,7 @@ opt_level = "3"   # Maximum optimization (0-3)
 allow_dirty = true
 commit = false
 commit_args = "--no-verify"
-current_version = "0.35.0"
+current_version = "0.36.0"
 ignore_missing_files = false
 ignore_missing_version = false
 message = "chore(release): bump to v{new_version}"
@@ -344,7 +353,7 @@ markers = [
   "psqlpy: marks tests using psqlpy",
 ]
 python_files = ["test_*.py", "quickstart_*.py", "usage_*.py"]
-testpaths = ["tests", "docs/examples/quickstart", "docs/examples/usage"]
+testpaths = ["tests", "docs/examples"]
 timeout = 300
 timeout_method = "thread"
 

{sqlspec-0.35.0 → sqlspec-0.36.0}/sqlspec/adapters/adbc/core.py

@@ -40,6 +40,7 @@ __all__ = (
     "build_connection_config",
     "build_profile",
     "collect_rows",
+    "create_mapped_exception",
     "detect_dialect",
     "driver_from_uri",
     "driver_kind_from_driver_name",
@@ -53,7 +54,6 @@ __all__ = (
     "normalize_script_rowcount",
     "prepare_parameters_with_casts",
     "prepare_postgres_parameters",
-    "raise_exception",
     "resolve_dialect_from_config",
     "resolve_dialect_from_driver_path",
     "resolve_dialect_name",
@@ -409,56 +409,67 @@ def prepare_postgres_parameters(
     )
 
 
-def _raise_adbc_error(error: Any, error_class: type[SQLSpecError], description: str) -> None:
+def _create_adbc_error(error: Any, error_class: type[SQLSpecError], description: str) -> SQLSpecError:
+    """Create an ADBC error instance without raising it."""
     msg = f"ADBC {description}: {error}"
-    raise error_class(msg) from error
+    exc = error_class(msg)
+    exc.__cause__ = error
+    return exc
 
 
-def raise_exception(error: Any) -> None:
-    """Raise SQLSpec exceptions for ADBC errors."""
+def create_mapped_exception(error: Any) -> SQLSpecError:
+    """Map ADBC errors to SQLSpec exceptions.
+
+    This is a factory function that returns an exception instance rather than
+    raising. This pattern is more robust for use in __exit__ handlers and
+    avoids issues with exception control flow in different Python versions.
+
+    Args:
+        error: The ADBC exception to map
+
+    Returns:
+        A SQLSpec exception that wraps the original error
+    """
     sqlstate = error.sqlstate if has_sqlstate(error) and error.sqlstate is not None else None
 
     if sqlstate:
         if sqlstate == "23505":
-            _raise_adbc_error(error, UniqueViolationError, "unique constraint violation")
-        elif sqlstate == "23503":
-            _raise_adbc_error(error, ForeignKeyViolationError, "foreign key constraint violation")
-        elif sqlstate == "23502":
-            _raise_adbc_error(error, NotNullViolationError, "not-null constraint violation")
-        elif sqlstate == "23514":
-            _raise_adbc_error(error, CheckViolationError, "check constraint violation")
-        elif sqlstate.startswith("23"):
-            _raise_adbc_error(error, IntegrityError, "integrity constraint violation")
-        elif sqlstate.startswith("42"):
-            _raise_adbc_error(error, SQLParsingError, "SQL parsing error")
-        elif sqlstate.startswith("08"):
-            _raise_adbc_error(error, DatabaseConnectionError, "connection error")
-        elif sqlstate.startswith("40"):
-            _raise_adbc_error(error, TransactionError, "transaction error")
-        elif sqlstate.startswith("22"):
-            _raise_adbc_error(error, DataError, "data error")
-        else:
-            _raise_adbc_error(error, SQLSpecError, "database error")
-        return
+            return _create_adbc_error(error, UniqueViolationError, "unique constraint violation")
+        if sqlstate == "23503":
+            return _create_adbc_error(error, ForeignKeyViolationError, "foreign key constraint violation")
+        if sqlstate == "23502":
+            return _create_adbc_error(error, NotNullViolationError, "not-null constraint violation")
+        if sqlstate == "23514":
+            return _create_adbc_error(error, CheckViolationError, "check constraint violation")
+        if sqlstate.startswith("23"):
+            return _create_adbc_error(error, IntegrityError, "integrity constraint violation")
+        if sqlstate.startswith("42"):
+            return _create_adbc_error(error, SQLParsingError, "SQL parsing error")
+        if sqlstate.startswith("08"):
+            return _create_adbc_error(error, DatabaseConnectionError, "connection error")
+        if sqlstate.startswith("40"):
+            return _create_adbc_error(error, TransactionError, "transaction error")
+        if sqlstate.startswith("22"):
+            return _create_adbc_error(error, DataError, "data error")
+        return _create_adbc_error(error, SQLSpecError, "database error")
 
     error_msg = str(error).lower()
 
     if "unique" in error_msg or "duplicate" in error_msg:
-        _raise_adbc_error(error, UniqueViolationError, "unique constraint violation")
-    elif "foreign key" in error_msg:
-        _raise_adbc_error(error, ForeignKeyViolationError, "foreign key constraint violation")
-    elif "not null" in error_msg or "null value" in error_msg:
-        _raise_adbc_error(error, NotNullViolationError, "not-null constraint violation")
-    elif "check constraint" in error_msg:
-        _raise_adbc_error(error, CheckViolationError, "check constraint violation")
-    elif "constraint" in error_msg:
-        _raise_adbc_error(error, IntegrityError, "integrity constraint violation")
-    elif "syntax" in error_msg:
-        _raise_adbc_error(error, SQLParsingError, "SQL parsing error")
-    elif "connection" in error_msg or "connect" in error_msg:
-        _raise_adbc_error(error, DatabaseConnectionError, "connection error")
-    else:
-        _raise_adbc_error(error, SQLSpecError, "database error")
+        return _create_adbc_error(error, UniqueViolationError, "unique constraint violation")
+    if "foreign key" in error_msg:
+        return _create_adbc_error(error, ForeignKeyViolationError, "foreign key constraint violation")
+    if "not null" in error_msg or "null value" in error_msg:
+        return _create_adbc_error(error, NotNullViolationError, "not-null constraint violation")
+    if "check constraint" in error_msg:
+        return _create_adbc_error(error, CheckViolationError, "check constraint violation")
+    if "constraint" in error_msg:
+        return _create_adbc_error(error, IntegrityError, "integrity constraint violation")
+    if "syntax" in error_msg:
+        return _create_adbc_error(error, SQLParsingError, "SQL parsing error")
+    if "connection" in error_msg or "connect" in error_msg:
+        return _create_adbc_error(error, DatabaseConnectionError, "connection error")
+    return _create_adbc_error(error, SQLSpecError, "database error")
 
 
 def _identity(value: Any) -> Any:

{sqlspec-0.35.0 → sqlspec-0.36.0}/sqlspec/adapters/adbc/driver.py

@@ -10,6 +10,7 @@ from typing import TYPE_CHECKING, Any, Literal, cast
 from sqlspec.adapters.adbc._typing import AdbcSessionContext
 from sqlspec.adapters.adbc.core import (
     collect_rows,
+    create_mapped_exception,
     detect_dialect,
     driver_profile,
     get_statement_config,
@@ -18,7 +19,6 @@ from sqlspec.adapters.adbc.core import (
     normalize_postgres_empty_parameters,
     normalize_script_rowcount,
     prepare_postgres_parameters,
-    raise_exception,
     resolve_dialect_name,
     resolve_parameter_casts,
     resolve_rowcount,
@@ -90,12 +90,8 @@ class AdbcExceptionHandler:
         _ = exc_tb
         if exc_type is None:
             return False
-        try:
-            raise_exception(exc_val)
-        except Exception as mapped:
-            self.pending_exception = mapped
-            return True
-        return False
+        self.pending_exception = create_mapped_exception(exc_val)
+        return True
 
 
 class AdbcDriver(SyncDriverAdapterBase):

{sqlspec-0.35.0 → sqlspec-0.36.0}/sqlspec/adapters/aiosqlite/core.py

@@ -31,12 +31,12 @@ __all__ = (
     "build_profile",
     "build_statement_config",
     "collect_rows",
+    "create_mapped_exception",
     "default_statement_config",
     "driver_profile",
     "format_identifier",
     "normalize_execute_many_parameters",
     "normalize_execute_parameters",
-    "raise_exception",
     "resolve_rowcount",
 )
 
@@ -172,63 +172,86 @@ def build_connection_config(connection_config: "Mapping[str, Any]") -> "dict[str
     return {key: value for key, value in connection_config.items() if key not in excluded_keys}
 
 
-def _raise_aiosqlite_error(error: Any, code: "int | None", error_class: type[SQLSpecError], description: str) -> None:
+def _create_aiosqlite_error(
+    error: Any, code: "int | None", error_class: type[SQLSpecError], description: str
+) -> SQLSpecError:
+    """Create a SQLSpec exception from an aiosqlite error.
+
+    Args:
+        error: The original aiosqlite exception
+        code: SQLite extended error code
+        error_class: The SQLSpec exception class to instantiate
+        description: Human-readable description of the error type
+
+    Returns:
+        A new SQLSpec exception instance with the original as its cause
+    """
     code_str = f"[code {code}]" if code else ""
     msg = f"AIOSQLite {description} {code_str}: {error}" if code_str else f"AIOSQLite {description}: {error}"
-    raise error_class(msg) from cast("BaseException", error)
+    exc = error_class(msg)
+    exc.__cause__ = cast("BaseException", error)
+    return exc
+
 
+def create_mapped_exception(error: BaseException) -> SQLSpecError:
+    """Map aiosqlite exceptions to SQLSpec exceptions.
 
-def raise_exception(error: BaseException) -> None:
-    """Raise SQLSpec exceptions for aiosqlite errors."""
+    This is a factory function that returns an exception instance rather than
+    raising. This pattern is more robust for use in __aexit__ handlers and
+    avoids issues with exception control flow in different Python versions.
+
+    Args:
+        error: The aiosqlite exception to map
+
+    Returns:
+        A SQLSpec exception that wraps the original error
+    """
     if has_sqlite_error(error):
         error_code = error.sqlite_errorcode
         error_name = error.sqlite_errorname
-        error_exc = cast("BaseException", error)
     else:
         error_code = None
         error_name = None
-        error_exc = error
     error_msg = str(error).lower()
 
     if "locked" in error_msg:
         msg = f"AIOSQLite database locked: {error}. Consider enabling WAL mode or reducing concurrency."
-        raise SQLSpecError(msg) from error_exc
+        exc = SQLSpecError(msg)
+        exc.__cause__ = error  # pyright: ignore[reportAttributeAccessIssue]
+        return exc
 
     if not error_code:
         if "unique constraint" in error_msg:
-            _raise_aiosqlite_error(error, 0, UniqueViolationError, "unique constraint violation")
-        elif "foreign key constraint" in error_msg:
-            _raise_aiosqlite_error(error, 0, ForeignKeyViolationError, "foreign key constraint violation")
-        elif "not null constraint" in error_msg:
-            _raise_aiosqlite_error(error, 0, NotNullViolationError, "not-null constraint violation")
-        elif "check constraint" in error_msg:
-            _raise_aiosqlite_error(error, 0, CheckViolationError, "check constraint violation")
-        elif "syntax" in error_msg:
-            _raise_aiosqlite_error(error, None, SQLParsingError, "SQL syntax error")
-        else:
-            _raise_aiosqlite_error(error, None, SQLSpecError, "database error")
-        return
+            return _create_aiosqlite_error(error, 0, UniqueViolationError, "unique constraint violation")
+        if "foreign key constraint" in error_msg:
+            return _create_aiosqlite_error(error, 0, ForeignKeyViolationError, "foreign key constraint violation")
+        if "not null constraint" in error_msg:
+            return _create_aiosqlite_error(error, 0, NotNullViolationError, "not-null constraint violation")
+        if "check constraint" in error_msg:
+            return _create_aiosqlite_error(error, 0, CheckViolationError, "check constraint violation")
+        if "syntax" in error_msg:
+            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":
-        _raise_aiosqlite_error(error, error_code, UniqueViolationError, "unique constraint violation")
-    elif error_code == SQLITE_CONSTRAINT_FOREIGNKEY_CODE or error_name == "SQLITE_CONSTRAINT_FOREIGNKEY":
-        _raise_aiosqlite_error(error, error_code, ForeignKeyViolationError, "foreign key constraint violation")
-    elif error_code == SQLITE_CONSTRAINT_NOTNULL_CODE or error_name == "SQLITE_CONSTRAINT_NOTNULL":
-        _raise_aiosqlite_error(error, error_code, NotNullViolationError, "not-null constraint violation")
-    elif error_code == SQLITE_CONSTRAINT_CHECK_CODE or error_name == "SQLITE_CONSTRAINT_CHECK":
-        _raise_aiosqlite_error(error, error_code, CheckViolationError, "check constraint violation")
-    elif error_code == SQLITE_CONSTRAINT_CODE or error_name == "SQLITE_CONSTRAINT":
-        _raise_aiosqlite_error(error, error_code, IntegrityError, "integrity constraint violation")
-    elif error_code == SQLITE_CANTOPEN_CODE or error_name == "SQLITE_CANTOPEN":
-        _raise_aiosqlite_error(error, error_code, DatabaseConnectionError, "connection error")
-    elif error_code == SQLITE_IOERR_CODE or error_name == "SQLITE_IOERR":
-        _raise_aiosqlite_error(error, error_code, OperationalError, "operational error")
-    elif error_code == SQLITE_MISMATCH_CODE or error_name == "SQLITE_MISMATCH":
-        _raise_aiosqlite_error(error, error_code, DataError, "data error")
-    elif error_code == 1 or "syntax" in error_msg:
-        _raise_aiosqlite_error(error, error_code, SQLParsingError, "SQL syntax error")
-    else:
-        _raise_aiosqlite_error(error, error_code, SQLSpecError, "database error")
+        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":
+        return _create_aiosqlite_error(error, error_code, NotNullViolationError, "not-null constraint violation")
+    if error_code == SQLITE_CONSTRAINT_CHECK_CODE or error_name == "SQLITE_CONSTRAINT_CHECK":
+        return _create_aiosqlite_error(error, error_code, CheckViolationError, "check constraint violation")
+    if error_code == SQLITE_CONSTRAINT_CODE or error_name == "SQLITE_CONSTRAINT":
+        return _create_aiosqlite_error(error, error_code, IntegrityError, "integrity constraint violation")
+    if error_code == SQLITE_CANTOPEN_CODE or error_name == "SQLITE_CANTOPEN":
+        return _create_aiosqlite_error(error, error_code, DatabaseConnectionError, "connection error")
+    if error_code == SQLITE_IOERR_CODE or error_name == "SQLITE_IOERR":
+        return _create_aiosqlite_error(error, error_code, OperationalError, "operational error")
+    if error_code == SQLITE_MISMATCH_CODE or error_name == "SQLITE_MISMATCH":
+        return _create_aiosqlite_error(error, error_code, DataError, "data error")
+    if error_code == 1 or "syntax" in error_msg:
+        return _create_aiosqlite_error(error, error_code, SQLParsingError, "SQL syntax error")
+    return _create_aiosqlite_error(error, error_code, SQLSpecError, "database error")
 
 
 def build_profile() -> "DriverParameterProfile":

{sqlspec-0.35.0 → sqlspec-0.36.0}/sqlspec/adapters/aiosqlite/driver.py

@@ -11,12 +11,12 @@ import aiosqlite
 from sqlspec.adapters.aiosqlite.core import (
     build_insert_statement,
     collect_rows,
+    create_mapped_exception,
     default_statement_config,
     driver_profile,
     format_identifier,
     normalize_execute_many_parameters,
     normalize_execute_parameters,
-    raise_exception,
     resolve_rowcount,
 )
 from sqlspec.adapters.aiosqlite.data_dictionary import AiosqliteDataDictionary
@@ -88,12 +88,8 @@ class AiosqliteExceptionHandler:
         if exc_val is None:
             return False
         if isinstance(exc_val, (aiosqlite.Error, sqlite3.Error)):
-            try:
-                raise_exception(exc_val)
-            except Exception as mapped:
-                self.pending_exception = mapped
-                return True
-            return False
+            self.pending_exception = create_mapped_exception(exc_val)
+            return True
         return False
 
 

{sqlspec-0.35.0 → sqlspec-0.36.0}/sqlspec/adapters/asyncmy/core.py

@@ -27,11 +27,11 @@ __all__ = (
     "build_profile",
     "build_statement_config",
     "collect_rows",
+    "create_mapped_exception",
     "default_statement_config",
     "detect_json_columns",
     "driver_profile",
     "format_identifier",
-    "map_exception",
     "normalize_execute_many_parameters",
     "normalize_execute_parameters",
     "normalize_lastrowid",
@@ -153,18 +153,30 @@ def apply_driver_features(
     return statement_config, features
 
 
-def _raise_mysql_error(
+def _create_mysql_error(
     error: Any, sqlstate: "str | None", code: "int | None", error_class: type[SQLSpecError], description: str
-) -> None:
+) -> SQLSpecError:
+    """Create a MySQL error instance without raising it."""
     code_str = f"[{sqlstate or code}]" if sqlstate or code else ""
     msg = f"MySQL {description} {code_str}: {error}" if code_str else f"MySQL {description}: {error}"
-    raise error_class(msg) from error
+    exc = error_class(msg)
+    exc.__cause__ = error
+    return exc
 
 
-def map_exception(error: Any, *, logger: Any | None = None) -> "bool | None":
+def create_mapped_exception(error: Any, *, logger: Any | None = None) -> "SQLSpecError | bool":
     """Map AsyncMy exceptions to SQLSpec errors.
 
-    Returns True to suppress expected migration errors.
+    This is a factory function that returns an exception instance rather than
+    raising. This pattern is more robust for use in __exit__ handlers and
+    avoids issues with exception control flow in different Python versions.
+
+    Args:
+        error: The AsyncMy exception to map
+        logger: Optional logger for migration warnings
+
+    Returns:
+        True to suppress expected migration errors, or a SQLSpec exception
     """
     error_code = error.args[0] if len(error.args) >= 1 and isinstance(error.args[0], int) else None
     sqlstate = error.sqlstate if has_sqlstate(error) and error.sqlstate is not None else None
@@ -175,32 +187,32 @@ def map_exception(error: Any, *, logger: Any | None = None) -> "bool | None":
         return True
 
     if sqlstate == "23505" or error_code == MYSQL_ER_DUP_ENTRY:
-        _raise_mysql_error(error, sqlstate, error_code, UniqueViolationError, "unique constraint violation")
-    elif sqlstate == "23503" or error_code in {1216, 1217, 1451, 1452}:
-        _raise_mysql_error(error, sqlstate, error_code, ForeignKeyViolationError, "foreign key constraint violation")
-    elif sqlstate == "23502" or error_code in {1048, MYSQL_ER_NO_DEFAULT_FOR_FIELD}:
-        _raise_mysql_error(error, sqlstate, error_code, NotNullViolationError, "not-null constraint violation")
-    elif sqlstate == "23514" or error_code == MYSQL_ER_CHECK_CONSTRAINT_VIOLATED:
-        _raise_mysql_error(error, sqlstate, error_code, CheckViolationError, "check constraint violation")
-    elif sqlstate and sqlstate.startswith("23"):
-        _raise_mysql_error(error, sqlstate, error_code, IntegrityError, "integrity constraint violation")
-    elif sqlstate and sqlstate.startswith("42"):
-        _raise_mysql_error(error, sqlstate, error_code, SQLParsingError, "SQL syntax error")
-    elif sqlstate and sqlstate.startswith("08"):
-        _raise_mysql_error(error, sqlstate, error_code, DatabaseConnectionError, "connection error")
-    elif sqlstate and sqlstate.startswith("40"):
-        _raise_mysql_error(error, sqlstate, error_code, TransactionError, "transaction error")
-    elif sqlstate and sqlstate.startswith("22"):
-        _raise_mysql_error(error, sqlstate, error_code, DataError, "data error")
-    elif error_code in {2002, 2003, 2005, 2006, 2013}:
-        _raise_mysql_error(error, sqlstate, error_code, DatabaseConnectionError, "connection error")
-    elif error_code in {1205, 1213}:
-        _raise_mysql_error(error, sqlstate, error_code, TransactionError, "transaction error")
-    elif error_code in range(1064, 1100):
-        _raise_mysql_error(error, sqlstate, error_code, SQLParsingError, "SQL syntax error")
-    else:
-        _raise_mysql_error(error, sqlstate, error_code, SQLSpecError, "database error")
-    return None
+        return _create_mysql_error(error, sqlstate, error_code, UniqueViolationError, "unique constraint violation")
+    if sqlstate == "23503" or error_code in {1216, 1217, 1451, 1452}:
+        return _create_mysql_error(
+            error, sqlstate, error_code, ForeignKeyViolationError, "foreign key constraint violation"
+        )
+    if sqlstate == "23502" or error_code in {1048, MYSQL_ER_NO_DEFAULT_FOR_FIELD}:
+        return _create_mysql_error(error, sqlstate, error_code, NotNullViolationError, "not-null constraint violation")
+    if sqlstate == "23514" or error_code == MYSQL_ER_CHECK_CONSTRAINT_VIOLATED:
+        return _create_mysql_error(error, sqlstate, error_code, CheckViolationError, "check constraint violation")
+    if sqlstate and sqlstate.startswith("23"):
+        return _create_mysql_error(error, sqlstate, error_code, IntegrityError, "integrity constraint violation")
+    if sqlstate and sqlstate.startswith("42"):
+        return _create_mysql_error(error, sqlstate, error_code, SQLParsingError, "SQL syntax error")
+    if sqlstate and sqlstate.startswith("08"):
+        return _create_mysql_error(error, sqlstate, error_code, DatabaseConnectionError, "connection error")
+    if sqlstate and sqlstate.startswith("40"):
+        return _create_mysql_error(error, sqlstate, error_code, TransactionError, "transaction error")
+    if sqlstate and sqlstate.startswith("22"):
+        return _create_mysql_error(error, sqlstate, error_code, DataError, "data error")
+    if error_code in {2002, 2003, 2005, 2006, 2013}:
+        return _create_mysql_error(error, sqlstate, error_code, DatabaseConnectionError, "connection error")
+    if error_code in {1205, 1213}:
+        return _create_mysql_error(error, sqlstate, error_code, TransactionError, "transaction error")
+    if error_code in range(1064, 1100):
+        return _create_mysql_error(error, sqlstate, error_code, SQLParsingError, "SQL syntax error")
+    return _create_mysql_error(error, sqlstate, error_code, SQLSpecError, "database error")
 
 
 def detect_json_columns(cursor: Any, json_type_codes: "set[int]") -> "list[int]":

{sqlspec-0.35.0 → sqlspec-0.36.0}/sqlspec/adapters/asyncmy/driver.py

@@ -13,11 +13,11 @@ from asyncmy.cursors import Cursor, DictCursor  # pyright: ignore
 from sqlspec.adapters.asyncmy.core import (
     build_insert_statement,
     collect_rows,
+    create_mapped_exception,
     default_statement_config,
     detect_json_columns,
     driver_profile,
     format_identifier,
-    map_exception,
     normalize_execute_many_parameters,
     normalize_execute_parameters,
     normalize_lastrowid,
@@ -95,13 +95,11 @@ class AsyncmyExceptionHandler:
         if exc_type is None:
             return False
         if issubclass(exc_type, asyncmy.errors.Error):
-            try:
-                result = map_exception(exc_val, logger=logger)
-                if result is True:
-                    return True
-            except Exception as mapped:
-                self.pending_exception = mapped
+            result = create_mapped_exception(exc_val, logger=logger)
+            if result is True:
                 return True
+            self.pending_exception = cast("Exception", result)
+            return True
         return False