sqlspec 0.37.1__tar.gz → 0.38.1__tar.gz

{sqlspec-0.37.1 → sqlspec-0.38.1}/Makefile

@@ -78,6 +78,11 @@ upgrade:                                            ## Upgrade all dependencies
 	@echo "${OK} Dependencies updated 🔄"
 	@uv run pre-commit autoupdate
 	@echo "${OK} Updated Pre-commit hooks 🔄"
+	@uv lock >/dev/null 2>&1
+	@echo ""
+	@echo "${WARN} mysql-connector-python is pinned via [tool.uv] exclude-newer-package in pyproject.toml"
+	@echo "${INFO} Check https://pypi.org/project/mysql-connector-python/#files for Python 3.12+ wheels."
+	@echo "${INFO} Once Oracle fixes their packaging, remove the constraint from pyproject.toml."
 
 .PHONY: lock
 lock:                                              ## Rebuild lockfiles from scratch

{sqlspec-0.37.1 → sqlspec-0.38.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlspec
-Version: 0.37.1
+Version: 0.38.1
 Summary: SQL Experiments in Python
 Project-URL: Discord, https://discord.gg/litestar
 Project-URL: Issue, https://github.com/litestar-org/sqlspec/issues/
@@ -9,6 +9,15 @@ Author-email: Cody Fincher <cody@litestar.dev>
 Maintainer-email: Litestar Developers <hello@litestar.dev>
 License-Expression: MIT
 License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
 Requires-Python: <4.0,>=3.10
 Requires-Dist: mypy-extensions
 Requires-Dist: rich-click>=1.9.0

{sqlspec-0.37.1 → sqlspec-0.38.1}/pyproject.toml

@@ -1,5 +1,16 @@
 [project]
 authors = [{ name = "Cody Fincher", email = "cody@litestar.dev" }]
+classifiers = [
+  "Development Status :: 5 - Production/Stable",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Programming Language :: Python :: 3 :: Only",
+  "Typing :: Typed",
+]
 dependencies = [
   "typing-extensions",
   "sqlglot>=19.9.0",
@@ -13,7 +24,7 @@ maintainers = [{ name = "Litestar Developers", email = "hello@litestar.dev" }]
 name = "sqlspec"
 readme = "README.md"
 requires-python = ">=3.10, <4.0"
-version = "0.37.1"
+version = "0.38.1"
 
 [project.urls]
 Discord = "https://discord.gg/litestar"
@@ -137,6 +148,12 @@ test = [
   "pytest-timeout>=2.3.1",
 ]
 
+[tool.uv]
+# NOTE: mysql-connector-python 9.6.0 (released 2026-01-21) removed Python 3.12+ wheels.
+# This is an Oracle packaging bug. Pinning to versions before that date until fixed.
+# Check https://pypi.org/project/mysql-connector-python/#files for updates.
+exclude-newer-package = { mysql-connector-python = "2026-01-20" }
+
 [project.scripts]
 sqlspec = "sqlspec.__main__:run_cli"
 
@@ -182,6 +199,7 @@ exclude = [
 include = [
   "sqlspec/core/**/*.py",                  # Core module
   "sqlspec/builder/**/*.py",               # Builder module
+  "sqlspec/exceptions.py",                 # Exceptions module
   "sqlspec/loader.py",                     # Loader module
   "sqlspec/observability/**/*.py",         # Observability utilities
   "sqlspec/driver/**/*.py",                # Driver module
@@ -222,7 +240,7 @@ opt_level = "3"   # Maximum optimization (0-3)
 allow_dirty = true
 commit = false
 commit_args = "--no-verify"
-current_version = "0.37.1"
+current_version = "0.38.1"
 ignore_missing_files = false
 ignore_missing_version = false
 message = "chore(release): bump to v{new_version}"

{sqlspec-0.37.1 → sqlspec-0.38.1}/sqlspec/adapters/adbc/core.py

@@ -15,15 +15,17 @@ from sqlspec.core import (
 from sqlspec.exceptions import (
     CheckViolationError,
     DatabaseConnectionError,
-    DataError,
+    DeadlockError,
     ForeignKeyViolationError,
     ImproperConfigurationError,
     IntegrityError,
     NotNullViolationError,
+    PermissionDeniedError,
+    QueryTimeoutError,
     SQLParsingError,
     SQLSpecError,
-    TransactionError,
     UniqueViolationError,
+    map_sqlstate_to_exception,
 )
 from sqlspec.typing import Empty
 from sqlspec.utils.module_loader import import_string
@@ -424,15 +426,22 @@ def create_mapped_exception(error: Any) -> SQLSpecError:
     raising. This pattern is more robust for use in __exit__ handlers and
     avoids issues with exception control flow in different Python versions.
 
+    Mapping priority:
+    1. SQLSTATE codes (most reliable for ADBC drivers)
+    2. Error message patterns
+    3. Default SQLSpecError fallback
+
     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
+    sqlstate_attr = error.sqlstate if has_sqlstate(error) else None
+    sqlstate = sqlstate_attr if sqlstate_attr is not None else None
 
     if sqlstate:
+        # Use centralized SQLSTATE mapping for specific codes
         if sqlstate == "23505":
             return _create_adbc_error(error, UniqueViolationError, "unique constraint violation")
         if sqlstate == "23503":
@@ -441,20 +450,36 @@ def create_mapped_exception(error: Any) -> SQLSpecError:
             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")
+
+        # Deadlock and serialization errors
+        if sqlstate == "40P01":
+            return _create_adbc_error(error, DeadlockError, "deadlock detected")
+        if sqlstate == "40001":
+            return _create_adbc_error(error, DeadlockError, "serialization failure")
+
+        # Query timeout/cancellation
+        if sqlstate == "57014":
+            return _create_adbc_error(error, QueryTimeoutError, "query canceled")
+
+        # Permission errors
+        if sqlstate == "42501":
+            return _create_adbc_error(error, PermissionDeniedError, "insufficient privilege")
+        if sqlstate == "28000":
+            return _create_adbc_error(error, PermissionDeniedError, "invalid authorization")
+
+        # Use centralized mapping for SQLSTATE class prefixes
+        exc_class = map_sqlstate_to_exception(sqlstate)
+        if exc_class is not None and exc_class is not SQLSpecError:
+            description = _get_sqlstate_description(sqlstate)
+            return _create_adbc_error(error, exc_class, description)
+
+        # Fallback for unmapped SQLSTATE codes
         return _create_adbc_error(error, SQLSpecError, "database error")
 
+    # Message-based fallback when no SQLSTATE is available
     error_msg = str(error).lower()
 
+    # Constraint violations
     if "unique" in error_msg or "duplicate" in error_msg:
         return _create_adbc_error(error, UniqueViolationError, "unique constraint violation")
     if "foreign key" in error_msg:
@@ -465,13 +490,53 @@ def create_mapped_exception(error: Any) -> SQLSpecError:
         return _create_adbc_error(error, CheckViolationError, "check constraint violation")
     if "constraint" in error_msg:
         return _create_adbc_error(error, IntegrityError, "integrity constraint violation")
+
+    # Deadlock/lock patterns
+    if "deadlock" in error_msg:
+        return _create_adbc_error(error, DeadlockError, "deadlock detected")
+    if "serialization" in error_msg or "concurrent update" in error_msg:
+        return _create_adbc_error(error, DeadlockError, "serialization failure")
+
+    # Timeout/cancellation patterns
+    if "timeout" in error_msg or "cancel" in error_msg or "interrupt" in error_msg:
+        return _create_adbc_error(error, QueryTimeoutError, "query timeout")
+
+    # Permission patterns
+    if "permission" in error_msg or "denied" in error_msg or "unauthorized" in error_msg:
+        return _create_adbc_error(error, PermissionDeniedError, "permission denied")
+
+    # Syntax errors
     if "syntax" in error_msg:
         return _create_adbc_error(error, SQLParsingError, "SQL parsing error")
+
+    # Connection errors
     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")
 
 
+_SQLSTATE_CLASS_CODE_LEN = 2
+
+# Module-level SQLSTATE descriptions (mypyc optimization - avoid dict creation per call)
+_SQLSTATE_DESCRIPTIONS: dict[str, str] = {
+    "23": "integrity constraint violation",
+    "40": "transaction error",
+    "42": "SQL syntax error",
+    "08": "connection error",
+    "22": "data error",
+    "28": "authorization error",
+    "57": "operational error",
+    "02": "no data",
+}
+
+
+def _get_sqlstate_description(sqlstate: str) -> str:
+    """Get a human-readable description for a SQLSTATE code class."""
+    class_code = sqlstate[:_SQLSTATE_CLASS_CODE_LEN] if len(sqlstate) >= _SQLSTATE_CLASS_CODE_LEN else sqlstate
+    return _SQLSTATE_DESCRIPTIONS.get(class_code, "database error")
+
+
 def _identity(value: Any) -> Any:
     return value
 

{sqlspec-0.37.1 → sqlspec-0.38.1}/sqlspec/adapters/aiosqlite/pool.py

@@ -1,6 +1,7 @@
 """Multi-connection pool for aiosqlite."""
 
 import asyncio
+import logging
 import time
 from contextlib import suppress
 from typing import TYPE_CHECKING, Any
@@ -8,7 +9,7 @@ from typing import TYPE_CHECKING, Any
 import aiosqlite
 
 from sqlspec.exceptions import SQLSpecError
-from sqlspec.utils.logging import get_logger
+from sqlspec.utils.logging import POOL_LOGGER_NAME, get_logger, log_with_context
 from sqlspec.utils.uuids import uuid4
 
 if TYPE_CHECKING:
@@ -24,7 +25,9 @@ __all__ = (
     "AiosqlitePoolConnectionContext",
 )
 
-logger = get_logger(__name__)
+logger = get_logger(POOL_LOGGER_NAME)
+
+_ADAPTER_NAME = "aiosqlite"
 
 
 class AiosqlitePoolClosedError(SQLSpecError):
@@ -127,7 +130,10 @@ class AiosqlitePoolConnection:
                 await self.connection.rollback()
             await self.connection.close()
         except Exception:
-            logger.debug("Error closing connection %s", self.id)
+            # Note: No pool context available at connection level
+            log_with_context(
+                logger, logging.DEBUG, "pool.connection.close.error", adapter=_ADAPTER_NAME, connection_id=self.id
+            )
         finally:
             self._closed = True
 
@@ -173,6 +179,7 @@ class AiosqliteConnectionPool:
         "_lock_instance",
         "_min_size",
         "_operation_timeout",
+        "_pool_id",
         "_pool_size",
         "_queue_instance",
         "_wal_initialized",
@@ -211,6 +218,7 @@ class AiosqliteConnectionPool:
         self._connection_registry: dict[str, AiosqlitePoolConnection] = {}
         self._wal_initialized = False
         self._warmed = False
+        self._pool_id = uuid4().hex[:8]  # Short ID for logging
 
         self._queue_instance: asyncio.Queue[AiosqlitePoolConnection] | None = None
         self._lock_instance: asyncio.Lock | None = None
@@ -246,6 +254,12 @@ class AiosqliteConnectionPool:
         """
         return self._closed_event_instance is not None and self._closed_event.is_set()
 
+    @property
+    def _database_name(self) -> str:
+        """Get sanitized database name for logging."""
+        db = self._connection_parameters.get("database", "unknown")
+        return str(db).split("/")[-1] if db else "unknown"
+
     def size(self) -> int:
         """Get total number of connections in pool.
 
@@ -298,7 +312,14 @@ class AiosqliteConnectionPool:
                 self._wal_initialized = True
 
         except Exception:
-            logger.exception("Failed to configure connection")
+            log_with_context(
+                logger,
+                logging.WARNING,
+                "pool.connection.configure.error",
+                adapter=_ADAPTER_NAME,
+                pool_id=self._pool_id,
+                database=self._database_name,
+            )
             await connection.execute("PRAGMA foreign_keys = ON")
             await connection.execute("PRAGMA busy_timeout = 30000")
             await connection.commit()
@@ -353,14 +374,30 @@ class AiosqliteConnectionPool:
             reason: Optional reason for retirement
         """
         if reason:
-            logger.debug("Retiring connection %s", connection.id, extra={"reason": reason})
+            log_with_context(
+                logger,
+                logging.DEBUG,
+                "pool.connection.retire",
+                adapter=_ADAPTER_NAME,
+                pool_id=self._pool_id,
+                connection_id=connection.id,
+                reason=reason,
+            )
         async with self._lock:
             self._connection_registry.pop(connection.id, None)
 
         try:
             await asyncio.wait_for(connection.close(), timeout=self._operation_timeout)
         except asyncio.TimeoutError:
-            logger.warning("Connection %s close timed out during retirement", connection.id)
+            log_with_context(
+                logger,
+                logging.WARNING,
+                "pool.connection.close.timeout",
+                adapter=_ADAPTER_NAME,
+                pool_id=self._pool_id,
+                connection_id=connection.id,
+                timeout_seconds=self._operation_timeout,
+            )
 
     async def _try_provision_new_connection(self) -> "AiosqlitePoolConnection | None":
         """Try to create a new connection if under capacity.
@@ -375,7 +412,16 @@ class AiosqliteConnectionPool:
         try:
             connection = await self._create_connection()
         except Exception:
-            logger.exception("Failed to create new connection")
+            log_with_context(
+                logger,
+                logging.WARNING,
+                "pool.connection.create.error",
+                adapter=_ADAPTER_NAME,
+                pool_id=self._pool_id,
+                database=self._database_name,
+                pool_size=len(self._connection_registry),
+                max_size=self._pool_size,
+            )
             return None
         else:
             connection.mark_as_in_use()
@@ -428,7 +474,16 @@ class AiosqliteConnectionPool:
         if connections_needed <= 0:
             return
 
-        logger.debug("Warming pool with %d connections", connections_needed)
+        log_with_context(
+            logger,
+            logging.DEBUG,
+            "pool.warmup.start",
+            adapter=_ADAPTER_NAME,
+            pool_id=self._pool_id,
+            database=self._database_name,
+            connections_needed=connections_needed,
+            min_size=self._min_size,
+        )
         tasks = [self._create_connection() for _ in range(connections_needed)]
         results = await asyncio.gather(*tasks, return_exceptions=True)
 
@@ -436,7 +491,14 @@ class AiosqliteConnectionPool:
             if isinstance(result, AiosqlitePoolConnection):
                 self._queue.put_nowait(result)
             elif isinstance(result, Exception):
-                logger.warning("Failed to create warm connection: %s", result)
+                log_with_context(
+                    logger,
+                    logging.WARNING,
+                    "pool.warmup.connection.error",
+                    adapter=_ADAPTER_NAME,
+                    pool_id=self._pool_id,
+                    error=str(result),
+                )
 
     async def _get_connection(self) -> AiosqlitePoolConnection:
         """Run the three-phase connection acquisition cycle.
@@ -495,7 +557,14 @@ class AiosqliteConnectionPool:
             return
 
         if connection.id not in self._connection_registry:
-            logger.warning("Attempted to release unknown connection: %s", connection.id)
+            log_with_context(
+                logger,
+                logging.WARNING,
+                "pool.connection.release.unknown",
+                adapter=_ADAPTER_NAME,
+                pool_id=self._pool_id,
+                connection_id=connection.id,
+            )
             return
 
         try:
@@ -503,7 +572,15 @@ class AiosqliteConnectionPool:
             connection.mark_as_idle()
             self._queue.put_nowait(connection)
         except Exception as e:
-            logger.warning("Failed to reset connection %s during release: %s", connection.id, e)
+            log_with_context(
+                logger,
+                logging.WARNING,
+                "pool.connection.reset.error",
+                adapter=_ADAPTER_NAME,
+                pool_id=self._pool_id,
+                connection_id=connection.id,
+                error=str(e),
+            )
             connection.mark_unhealthy()
             await self._retire_connection(connection)
 
@@ -530,4 +607,12 @@ class AiosqliteConnectionPool:
 
             for i, result in enumerate(results):
                 if isinstance(result, Exception):
-                    logger.warning("Error closing connection %s: %s", connections[i].id, result)
+                    log_with_context(
+                        logger,
+                        logging.WARNING,
+                        "pool.close.connection.error",
+                        adapter=_ADAPTER_NAME,
+                        pool_id=self._pool_id,
+                        connection_id=connections[i].id,
+                        error=str(result),
+                    )

{sqlspec-0.37.1 → sqlspec-0.38.1}/sqlspec/adapters/asyncmy/core.py

@@ -5,11 +5,15 @@ from typing import TYPE_CHECKING, Any
 from sqlspec.core import DriverParameterProfile, ParameterStyle, StatementConfig, build_statement_config_from_profile
 from sqlspec.exceptions import (
     CheckViolationError,
+    ConnectionTimeoutError,
     DatabaseConnectionError,
     DataError,
+    DeadlockError,
     ForeignKeyViolationError,
     IntegrityError,
     NotNullViolationError,
+    PermissionDeniedError,
+    QueryTimeoutError,
     SQLParsingError,
     SQLSpecError,
     TransactionError,
@@ -38,10 +42,27 @@ __all__ = (
     "resolve_rowcount",
 )
 
+# MySQL error codes for constraint violations
 MYSQL_ER_DUP_ENTRY = 1062
 MYSQL_ER_NO_DEFAULT_FOR_FIELD = 1364
 MYSQL_ER_CHECK_CONSTRAINT_VIOLATED = 3819
 
+# MySQL error codes for permission/access errors
+MYSQL_ER_DBACCESS_DENIED = 1044
+MYSQL_ER_ACCESS_DENIED = 1045
+MYSQL_ER_TABLEACCESS_DENIED = 1142
+
+# MySQL error codes for transaction errors
+MYSQL_ER_LOCK_WAIT_TIMEOUT = 1205
+MYSQL_ER_LOCK_DEADLOCK = 1213
+
+# MySQL error codes for connection errors
+MYSQL_CR_CONNECTION_ERROR = 2002
+MYSQL_CR_CONN_HOST_ERROR = 2003
+MYSQL_CR_UNKNOWN_HOST = 2005
+MYSQL_CR_SERVER_GONE_ERROR = 2006
+MYSQL_CR_SERVER_LOST = 2013
+
 
 def _bool_to_int(value: bool) -> int:
     return int(value)
@@ -104,7 +125,7 @@ def build_profile() -> "DriverParameterProfile":
     return DriverParameterProfile(
         name="AsyncMy",
         default_style=ParameterStyle.QMARK,
-        supported_styles={ParameterStyle.QMARK, ParameterStyle.POSITIONAL_PYFORMAT},
+        supported_styles={ParameterStyle.QMARK},
         default_execution_style=ParameterStyle.POSITIONAL_PYFORMAT,
         supported_execution_styles={ParameterStyle.POSITIONAL_PYFORMAT},
         has_native_list_expansion=False,
@@ -171,6 +192,12 @@ def create_mapped_exception(error: Any, *, logger: Any | None = None) -> "SQLSpe
     raising. This pattern is more robust for use in __exit__ handlers and
     avoids issues with exception control flow in different Python versions.
 
+    Mapping priority:
+    1. Specific error codes (most reliable for MySQL)
+    2. SQLSTATE codes (where available)
+    3. Generic error code ranges
+    4. Default SQLSpecError fallback
+
     Args:
         error: The AsyncMy exception to map
         logger: Optional logger for migration warnings
@@ -179,13 +206,16 @@ def create_mapped_exception(error: Any, *, logger: Any | None = None) -> "SQLSpe
         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
+    sqlstate_attr = error.sqlstate if has_sqlstate(error) else None
+    sqlstate = sqlstate_attr if sqlstate_attr is not None else None
 
+    # Migration-specific errors to suppress
     if error_code in {1061, 1091}:
         if logger is not None:
             logger.warning("AsyncMy MySQL expected migration error (ignoring): %s", error)
         return True
 
+    # Integrity constraint violations
     if sqlstate == "23505" or error_code == MYSQL_ER_DUP_ENTRY:
         return _create_mysql_error(error, sqlstate, error_code, UniqueViolationError, "unique constraint violation")
     if sqlstate == "23503" or error_code in {1216, 1217, 1451, 1452}:
@@ -198,20 +228,44 @@ def create_mapped_exception(error: Any, *, logger: Any | None = None) -> "SQLSpe
         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")
+
+    # Permission/access errors (check specific codes first)
+    if error_code in {MYSQL_ER_DBACCESS_DENIED, MYSQL_ER_ACCESS_DENIED, MYSQL_ER_TABLEACCESS_DENIED}:
+        return _create_mysql_error(error, sqlstate, error_code, PermissionDeniedError, "access denied")
+    if sqlstate and sqlstate.startswith("28"):
+        return _create_mysql_error(error, sqlstate, error_code, PermissionDeniedError, "authorization error")
+
+    # Transaction errors (deadlock vs lock wait timeout)
+    if error_code == MYSQL_ER_LOCK_DEADLOCK:
+        return _create_mysql_error(error, sqlstate, error_code, DeadlockError, "deadlock detected")
+    if error_code == MYSQL_ER_LOCK_WAIT_TIMEOUT:
+        return _create_mysql_error(error, sqlstate, error_code, QueryTimeoutError, "lock wait timeout")
+    if sqlstate and sqlstate.startswith("40"):
+        return _create_mysql_error(error, sqlstate, error_code, TransactionError, "transaction error")
+
+    # SQL syntax errors
     if sqlstate and sqlstate.startswith("42"):
         return _create_mysql_error(error, sqlstate, error_code, SQLParsingError, "SQL syntax error")
+    if error_code in range(1064, 1100):
+        return _create_mysql_error(error, sqlstate, error_code, SQLParsingError, "SQL syntax error")
+
+    # Connection errors
     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 error_code == MYSQL_CR_SERVER_LOST:
+        return _create_mysql_error(error, sqlstate, error_code, ConnectionTimeoutError, "connection lost")
+    if error_code in {
+        MYSQL_CR_CONNECTION_ERROR,
+        MYSQL_CR_CONN_HOST_ERROR,
+        MYSQL_CR_UNKNOWN_HOST,
+        MYSQL_CR_SERVER_GONE_ERROR,
+    }:
+        return _create_mysql_error(error, sqlstate, error_code, DatabaseConnectionError, "connection error")
+
+    # Data errors
     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")