velocity-python 0.0.108__tar.gz → 0.0.109__tar.gz

{velocity_python-0.0.108/src/velocity_python.egg-info → velocity_python-0.0.109}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.108
+Version: 0.0.109
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT

{velocity_python-0.0.108 → velocity_python-0.0.109}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "velocity-python"
-version = "0.0.108"
+version = "0.0.109"
 authors = [
   { name="Velocity Team", email="info@codeclubs.org" },
 ]

{velocity_python-0.0.108 → velocity_python-0.0.109}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.108"
+__version__ = version = "0.0.109"
 
 from . import aws
 from . import db

{velocity_python-0.0.108 → velocity_python-0.0.109}/src/velocity/db/core/engine.py

@@ -24,6 +24,38 @@ class Engine:
         self.__sql = sql
         self.__driver = driver
         self.__connect_timeout = connect_timeout
+        
+        # Set up error code mappings from the SQL class
+        self._setup_error_mappings()
+
+    def _setup_error_mappings(self):
+        """
+        Set up error code to exception class mappings from the SQL driver.
+        """
+        self.error_codes = {}
+        
+        # Map error codes to exception class names
+        sql_attrs = [
+            ('ApplicationErrorCodes', 'DbApplicationError'),
+            ('DatabaseMissingErrorCodes', 'DbDatabaseMissingError'),
+            ('TableMissingErrorCodes', 'DbTableMissingError'), 
+            ('ColumnMissingErrorCodes', 'DbColumnMissingError'),
+            ('ForeignKeyMissingErrorCodes', 'DbForeignKeyMissingError'),
+            ('ConnectionErrorCodes', 'DbConnectionError'),
+            ('DuplicateKeyErrorCodes', 'DbDuplicateKeyError'),
+            ('RetryTransactionCodes', 'DbRetryTransaction'),
+            ('TruncationErrorCodes', 'DbTruncationError'),
+            ('LockTimeoutErrorCodes', 'DbLockTimeoutError'),
+            ('DatabaseObjectExistsErrorCodes', 'DbObjectExistsError'),
+            ('DataIntegrityErrorCodes', 'DbDataIntegrityError')
+        ]
+        
+        for attr_name, exception_class in sql_attrs:
+            if hasattr(self.sql, attr_name):
+                codes = getattr(self.sql, attr_name)
+                if codes:  # Only add non-empty lists
+                    for code in codes:
+                        self.error_codes[str(code)] = exception_class
 
     def __str__(self):
         return f"[{self.sql.server}] engine({self.config})"
@@ -352,7 +384,16 @@ class Engine:
         
         # Safely get error code and message with fallbacks
         try:
-            error_code = getattr(exception, 'pgcode', None) or self.get_error(exception)
+            # Try PostgreSQL-specific error code first, then use SQL driver's get_error method
+            error_code = getattr(exception, 'pgcode', None)
+            if not error_code and hasattr(self.sql, 'get_error'):
+                try:
+                    error_code, error_message_from_driver = self.sql.get_error(exception)
+                    if error_message_from_driver:
+                        error_message = error_message_from_driver
+                except Exception as get_error_exception:
+                    logger.warning(f"⚠️  SQL driver get_error failed: {get_error_exception}")
+                    error_code = None
         except Exception as e:
             logger.warning(f"⚠️  Unable to extract database error code: {e}")
             error_code = None
@@ -364,18 +405,16 @@ class Engine:
             error_message = f"<Error converting exception: {type(exception).__name__}>"
         
         # Primary error classification by error code
-        if error_code and hasattr(self, 'error_codes'):
-            for error_class, codes in self.error_codes.items():
-                if error_code in codes:
-                    logger.info(f"✅ Successfully classified error: {error_code} → {error_class}")
-                    try:
-                        raise self._create_exception_with_chaining(
-                            error_class, error_message, exception, sql, parameters
-                        )
-                    except Exception as creation_error:
-                        logger.error(f"❌ Failed to create {error_class} exception: {creation_error}")
-                        # Fall through to regex classification
-                        break
+        if error_code and hasattr(self, 'error_codes') and str(error_code) in self.error_codes:
+            error_class = self.error_codes[str(error_code)]
+            logger.info(f"✅ Successfully classified error: {error_code} → {error_class}")
+            try:
+                raise self._create_exception_with_chaining(
+                    error_class, error_message, exception, sql, parameters
+                )
+            except Exception as creation_error:
+                logger.error(f"❌ Failed to create {error_class} exception: {creation_error}")
+                # Fall through to regex classification
         
         # Secondary error classification by message patterns (regex fallback)
         error_message_lower = error_message.lower()
@@ -415,6 +454,13 @@ class Engine:
             r'schema.*does.*not.*exist|unknown.*table'
         ]
         
+        # Enhanced column missing patterns
+        column_missing_patterns = [
+            r'column.*does.*not.*exist',
+            r'unknown.*column|column.*not.*found',
+            r'no.*such.*column|invalid.*column.*name'
+        ]
+        
         # Enhanced syntax error patterns
         syntax_patterns = [
             r'syntax.*error|invalid.*syntax',
@@ -431,12 +477,13 @@ class Engine:
         
         # Comprehensive pattern matching with error class mapping
         pattern_mappings = [
-            (connection_patterns, 'ConnectionError'),
-            (duplicate_patterns, 'DuplicateError'), 
-            (permission_patterns, 'PermissionError'),
-            (not_found_patterns, 'NotFoundError'),
-            (syntax_patterns, 'SyntaxError'),
-            (deadlock_patterns, 'DeadlockError')
+            (connection_patterns, 'DbConnectionError'),
+            (duplicate_patterns, 'DbDuplicateKeyError'), 
+            (permission_patterns, 'DbPermissionError'),
+            (not_found_patterns, 'DbTableMissingError'),
+            (column_missing_patterns, 'DbColumnMissingError'),
+            (syntax_patterns, 'DbSyntaxError'),
+            (deadlock_patterns, 'DbDeadlockError')
         ]
         
         # Apply pattern matching

{velocity_python-0.0.108 → velocity_python-0.0.109/src/velocity_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.108
+Version: 0.0.109
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT