velocity-python 0.1.43__tar.gz → 0.1.45__tar.gz

{velocity_python-0.1.43/src/velocity_python.egg-info → velocity_python-0.1.45}/PKG-INFO

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

{velocity_python-0.1.43 → velocity_python-0.1.45}/pyproject.toml

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

{velocity_python-0.1.43 → velocity_python-0.1.45}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.1.43"
+__version__ = version = "0.1.45"
 
 import importlib as _importlib
 

{velocity_python-0.1.43 → velocity_python-0.1.45}/src/velocity/db/core/table.py

@@ -234,6 +234,63 @@ def _normalize_index_expression(expression):
     return normalized.strip().lower()
 
 
+def _split_top_level_boolean_terms(expression):
+    parts = []
+    operators = []
+    start = 0
+    depth = 0
+    position = 0
+    while position < len(expression):
+        char = expression[position]
+        if char == "(":
+            depth += 1
+            position += 1
+            continue
+        if char == ")":
+            depth = max(0, depth - 1)
+            position += 1
+            continue
+        if depth == 0:
+            lowered = expression[position:].lower()
+            for operator in (" and ", " or "):
+                if lowered.startswith(operator):
+                    parts.append(expression[start:position].strip())
+                    operators.append(operator.strip())
+                    position += len(operator)
+                    start = position
+                    break
+            else:
+                position += 1
+            continue
+        position += 1
+
+    if operators:
+        parts.append(expression[start:].strip())
+
+    return parts, operators
+
+
+def _normalize_index_where_clause(expression):
+    normalized = _normalize_index_expression(expression)
+    parts, operators = _split_top_level_boolean_terms(normalized)
+    if not operators:
+        return normalized
+
+    simplified_parts = []
+    for part in parts:
+        stripped = _strip_redundant_outer_parens(part)
+        nested_parts, nested_operators = _split_top_level_boolean_terms(stripped)
+        if nested_operators:
+            simplified_parts.append(part)
+        else:
+            simplified_parts.append(stripped)
+
+    combined = [simplified_parts[0]]
+    for operator, part in zip(operators, simplified_parts[1:]):
+        combined.extend([operator, part])
+    return " ".join(combined).strip()
+
+
 def _parse_index_signature(index_sql):
     normalized_sql = " ".join(str(index_sql or "").split())
     upper_sql = normalized_sql.upper()
@@ -257,7 +314,7 @@ def _parse_index_signature(index_sql):
     where_clause = None
     where_pos = upper_sql.find(" WHERE ", closing_index)
     if where_pos != -1:
-        where_clause = _normalize_index_expression(normalized_sql[where_pos + 7 :])
+        where_clause = _normalize_index_where_clause(normalized_sql[where_pos + 7 :])
 
     return {
         "name": index_name,
@@ -686,16 +743,23 @@ class Table:
         return signatures
 
     def _desired_index_signature(self, spec):
-        sql, _vals = self.create_index(
-            spec["columns"],
-            unique=spec["unique"],
-            direction=spec["direction"],
-            where=spec["where"],
-            lower=spec["lower"],
-            name=spec["name"],
-            sql_only=True,
-        )
-        return _parse_index_signature(sql)
+        columns = []
+        for column_name in spec["columns"]:
+            normalized_column = _normalize_identifier(column_name)
+            if spec.get("lower"):
+                normalized_column = f"lower({normalized_column})"
+            columns.append(normalized_column)
+
+        return {
+            "name": _normalize_identifier(spec.get("name")) if spec.get("name") else None,
+            "unique": bool(spec.get("unique")),
+            "columns": tuple(columns),
+            "where": (
+                _normalize_index_where_clause(spec.get("where"))
+                if spec.get("where")
+                else None
+            ),
+        }
 
     def _existing_foreign_key_signatures(self):
         sql, vals = self.sql.foreign_key_info(table=self.name, column=None)

{velocity_python-0.1.43 → velocity_python-0.1.45}/src/velocity/db/servers/tablehelper.py

@@ -196,6 +196,17 @@ class TableHelper:
 
         alias = self.get_table_alias("current_table")
         if not self.has_pointer(column):
+            raw_expression = self.remove_operator(key).strip()
+            if column.upper() in self.reserved and re.search(
+                r"(?i)\bcase\s+when\b|\bexists\s*\(|\bselect\b|\bfrom\b|\bwhere\b",
+                raw_expression,
+            ):
+                if options.get("bypass_on_error"):
+                    return key
+                raise ValueError(
+                    f"Could not safely resolve complex SQL expression: {key}"
+                )
+
             # Standard column - no pointer syntax
             if (
                 options.get("alias_table")

{velocity_python-0.1.43 → velocity_python-0.1.45}/src/velocity/db/tests/test_tablehelper.py

@@ -198,6 +198,29 @@ class TestTableHelper(unittest.TestCase):
                     f"Failed for '{input_expr}': expected '{expected}', got '{result}'",
                 )
 
+    def test_resolve_references_preserves_complex_case_exists_expression(self):
+        """Complex CASE/EXISTS expressions should remain raw when not safely rewritable."""
+        original_reserved = TableHelper.reserved
+        TableHelper.reserved = ["CASE", "WHEN", "THEN", "ELSE", "END", "EXISTS"]
+        try:
+            expr = """coalesce(sum(case when exists (
+                select 1
+                from donor_users du
+                where lower(du.email_address) = lower(swipegive_settings.email_address)
+                  and lower(coalesce(nullif(du.plaid_status, ''), 'ready')) not in ('error', 'purged')
+              ) then 1 else 0 end), 0) as active"""
+            result = self.helper.resolve_references(
+                expr,
+                options={
+                    "alias_column": True,
+                    "alias_table": True,
+                    "bypass_on_error": True,
+                },
+            )
+            self.assertEqual(result, expr)
+        finally:
+            TableHelper.reserved = original_reserved
+
     def test_extract_column_name_cast_expressions(self):
         """Test extracting column names from CAST expressions"""
         test_cases = [

{velocity_python-0.1.43 → velocity_python-0.1.45/src/velocity_python.egg-info}/PKG-INFO

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

{velocity_python-0.1.43 → velocity_python-0.1.45}/tests/test_table_alter.py

@@ -558,6 +558,54 @@ class TableAlterTests(unittest.TestCase):
             _parse_index_signature(desired),
         )
 
+    def test_parse_index_signature_ignores_redundant_boolean_term_parentheses(self):
+        existing = (
+            "CREATE INDEX idx_pending_transactions_scheduled_capture_at "
+            "ON public.pending_transactions USING btree (scheduled_capture_at) "
+            "WHERE ((status = 'authorized'::text) AND (captured_at IS NULL) AND "
+            "(canceled_at IS NULL))"
+        )
+        desired = (
+            "CREATE INDEX idx_pending_transactions_scheduled_capture_at "
+            "ON pending_transactions (scheduled_capture_at) "
+            "WHERE status = 'authorized' AND captured_at IS NULL AND canceled_at IS NULL"
+        )
+
+        self.assertEqual(
+            _parse_index_signature(existing),
+            _parse_index_signature(desired),
+        )
+
+    def test_desired_index_signature_allows_system_columns_not_in_declared_spec(self):
+        table = FakeTable(
+            PostgresSQL,
+            {
+                "product_sys_id": {"type": "BIGINT", "nullable": False},
+            },
+        )
+
+        signature = Table._desired_index_signature(
+            table,
+            {
+                "name": "idx_inventory_ledger_product_sys_id_sys_id",
+                "columns": ["product_sys_id", "sys_id"],
+                "unique": False,
+                "direction": None,
+                "where": None,
+                "lower": None,
+            },
+        )
+
+        self.assertEqual(
+            signature,
+            {
+                "name": "idx_inventory_ledger_product_sys_id_sys_id",
+                "unique": False,
+                "columns": ("product_sys_id", "sys_id"),
+                "where": None,
+            },
+        )
+
 
 if __name__ == "__main__":
     unittest.main()