velocity-python 0.0.97__py3-none-any.whl → 0.0.100__py3-none-any.whl

velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.97"
+__version__ = version = "0.0.98"
 
 from . import aws
 from . import db

velocity/db/core/engine.py

@@ -325,81 +325,192 @@ class Engine:
             result = tx.execute(sql, vals)
             return [f"{x[0]}.{x[1]}" for x in result.as_tuple()]
 
-    def process_error(self, sql_stmt=None, sql_params=None):
-        """
-        Central method to parse driver exceptions and re-raise them as our custom exceptions.
-        """
-        e = sys.exc_info()[1]
-        msg = str(e).strip().lower()
-
-        if isinstance(e, exceptions.DbException):
-            raise
-
-        error_code, error_mesg = self.sql.get_error(e)
-
+    def process_error(self, exception, sql=None, parameters=None):
+        """
+        Process database errors and raise appropriate velocity exceptions.
+        Enhanced for robustness with exception chaining and comprehensive error handling.
+        
+        Args:
+            exception: The original exception from the database driver
+            sql: The SQL statement that caused the error (optional)
+            parameters: The parameters passed to the SQL statement (optional)
+            
+        Returns:
+            The appropriate velocity exception to raise
+        """
+        logger = logging.getLogger(__name__)
+        
+        # Enhanced logging with context
+        extra_data = {
+            'exception_type': type(exception).__name__,
+            'sql': sql,
+            'parameters': parameters
+        }
+        
+        logger.error(
+            f"Database error caught. Attempting to transform: "
+            f"type={type(exception).__name__}, sql={sql[:100] if sql else 'None'}...",
+            extra=extra_data
+        )
+        
+        # Safely get error code and message with fallbacks
+        try:
+            error_code = getattr(exception, 'pgcode', None) or self.get_error(exception)
+        except Exception as e:
+            logger.warning(f"Failed to extract error code: {e}")
+            error_code = None
+            
+        try:
+            error_message = str(exception)
+        except Exception as e:
+            logger.warning(f"Failed to convert exception to string: {e}")
+            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"Classified error by code: {error_code} -> {error_class}")
+                    try:
+                        return 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
+        
+        # Secondary error classification by message patterns (regex fallback)
+        error_message_lower = error_message.lower()
+        
+        # Enhanced connection error patterns
+        connection_patterns = [
+            r'connection.*refused|could not connect',
+            r'network.*unreachable|network.*down',
+            r'broken pipe|connection.*broken',
+            r'timeout.*connection|connection.*timeout',
+            r'server.*closed.*connection|connection.*lost',
+            r'no route to host|host.*unreachable',
+            r'connection.*reset|reset.*connection'
+        ]
+        
+        # Enhanced duplicate key patterns  
+        duplicate_patterns = [
+            r'duplicate.*key.*value|unique.*constraint.*violated',
+            r'duplicate.*entry|key.*already.*exists',
+            r'violates.*unique.*constraint',
+            r'unique.*violation|constraint.*unique'
+        ]
+        
+        # Enhanced permission/authorization patterns
+        permission_patterns = [
+            r'permission.*denied|access.*denied|authorization.*failed',
+            r'insufficient.*privileges|privilege.*denied',
+            r'not.*authorized|unauthorized.*access',
+            r'authentication.*failed|login.*failed'
+        ]
+        
+        # Enhanced database/table not found patterns
+        not_found_patterns = [
+            r'database.*does.*not.*exist|unknown.*database',
+            r'table.*does.*not.*exist|relation.*does.*not.*exist',
+            r'no.*such.*database|database.*not.*found',
+            r'schema.*does.*not.*exist|unknown.*table'
+        ]
+        
+        # Enhanced syntax error patterns
+        syntax_patterns = [
+            r'syntax.*error|invalid.*syntax',
+            r'malformed.*query|bad.*sql.*grammar',
+            r'unexpected.*token|parse.*error'
+        ]
+        
+        # Enhanced deadlock/timeout patterns
+        deadlock_patterns = [
+            r'deadlock.*detected|lock.*timeout',
+            r'timeout.*waiting.*for.*lock|query.*timeout',
+            r'lock.*wait.*timeout|deadlock.*found'
+        ]
+        
+        # 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')
+        ]
+        
+        # Apply pattern matching
+        for patterns, error_class in pattern_mappings:
+            for pattern in patterns:
+                try:
+                    if re.search(pattern, error_message_lower):
+                        logger.info(f"Classified error by pattern: '{pattern}' -> {error_class}")
+                        return self._create_exception_with_chaining(
+                            error_class, error_message, exception, sql, parameters
+                        )
+                except re.error as regex_error:
+                    logger.warning(f"Regex pattern error '{pattern}': {regex_error}")
+                    continue
+                except Exception as pattern_error:
+                    logger.error(f"Error applying pattern '{pattern}': {pattern_error}")
+                    continue
+        
+        # Fallback: return generic database error with full context
         logger.warning(
-            "Database error caught. Attempting to transform: code=%s message=%s",
-            error_code,
-            error_mesg,
+            f"Could not classify error. Returning generic DatabaseError. "
+            f"Error code: {error_code}, Available error codes: {list(getattr(self, 'error_codes', {}).keys()) if hasattr(self, 'error_codes') else 'None'}"
         )
-
-        if error_code in self.sql.ApplicationErrorCodes:
-            raise exceptions.DbApplicationError from None
-        if error_code in self.sql.ColumnMissingErrorCodes:
-            raise exceptions.DbColumnMissingError from None
-        if error_code in self.sql.TableMissingErrorCodes:
-            raise exceptions.DbTableMissingError from None
-        if error_code in self.sql.DatabaseMissingErrorCodes:
-            raise exceptions.DbDatabaseMissingError from None
-        if error_code in self.sql.ForeignKeyMissingErrorCodes:
-            raise exceptions.DbForeignKeyMissingError from None
-        if error_code in self.sql.TruncationErrorCodes:
-            raise exceptions.DbTruncationError from None
-        if error_code in self.sql.DataIntegrityErrorCodes:
-            raise exceptions.DbDataIntegrityError from None
-        if error_code in self.sql.ConnectionErrorCodes:
-            raise exceptions.DbConnectionError from None
-        if error_code in self.sql.DuplicateKeyErrorCodes:
-            raise exceptions.DbDuplicateKeyError from None
-        if re.search(r"key \(sys_id\)=\(\d+\) already exists.", msg, re.M):
-            raise exceptions.DbDuplicateKeyError from None
-        if error_code in self.sql.DatabaseObjectExistsErrorCodes:
-            raise exceptions.DbObjectExistsError from None
-        if error_code in self.sql.LockTimeoutErrorCodes:
-            raise exceptions.DbLockTimeoutError from None
-        if error_code in self.sql.RetryTransactionCodes:
-            raise exceptions.DbRetryTransaction from None
-        if re.findall(r"database.*does not exist", msg, re.M):
-            raise exceptions.DbDatabaseMissingError from None
-        if re.findall(r"no such database", msg, re.M):
-            raise exceptions.DbDatabaseMissingError from None
-        if re.findall(r"already exists", msg, re.M):
-            raise exceptions.DbObjectExistsError from None
-        if re.findall(r"server closed the connection unexpectedly", msg, re.M):
-            raise exceptions.DbConnectionError from None
-        if re.findall(r"no connection to the server", msg, re.M):
-            raise exceptions.DbConnectionError from None
-        if re.findall(r"connection timed out", msg, re.M):
-            raise exceptions.DbConnectionError from None
-        if re.findall(r"could not connect to server", msg, re.M):
-            raise exceptions.DbConnectionError from None
-        if re.findall(r"cannot connect to server", msg, re.M):
-            raise exceptions.DbConnectionError from None
-        if re.findall(r"connection already closed", msg, re.M):
-            raise exceptions.DbConnectionError from None
-        if re.findall(r"cursor already closed", msg, re.M):
-            raise exceptions.DbConnectionError from None
-        if "no such table:" in msg:
-            raise exceptions.DbTableMissingError from None
-
-        logger.error(
-            "Unhandled/Unknown Error in engine.process_error",
-            exc_info=True,
-            extra={
-                "error_code": error_code,
-                "error_msg": error_mesg,
-                "sql_stmt": sql_stmt,
-                "sql_params": sql_params,
-            },
+        
+        return self._create_exception_with_chaining(
+            'DatabaseError', error_message, exception, sql, parameters
         )
-        raise
+    
+    def _create_exception_with_chaining(self, error_class, message, original_exception, sql=None, parameters=None):
+        """
+        Create a velocity exception with proper exception chaining.
+        
+        Args:
+            error_class: The name of the exception class to create
+            message: The error message
+            original_exception: The original exception to chain
+            sql: The SQL statement (optional)
+            parameters: The SQL parameters (optional)
+            
+        Returns:
+            The created exception with proper chaining
+        """
+        logger = logging.getLogger(__name__)
+        
+        try:
+            # Import the exception class dynamically
+            exception_module = __import__('velocity.db.exceptions', fromlist=[error_class])
+            ExceptionClass = getattr(exception_module, error_class)
+            
+            # Create enhanced message with context
+            if sql:
+                enhanced_message = f"{message} (SQL: {sql[:200]}{'...' if len(sql) > 200 else ''})"
+            else:
+                enhanced_message = message
+                
+            # Create the exception with chaining
+            new_exception = ExceptionClass(enhanced_message)
+            new_exception.__cause__ = original_exception  # Preserve exception chain
+            
+            return new_exception
+            
+        except (ImportError, AttributeError) as e:
+            logger.error(f"Could not import exception class {error_class}: {e}")
+            # Fallback to generic database error
+            try:
+                exception_module = __import__('velocity.db.exceptions', fromlist=['DatabaseError'])
+                DatabaseError = getattr(exception_module, 'DatabaseError')
+                fallback_exception = DatabaseError(f"Database error: {message}")
+                fallback_exception.__cause__ = original_exception
+                return fallback_exception
+            except Exception as fallback_error:
+                logger.critical(f"Failed to create fallback exception: {fallback_error}")
+                # Last resort: return the original exception
+                return original_exception

velocity/db/servers/postgres/sql.py

@@ -68,20 +68,20 @@ class SQL:
 
     default_schema = "public"
 
-    ApplicationErrorCodes = ["22P02", "42883"]
+    ApplicationErrorCodes = ["22P02", "42883", "42501", "42601", "25P01", "25P02"]
 
-    DatabaseMissingErrorCodes = []
+    DatabaseMissingErrorCodes = ["3D000"]
     TableMissingErrorCodes = ["42P01"]
     ColumnMissingErrorCodes = ["42703"]
     ForeignKeyMissingErrorCodes = ["42704"]
 
-    ConnectionErrorCodes = ["08001", "08S01", "57P03", "08006", "53300"]
-    DuplicateKeyErrorCodes = []  # Handled in regex check.
-    RetryTransactionCodes = []
+    ConnectionErrorCodes = ["08001", "08S01", "57P03", "08006", "53300", "08003", "08004", "08P01"]
+    DuplicateKeyErrorCodes = ["23505"]  # unique_violation - no longer relying only on regex
+    RetryTransactionCodes = ["40001", "40P01", "40002"]
     TruncationErrorCodes = ["22001"]
     LockTimeoutErrorCodes = ["55P03"]
     DatabaseObjectExistsErrorCodes = ["42710", "42P07", "42P04"]
-    DataIntegrityErrorCodes = ["23503"]
+    DataIntegrityErrorCodes = ["23503", "23502", "23514", "23P01", "22003"]
 
     @classmethod
     def get_error(self, e):

velocity/db/servers/tablehelper.py

@@ -182,7 +182,9 @@ class TableHelper:
         if options is None:
             options = {"alias_column": True, "alias_table": False, "alias_only": False}
             
-        column = self.extract_column_name(key)
+        # Remove operator first, then extract column name
+        key_without_operator = self.remove_operator(key)
+        column = self.extract_column_name(key_without_operator)
         if not column:
             if options.get("bypass_on_error"):
                 return key
@@ -339,8 +341,19 @@ class TableHelper:
             expr = expr.split(",")[0].strip()
 
         # Extract column name (basic or dotted like table.col or *)
+        # Handle asterisk separately since \b doesn't work with non-word characters
+        if expr.strip() == "*":
+            return "*"
+        
+        # Check for pointer syntax (>)
+        if ">" in expr:
+            # For pointer syntax, return the whole expression
+            pointer_match = re.search(r"([a-zA-Z_][\w]*>[a-zA-Z_][\w]*)", expr)
+            if pointer_match:
+                return pointer_match.group(1)
+        
         match = re.search(
-            r"\b([a-zA-Z_][\w]*\.\*|\*|[a-zA-Z_][\w]*(?:\.[a-zA-Z_][\w]*)?)\b", expr
+            r"\b([a-zA-Z_][\w]*\.\*|[a-zA-Z_][\w]*(?:\.[a-zA-Z_][\w]*)?)\b", expr
         )
         return match.group(1) if match else None
 

{velocity_python-0.0.97.dist-info → velocity_python-0.0.100.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.97
+Version: 0.0.100
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <contact@example.com>
 License: MIT

{velocity_python-0.0.97.dist-info → velocity_python-0.0.100.dist-info}/RECORD

@@ -1,4 +1,4 @@
-velocity/__init__.py,sha256=INVMQ4GO-JInxsuAsrayUJ5jvsooS1cSwDflvVJjvPE,106
+velocity/__init__.py,sha256=O-57F3X343WA-gKPiQGHVnZP1MzGg0pLJt9430h-6gQ,106
 velocity/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 velocity/app/invoices.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 velocity/app/orders.py,sha256=W-HAXEwY8-IFXbKh82HnMeRVZM7P-TWGEQOWtkLIzI4,6298
@@ -16,7 +16,7 @@ velocity/db/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,
 velocity/db/core/column.py,sha256=tAr8tL3a2nyaYpNHhGl508FrY_pGZTzyYgjAV5CEBv4,4092
 velocity/db/core/database.py,sha256=3zNGItklu9tZCKsbx2T2vCcU1so8AL9PPL0DLjvaz6s,3554
 velocity/db/core/decorators.py,sha256=76Jkr9XptXt8cvcgp1zbHfuL8uHzWy8lwfR29u-DVu4,4574
-velocity/db/core/engine.py,sha256=3POukyvvtGVTwEGx4vsAInWw_WGGsqMdBFozoPUnIi0,14665
+velocity/db/core/engine.py,sha256=UmaYwVCDBtvDHdHdKNsZ4kZ0GpZ7uMp1MaqpfOHblNI,19311
 velocity/db/core/exceptions.py,sha256=MOWyA1mlMe8eWbFkEHK0Lp9czdplpRyqbAn2JfGmMrM,707
 velocity/db/core/result.py,sha256=OVqoMwlx3CHNNwr-JGWRx5I8u_YX6hlUpecx99UT5nE,6164
 velocity/db/core/row.py,sha256=aliLYTTFirgJsOvmUsANwJMyxaATuhpGpFJhcu_twwY,6709
@@ -30,11 +30,11 @@ velocity/db/servers/sqlite.py,sha256=X210a5pENT9PiVK7f16fxXzFwEsq8fSe58Vouv2xqlk
 velocity/db/servers/sqlite_reserved.py,sha256=-xmjl-Hgu6lKqkCAXq_6U8_aJX6gvaMgLMLdCt-Ej7o,3006
 velocity/db/servers/sqlserver.py,sha256=0uGLEWRXiUhrOVTpEA1zvaKq1mcfiaCDp9r7gX-N71g,29914
 velocity/db/servers/sqlserver_reserved.py,sha256=3LGQYU0qfvk6AbKety96gbzzfLbZ0dNHDPLxKGvvi4Q,4596
-velocity/db/servers/tablehelper.py,sha256=S_759UBIqj-xn6IzwIu6wU7QSrUdLtg0-T80j23m23Y,22016
+velocity/db/servers/tablehelper.py,sha256=qOHHKgQgUC0t_AUcY5oaPfjkRJS9wnMI4YJCDIb9Rew,22583
 velocity/db/servers/postgres/__init__.py,sha256=FUvXO3R5CtKCTGRim1geisIxXbiG_aQ_VFSQX9HGsjw,529
 velocity/db/servers/postgres/operators.py,sha256=A2T1qFwhzPl0fdXVhLZJhh5Qfx-qF8oZsDnxnq2n_V8,389
 velocity/db/servers/postgres/reserved.py,sha256=5tKLaqFV-HrWRj-nsrxl5KGbmeM3ukn_bPZK36XEu8M,3648
-velocity/db/servers/postgres/sql.py,sha256=dDUcdErrAgWulrr6582p4Zf1co6-PH8MfVU2q9KRisI,41416
+velocity/db/servers/postgres/sql.py,sha256=hQugqzYuLWPCDpN1Tdt6CSYRTZHpG9aBc0GPagkmGYw,41581
 velocity/db/servers/postgres/types.py,sha256=Wa45ppVf_pdWul-jYWFRGMl6IdSq8dAp10SKnhL7osQ,3757
 velocity/misc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 velocity/misc/db.py,sha256=MPgt-kkukKR_Wh_S_5W-MyDgaeoZ4YLoDJ54wU2ppm4,2830
@@ -47,8 +47,8 @@ velocity/misc/tools.py,sha256=_bGneHHA_BV-kUonzw5H3hdJ5AOJRCKfzhgpkFbGqIo,1502
 velocity/misc/conv/__init__.py,sha256=MLYF58QHjzfDSxb1rdnmLnuEQCa3gnhzzZ30CwZVvQo,40
 velocity/misc/conv/iconv.py,sha256=d4_BucW8HTIkGNurJ7GWrtuptqUf-9t79ObzjJ5N76U,10603
 velocity/misc/conv/oconv.py,sha256=h5Lo05DqOQnxoD3y6Px_MQP_V-pBbWf8Hkgkb9Xp1jk,6032
-velocity_python-0.0.97.dist-info/licenses/LICENSE,sha256=aoN245GG8s9oRUU89KNiGTU4_4OtnNmVi4hQeChg6rM,1076
-velocity_python-0.0.97.dist-info/METADATA,sha256=vQvxtwSQIBj6yC8li-uFlArx8F6IqyhMd3oH4sXB8go,33022
-velocity_python-0.0.97.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-velocity_python-0.0.97.dist-info/top_level.txt,sha256=JW2vJPmodgdgSz7H6yoZvnxF8S3fTMIv-YJWCT1sNW0,9
-velocity_python-0.0.97.dist-info/RECORD,,
+velocity_python-0.0.100.dist-info/licenses/LICENSE,sha256=aoN245GG8s9oRUU89KNiGTU4_4OtnNmVi4hQeChg6rM,1076
+velocity_python-0.0.100.dist-info/METADATA,sha256=01JZ2yuzUG3D5VpFz6ArpooG_VEO0Wl87ENZ0bu-2VQ,33023
+velocity_python-0.0.100.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+velocity_python-0.0.100.dist-info/top_level.txt,sha256=JW2vJPmodgdgSz7H6yoZvnxF8S3fTMIv-YJWCT1sNW0,9
+velocity_python-0.0.100.dist-info/RECORD,,