velocity-python 0.0.137__tar.gz → 0.0.138__tar.gz

{velocity_python-0.0.137 → velocity_python-0.0.138}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.137
+Version: 0.0.138
 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.137 → velocity_python-0.0.138}/pyproject.toml

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

{velocity_python-0.0.137 → velocity_python-0.0.138}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.137"
+__version__ = version = "0.0.138"
 
 from . import aws
 from . import db

{velocity_python-0.0.137 → velocity_python-0.0.138}/src/velocity/db/core/engine.py

@@ -367,12 +367,34 @@ class Engine:
 
         msg = str(exception).strip().lower()
 
-        # Create enhanced error message with SQL query
+        # Create enhanced error message with SQL query and context
         enhanced_message = str(exception)
+        
+        # Add specific guidance for common WHERE clause errors
+        exception_str_lower = str(exception).lower()
+        if "argument of where must be type boolean" in exception_str_lower:
+            enhanced_message += (
+                "\n\n*** WHERE CLAUSE ERROR ***\n"
+                "This error typically occurs when a WHERE clause contains a bare value "
+                "instead of a proper boolean expression.\n"
+                "Common fixes:\n"
+                "  - Change WHERE 1001 to WHERE sys_id = 1001\n"
+                "  - Change WHERE {'column': value} format in dictionaries\n"
+                "  - Ensure string WHERE clauses are complete SQL expressions"
+            )
+        
         if sql:
             enhanced_message += (
                 f"\n\nSQL Query:\n{self._format_sql_with_params(sql, parameters)}"
             )
+            
+        # Add call stack context for better debugging
+        import traceback
+        stack_trace = traceback.format_stack()
+        # Get the last few frames that aren't in the error handling itself
+        relevant_frames = [frame for frame in stack_trace if 'process_error' not in frame and 'logging' not in frame][-3:]
+        if relevant_frames:
+            enhanced_message += "\n\nCall Context:\n" + "".join(relevant_frames)
 
         # Format SQL for logging
         formatted_sql_info = ""

{velocity_python-0.0.137 → velocity_python-0.0.138}/src/velocity/db/servers/postgres/sql.py

@@ -69,7 +69,7 @@ class SQL(BaseSQLDialect):
 
     default_schema = "public"
 
-    ApplicationErrorCodes = ["22P02", "42883", "42501", "42601", "25P01", "25P02"]
+    ApplicationErrorCodes = ["22P02", "42883", "42501", "42601", "25P01", "25P02", "42804"]  # Added 42804 for datatype mismatch
 
     DatabaseMissingErrorCodes = ["3D000"]
     TableMissingErrorCodes = ["42P01"]
@@ -296,23 +296,37 @@ class SQL(BaseSQLDialect):
         else:
             sql_parts["FROM"].append(TableHelper.quote(table))
 
-        # WHERE
+        # WHERE - Enhanced validation to prevent malformed SQL
         if where:
             if isinstance(where, str):
                 # Validate string WHERE clauses to prevent malformed SQL
-                if where.strip().isdigit() or where.strip() in ('True', 'False'):
+                where_stripped = where.strip()
+                if not where_stripped:
+                    raise ValueError("WHERE clause cannot be empty string.")
+                # Check for boolean literals first (includes '1' and '0')
+                if where_stripped in ('True', 'False', '1', '0'):
                     raise ValueError(
                         f"Invalid WHERE clause: '{where}'. "
-                        "String WHERE clauses must be complete SQL expressions, "
-                        "not bare values. Use a dictionary like {{'column': value}} instead."
+                        "Boolean literals alone are not valid WHERE clauses. "
+                        "Use complete SQL expressions like 'sys_active = true' instead."
+                    )
+                # Then check for other numeric values (excluding '1' and '0' already handled above)
+                elif where_stripped.isdigit():
+                    raise ValueError(
+                        f"Invalid WHERE clause: '{where}'. "
+                        "Bare integers are not valid WHERE clauses. "
+                        "Use a dictionary like {{'sys_id': {where_stripped}}} or "
+                        f"a complete SQL expression like 'sys_id = {where_stripped}' instead."
                     )
                 sql_parts["WHERE"].append(where)
             elif isinstance(where, (int, float, bool)):
                 # Handle primitive types that should be converted to proper WHERE clauses
+                suggested_fix = "{'sys_id': " + str(where) + "}" if isinstance(where, int) else "complete SQL expression"
                 raise ValueError(
                     f"Invalid WHERE clause: {where} (type: {type(where).__name__}). "
-                    "WHERE clauses must be dictionaries like {{'column': value}}, "
-                    "lists of tuples, or complete SQL strings."
+                    f"Primitive values cannot be WHERE clauses directly. "
+                    f"Use a dictionary like {suggested_fix} or a complete SQL string instead. "
+                    f"This error prevents PostgreSQL 'argument of WHERE must be type boolean' errors."
                 )
             elif isinstance(where, Mapping):
                 # Convert dictionary to predicate list
@@ -473,20 +487,34 @@ class SQL(BaseSQLDialect):
                         new_where.append(th.make_predicate(key, val))
                     where = new_where
                 elif isinstance(where, str):
-                    # Validate string WHERE clauses to prevent malformed SQL
-                    if where.strip().isdigit() or where.strip() in ('True', 'False'):
+                    # Enhanced validation for string WHERE clauses
+                    where_stripped = where.strip()
+                    if not where_stripped:
+                        raise ValueError("WHERE clause cannot be empty string.")
+                    # Check for boolean literals first (includes '1' and '0')
+                    if where_stripped in ('True', 'False', '1', '0'):
+                        raise ValueError(
+                            f"Invalid WHERE clause: '{where}'. "
+                            "Boolean literals alone are not valid WHERE clauses. "
+                            "Use complete SQL expressions like 'sys_active = true' instead."
+                        )
+                    # Then check for other numeric values (excluding '1' and '0' already handled above)
+                    elif where_stripped.isdigit():
                         raise ValueError(
                             f"Invalid WHERE clause: '{where}'. "
-                            "String WHERE clauses must be complete SQL expressions, "
-                            "not bare values. Use a dictionary like {{'column': value}} instead."
+                            "Bare integers are not valid WHERE clauses. "
+                            f"Use a dictionary like {{'sys_id': {where_stripped}}} or "
+                            f"a complete SQL expression like 'sys_id = {where_stripped}' instead."
                         )
                     where_clauses.append(where)
                 elif isinstance(where, (int, float, bool)):
                     # Handle primitive types that should be converted to proper WHERE clauses
+                    suggested_fix = "{'sys_id': " + str(where) + "}" if isinstance(where, int) else "complete SQL expression"
                     raise ValueError(
                         f"Invalid WHERE clause: {where} (type: {type(where).__name__}). "
-                        "WHERE clauses must be dictionaries like {{'column': value}}, "
-                        "lists of tuples, or complete SQL strings."
+                        f"Primitive values cannot be WHERE clauses directly. "
+                        f"Use a dictionary like {suggested_fix} or a complete SQL string instead. "
+                        f"This error prevents PostgreSQL 'argument of WHERE must be type boolean' errors."
                     )
                 
                 # Process the where clause if it's a list of tuples

{velocity_python-0.0.137 → velocity_python-0.0.138}/src/velocity_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.137
+Version: 0.0.138
 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.137 → velocity_python-0.0.138}/src/velocity_python.egg-info/SOURCES.txt

@@ -128,4 +128,5 @@ src/velocity_python.egg-info/PKG-INFO
 src/velocity_python.egg-info/SOURCES.txt
 src/velocity_python.egg-info/dependency_links.txt
 src/velocity_python.egg-info/requires.txt
-src/velocity_python.egg-info/top_level.txt
+src/velocity_python.egg-info/top_level.txt
+tests/test_where_clause_validation.py

velocity_python-0.0.138/tests/test_where_clause_validation.py

@@ -0,0 +1,198 @@
+#!/usr/bin/env python3
+"""
+Test cases for WHERE clause validation improvements.
+Tests the fixes for the PostgreSQL 'argument of WHERE must be type boolean' error.
+"""
+
+import unittest
+from unittest.mock import Mock, MagicMock
+from velocity.db.servers.postgres.sql import SQL
+from velocity.db import exceptions
+
+
+class TestWhereClauseValidation(unittest.TestCase):
+    """Test WHERE clause validation improvements."""
+
+    def setUp(self):
+        """Set up test fixtures."""
+        self.mock_tx = Mock()
+        self.mock_tx.table.return_value.primary_keys.return_value = ['sys_id']
+        
+        # Mock TableHelper methods
+        self.mock_helper = Mock()
+        self.mock_helper.resolve_references.return_value = "test_column"
+        self.mock_helper.make_predicate.return_value = ("test_column = %s", 123)
+        self.mock_helper.get_table_alias.return_value = "t1"
+        self.mock_helper.foreign_keys = {}
+        self.mock_helper.split_columns.return_value = ["column1", "column2"]
+        
+        # Patch TableHelper creation
+        import velocity.db.servers.postgres.sql as sql_module
+        sql_module._get_table_helper = Mock(return_value=self.mock_helper)
+
+    def test_invalid_where_bare_integer(self):
+        """Test that bare integers in WHERE clauses are rejected with helpful error."""
+        with self.assertRaises(ValueError) as cm:
+            SQL.select(self.mock_tx, table="test_table", where=1001)
+        
+        error_msg = str(cm.exception)
+        self.assertIn("Invalid WHERE clause: 1001", error_msg)
+        self.assertIn("Primitive values cannot be WHERE clauses directly", error_msg)
+        self.assertIn("{'sys_id': 1001}", error_msg)
+        self.assertIn("PostgreSQL 'argument of WHERE must be type boolean' errors", error_msg)
+
+    def test_invalid_where_string_integer(self):
+        """Test that string integers in WHERE clauses are rejected."""
+        with self.assertRaises(ValueError) as cm:
+            SQL.select(self.mock_tx, table="test_table", where="1001")
+        
+        error_msg = str(cm.exception)
+        self.assertIn("Invalid WHERE clause: '1001'", error_msg)
+        self.assertIn("Bare integers are not valid WHERE clauses", error_msg)
+        self.assertIn("sys_id = 1001", error_msg)
+
+    def test_invalid_where_boolean_literal(self):
+        """Test that boolean literals in WHERE clauses are rejected."""
+        test_cases = ["True", "False", "1", "0"]
+        
+        for bool_val in test_cases:
+            with self.subTest(bool_val=bool_val):
+                with self.assertRaises(ValueError) as cm:
+                    SQL.select(self.mock_tx, table="test_table", where=bool_val)
+                
+                error_msg = str(cm.exception)
+                self.assertIn(f"Invalid WHERE clause: '{bool_val}'", error_msg)
+                self.assertIn("Boolean literals alone are not valid WHERE clauses", error_msg)
+
+    def test_invalid_where_empty_string(self):
+        """Test that empty string WHERE clauses are rejected."""
+        with self.assertRaises(ValueError) as cm:
+            SQL.select(self.mock_tx, table="test_table", where="   ")
+        
+        error_msg = str(cm.exception)
+        self.assertIn("WHERE clause cannot be empty string", error_msg)
+
+    def test_invalid_where_float(self):
+        """Test that float values in WHERE clauses are rejected."""
+        with self.assertRaises(ValueError) as cm:
+            SQL.select(self.mock_tx, table="test_table", where=123.45)
+        
+        error_msg = str(cm.exception)
+        self.assertIn("Invalid WHERE clause: 123.45", error_msg)
+        self.assertIn("type: float", error_msg)
+
+    def test_invalid_where_boolean(self):
+        """Test that boolean values in WHERE clauses are rejected."""
+        with self.assertRaises(ValueError) as cm:
+            SQL.select(self.mock_tx, table="test_table", where=True)
+        
+        error_msg = str(cm.exception)
+        self.assertIn("Invalid WHERE clause: True", error_msg)
+        self.assertIn("type: bool", error_msg)
+
+    def test_valid_where_dictionary(self):
+        """Test that dictionary WHERE clauses work correctly."""
+        try:
+            sql, params = SQL.select(
+                self.mock_tx, 
+                table="test_table", 
+                where={"sys_id": 1001}
+            )
+            # Should not raise an exception
+            self.assertIsInstance(sql, str)
+            self.assertIsInstance(params, tuple)
+        except ValueError as e:
+            self.fail(f"Valid dictionary WHERE clause raised ValueError: {e}")
+
+    def test_valid_where_complete_sql_string(self):
+        """Test that complete SQL string WHERE clauses work correctly."""
+        try:
+            sql, params = SQL.select(
+                self.mock_tx, 
+                table="test_table", 
+                where="sys_id = 1001 AND sys_active = true"
+            )
+            # Should not raise an exception
+            self.assertIsInstance(sql, str)
+            self.assertIsInstance(params, tuple)
+        except ValueError as e:
+            self.fail(f"Valid SQL string WHERE clause raised ValueError: {e}")
+
+    def test_update_where_validation(self):
+        """Test that UPDATE method has the same WHERE validation."""
+        with self.assertRaises(ValueError) as cm:
+            SQL.update(
+                self.mock_tx, 
+                table="test_table", 
+                data={"name": "test"}, 
+                where=1001
+            )
+        
+        error_msg = str(cm.exception)
+        self.assertIn("Invalid WHERE clause: 1001", error_msg)
+        self.assertIn("PostgreSQL 'argument of WHERE must be type boolean' errors", error_msg)
+
+    def test_update_where_string_integer(self):
+        """Test UPDATE method rejects string integers."""
+        with self.assertRaises(ValueError) as cm:
+            SQL.update(
+                self.mock_tx, 
+                table="test_table", 
+                data={"name": "test"}, 
+                where="999"
+            )
+        
+        error_msg = str(cm.exception)
+        self.assertIn("Invalid WHERE clause: '999'", error_msg)
+        self.assertIn("Bare integers are not valid WHERE clauses", error_msg)
+
+
+class TestEnhancedErrorMessages(unittest.TestCase):
+    """Test enhanced error message functionality."""
+
+    def test_datatype_mismatch_error_enhancement(self):
+        """Test that datatype mismatch errors get enhanced messages."""
+        from velocity.db.core.engine import Engine
+        
+        # Create a mock exception that simulates the PostgreSQL error
+        mock_exception = Exception("argument of WHERE must be type boolean, not type integer")
+        
+        # Create an engine instance with mocked dependencies
+        mock_driver = Mock()
+        mock_config = Mock()
+        mock_sql = Mock()
+        # Set up the error code to trigger ApplicationError path
+        mock_sql.get_error.return_value = ("42804", "datatype mismatch")
+        mock_sql.ApplicationErrorCodes = ["42804"]
+        # Add all the other error code lists that the engine checks
+        mock_sql.ColumnMissingErrorCodes = []
+        mock_sql.TableMissingErrorCodes = []
+        mock_sql.DatabaseMissingErrorCodes = []
+        mock_sql.ForeignKeyMissingErrorCodes = []
+        mock_sql.TruncationErrorCodes = []
+        mock_sql.DataIntegrityErrorCodes = []
+        mock_sql.ConnectionErrorCodes = []
+        mock_sql.DuplicateKeyErrorCodes = []
+        mock_sql.DatabaseObjectExistsErrorCodes = []
+        mock_sql.LockTimeoutErrorCodes = []
+        mock_sql.RetryTransactionCodes = []
+        
+        engine = Engine(mock_driver, mock_config, mock_sql)
+        
+        # Mock the _format_sql_with_params method
+        engine._format_sql_with_params = Mock(return_value="SELECT * FROM test WHERE 1001")
+        
+        # Test that the error gets enhanced
+        with self.assertRaises(exceptions.DbApplicationError) as cm:
+            engine.process_error(mock_exception, "SELECT * FROM test WHERE 1001", [])
+        
+        error_msg = str(cm.exception)
+        # Verify the enhanced error message contains our WHERE clause help
+        self.assertIn("*** WHERE CLAUSE ERROR ***", error_msg)
+        self.assertIn("WHERE 1001 to WHERE sys_id = 1001", error_msg)
+        self.assertIn("SQL Query:", error_msg)
+        self.assertIn("Call Context:", error_msg)
+
+
+if __name__ == '__main__':
+    unittest.main()