velocity-python 0.1.38__tar.gz → 0.1.39__tar.gz

{velocity_python-0.1.38/src/velocity_python.egg-info → velocity_python-0.1.39}/PKG-INFO

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

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

{velocity_python-0.1.38 → velocity_python-0.1.39}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.1.38"
+__version__ = version = "0.1.39"
 
 import importlib as _importlib
 

{velocity_python-0.1.38 → velocity_python-0.1.39}/src/velocity/db/core/table.py

@@ -155,6 +155,12 @@ def _normalize_identifier(value):
     return str(value or "").strip().strip('"').lower()
 
 
+def _normalize_referential_action(value):
+    if not value:
+        return "NO ACTION"
+    return " ".join(str(value).strip().upper().split())
+
+
 def _split_sql_expressions(text):
     expressions = []
     current = []
@@ -267,12 +273,14 @@ def _normalize_index_specs(indexes, *, unique_default=False):
             direction = definition.get("direction")
             where = definition.get("where")
             lower = definition.get("lower")
+            name = definition.get("name")
         else:
             columns = definition
             unique = unique_default
             direction = None
             where = None
             lower = None
+            name = None
 
         if isinstance(columns, str):
             columns = [column.strip() for column in columns.split(",") if column.strip()]
@@ -288,6 +296,7 @@ def _normalize_index_specs(indexes, *, unique_default=False):
                 "direction": direction,
                 "where": where,
                 "lower": lower,
+                "name": _normalize_identifier(name) if name else None,
             }
         )
 
@@ -315,6 +324,9 @@ def _normalize_foreign_key_specs(foreign_keys):
             raise ValueError("Foreign key definition requires ref_table")
 
         ref_columns = definition.get("ref_columns") or definition.get("key_to_columns") or "sys_id"
+        name = definition.get("name")
+        on_delete = _normalize_referential_action(definition.get("on_delete"))
+        on_update = _normalize_referential_action(definition.get("on_update"))
 
         if isinstance(columns, str):
             columns = [column.strip() for column in columns.split(",") if column.strip()]
@@ -337,6 +349,9 @@ def _normalize_foreign_key_specs(foreign_keys):
                 "ref_columns": tuple(
                     _normalize_identifier(column) for column in ref_columns
                 ),
+                "name": _normalize_identifier(name) if name else None,
+                "on_delete": on_delete,
+                "on_update": on_update,
             }
         )
 
@@ -430,7 +445,14 @@ class Table:
 
     @return_default(None, (exceptions.DbObjectExistsError,))
     def create_index(
-        self, columns, unique=False, direction=None, where=None, lower=None, **kwds
+        self,
+        columns,
+        unique=False,
+        direction=None,
+        where=None,
+        lower=None,
+        name=None,
+        **kwds,
     ):
         """
         Creates an index on the given columns. Returns None on success, or `None` if the index already exists.
@@ -445,6 +467,7 @@ class Table:
             direction=direction,
             where=where,
             lower=lower,
+            name=name,
         )
         if kwds.get("sql_only", False):
             return sql, vals
@@ -484,6 +507,7 @@ class Table:
                     "direction": definition.get("direction"),
                     "where": definition.get("where"),
                     "lower": definition.get("lower"),
+                    "name": definition.get("name"),
                 }
             else:
                 columns = definition
@@ -492,6 +516,7 @@ class Table:
                     "direction": None,
                     "where": None,
                     "lower": None,
+                    "name": None,
                 }
 
             if isinstance(columns, str):
@@ -558,6 +583,7 @@ class Table:
             direction=spec["direction"],
             where=spec["where"],
             lower=spec["lower"],
+            name=spec["name"],
             sql_only=True,
         )
         return _parse_index_signature(sql)
@@ -594,6 +620,8 @@ class Table:
                         _normalize_identifier(item["referenced_column_name"])
                         for item in ordered
                     ),
+                    "on_delete": _normalize_referential_action(first.get("delete_rule")),
+                    "on_update": _normalize_referential_action(first.get("update_rule")),
                 }
             )
         return signatures
@@ -710,6 +738,7 @@ class Table:
                 summary["skipped_indexes"].append(
                     {
                         "columns": list(spec["columns"]),
+                        "name": spec["name"],
                         "reason": message,
                     }
                 )
@@ -719,6 +748,7 @@ class Table:
                 summary["skipped_indexes"].append(
                     {
                         "columns": list(spec["columns"]),
+                        "name": spec["name"],
                         "reason": "create_missing_indexes is disabled",
                     }
                 )
@@ -732,11 +762,13 @@ class Table:
                     direction=spec["direction"],
                     where=spec["where"],
                     lower=spec["lower"],
+                    name=spec["name"],
                 )
                 summary["created_indexes"].append(
                     {
                         "columns": list(spec["columns"]),
                         "unique": spec["unique"],
+                        "name": spec["name"],
                     }
                 )
                 existing_indexes = self._existing_index_signatures()
@@ -750,6 +782,7 @@ class Table:
                 summary["skipped_indexes"].append(
                     {
                         "columns": list(spec["columns"]),
+                        "name": spec["name"],
                         "reason": message,
                     }
                 )
@@ -763,12 +796,40 @@ class Table:
                     if existing["columns"] == spec["columns"]
                     and existing["ref_table"] == spec["ref_table"]
                     and existing["ref_columns"] == spec["ref_columns"]
+                    and existing["on_delete"] == spec["on_delete"]
+                    and existing["on_update"] == spec["on_update"]
                 ),
                 None,
             )
             if exact_match:
                 continue
 
+            name_conflict = None
+            if spec["name"]:
+                name_conflict = next(
+                    (
+                        existing
+                        for existing in existing_foreign_keys
+                        if existing["constraint_name"] == spec["name"]
+                    ),
+                    None,
+                )
+            if name_conflict:
+                message = (
+                    f"Foreign key '{spec['name']}' on table '{self.name}' exists "
+                    "with a different definition."
+                )
+                if on_existing_conflicts == "raise":
+                    raise exceptions.DbSchemaConflictError(message)
+                summary["skipped_foreign_keys"].append(
+                    {
+                        "columns": list(spec["columns"]),
+                        "name": spec["name"],
+                        "reason": message,
+                    }
+                )
+                continue
+
             column_conflict = next(
                 (
                     existing
@@ -780,13 +841,14 @@ class Table:
             if column_conflict:
                 message = (
                     f"Foreign key on table '{self.name}' for columns {spec['columns']} "
-                    "exists with a different target."
+                    "exists with a different target or referential action."
                 )
                 if on_existing_conflicts == "raise":
                     raise exceptions.DbSchemaConflictError(message)
                 summary["skipped_foreign_keys"].append(
                     {
                         "columns": list(spec["columns"]),
+                        "name": spec["name"],
                         "reason": message,
                     }
                 )
@@ -796,6 +858,7 @@ class Table:
                 summary["skipped_foreign_keys"].append(
                     {
                         "columns": list(spec["columns"]),
+                        "name": spec["name"],
                         "reason": "create_missing_foreign_keys is disabled",
                     }
                 )
@@ -806,12 +869,18 @@ class Table:
                 list(spec["columns"]),
                 spec["ref_table"],
                 list(spec["ref_columns"]),
+                name=spec["name"],
+                on_delete=spec["on_delete"],
+                on_update=spec["on_update"],
             )
             summary["created_foreign_keys"].append(
                 {
                     "columns": list(spec["columns"]),
                     "ref_table": spec["ref_table"],
                     "ref_columns": list(spec["ref_columns"]),
+                    "name": spec["name"],
+                    "on_delete": spec["on_delete"],
+                    "on_update": spec["on_update"],
                 }
             )
             existing_foreign_keys = self._existing_foreign_key_signatures()
@@ -1124,25 +1193,53 @@ class Table:
 
     @return_default()
     def create_foreign_key(
-        self, columns, key_to_table, key_to_columns="sys_id", **kwds
+        self,
+        columns,
+        key_to_table,
+        key_to_columns="sys_id",
+        name=None,
+        on_delete=None,
+        on_update=None,
+        **kwds,
     ):
         """
         Creates a foreign key referencing `key_to_table(key_to_columns)`.
         """
         sql, vals = self.sql.create_foreign_key(
-            self.name, columns, key_to_table, key_to_columns
+            self.name,
+            columns,
+            key_to_table,
+            key_to_columns,
+            name=name,
+            on_delete=on_delete,
+            on_update=on_update,
         )
         if kwds.get("sql_only", False):
             return sql, vals
         _ddl_logger.warning("DDL CREATE FOREIGN KEY on %s columns=%s ref=%s(%s)", self.name, columns, key_to_table, key_to_columns)
         return self.tx.execute(sql, vals, cursor=self.cursor())
 
-    def drop_foreign_key(self, columns, key_to_table, key_to_columns="sys_id", **kwds):
+    def drop_foreign_key(
+        self,
+        columns,
+        key_to_table,
+        key_to_columns="sys_id",
+        name=None,
+        on_delete=None,
+        on_update=None,
+        **kwds,
+    ):
         """
         Drops the specified foreign key constraint.
         """
-        sql, vals = self.sql.create_foreign_key(
-            self.name, columns, key_to_table, key_to_columns
+        sql, vals = self.sql.drop_foreign_key(
+            self.name,
+            columns,
+            key_to_table,
+            key_to_columns,
+            name=name,
+            on_delete=on_delete,
+            on_update=on_update,
         )
         if kwds.get("sql_only", False):
             return sql, vals

{velocity_python-0.1.38 → velocity_python-0.1.39}/src/velocity/db/servers/base/sql.py

@@ -407,6 +407,8 @@ class BaseSQLDialect(ABC):
         key_to_columns: List[str],
         name: Optional[str] = None,
         schema: Optional[str] = None,
+        on_delete: Optional[str] = None,
+        on_update: Optional[str] = None,
     ) -> str:
         """Generate CREATE FOREIGN KEY statement."""
         pass
@@ -421,6 +423,8 @@ class BaseSQLDialect(ABC):
         key_to_columns: Optional[List[str]] = None,
         name: Optional[str] = None,
         schema: Optional[str] = None,
+        on_delete: Optional[str] = None,
+        on_update: Optional[str] = None,
     ) -> str:
         """Generate DROP FOREIGN KEY statement."""
         pass

{velocity_python-0.1.38 → velocity_python-0.1.39}/src/velocity/db/servers/mysql/sql.py

@@ -654,7 +654,15 @@ END;
 
     @classmethod
     def create_foreign_key(
-        cls, table, columns, key_to_table, key_to_columns, name=None, schema=None
+        cls,
+        table,
+        columns,
+        key_to_table,
+        key_to_columns,
+        name=None,
+        schema=None,
+        on_delete=None,
+        on_update=None,
     ):
         if name is None:
             name = f"fk_{table}_{'_'.join(columns)}"
@@ -662,12 +670,17 @@ END;
         col_list = ", ".join(quote(col) for col in columns)
         ref_col_list = ", ".join(quote(col) for col in key_to_columns)
 
-        return f"""
+        sql = f"""
         ALTER TABLE {quote(table)}
         ADD CONSTRAINT {quote(name)}
         FOREIGN KEY ({col_list})
         REFERENCES {quote(key_to_table)} ({ref_col_list})
         """
+        if on_delete:
+            sql += f" ON DELETE {str(on_delete).upper()}"
+        if on_update:
+            sql += f" ON UPDATE {str(on_update).upper()}"
+        return sql
 
     @classmethod
     def drop_foreign_key(
@@ -678,6 +691,8 @@ END;
         key_to_columns=None,
         name=None,
         schema=None,
+        on_delete=None,
+        on_update=None,
     ):
         if name is None:
             name = f"fk_{table}_{'_'.join(columns)}"

{velocity_python-0.1.38 → velocity_python-0.1.39}/src/velocity/db/servers/postgres/sql.py

@@ -1461,6 +1461,8 @@ class SQL(BaseSQLDialect):
            , KCU2.CONSTRAINT_SCHEMA AS "REFERENCED_TABLE_SCHEMA"
            , KCU2.TABLE_NAME AS "REFERENCED_TABLE_NAME"
            , KCU2.COLUMN_NAME AS "REFERENCED_COLUMN_NAME"
+              , RC.UPDATE_RULE AS "UPDATE_RULE"
+              , RC.DELETE_RULE AS "DELETE_RULE"
         FROM INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS RC
         JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE KCU1
         ON KCU1.CONSTRAINT_CATALOG = RC.CONSTRAINT_CATALOG
@@ -1495,7 +1497,15 @@ class SQL(BaseSQLDialect):
 
     @classmethod
     def create_foreign_key(
-        cls, table, columns, key_to_table, key_to_columns, name=None, schema=None
+        cls,
+        table,
+        columns,
+        key_to_table,
+        key_to_columns,
+        name=None,
+        schema=None,
+        on_delete=None,
+        on_update=None,
     ):
         if "." not in table and schema:
             table = f"{schema}.{table}"
@@ -1510,7 +1520,15 @@ class SQL(BaseSQLDialect):
             m.update(key_to_table.encode("utf-8"))
             m.update(" ".join(key_to_columns).encode("utf-8"))
             name = f"FK_{m.hexdigest()}"
-        sql = f"ALTER TABLE {table} ADD CONSTRAINT {name} FOREIGN KEY ({','.join(columns)}) REFERENCES {key_to_table} ({','.join(key_to_columns)});"
+        sql = (
+            f"ALTER TABLE {table} ADD CONSTRAINT {name} FOREIGN KEY ({','.join(columns)}) "
+            f"REFERENCES {key_to_table} ({','.join(key_to_columns)})"
+        )
+        if on_delete:
+            sql += f" ON DELETE {str(on_delete).upper()}"
+        if on_update:
+            sql += f" ON UPDATE {str(on_update).upper()}"
+        sql += ";"
         sql = sqlparse.format(sql, reindent=True, keyword_case="upper")
         return sql, tuple()
 
@@ -1523,6 +1541,8 @@ class SQL(BaseSQLDialect):
         key_to_columns=None,
         name=None,
         schema=None,
+        on_delete=None,
+        on_update=None,
     ):
         if "." not in table and schema:
             table = f"{schema}.{table}"
@@ -1576,10 +1596,11 @@ class SQL(BaseSQLDialect):
                 "",
                 columns.replace(" ", "").replace(",", "_").replace('"', ""),
             )
-        if trigram:
-            sql.append(f"IDX__TRGM_{table.replace('.', '_')}_{trigram}__{name}".upper())
-        else:
-            sql.append(f"IDX__{table.replace('.', '_')}__{name}".upper())
+            if trigram:
+                name = f"IDX__TRGM_{table.replace('.', '_')}_{trigram}__{name}".upper()
+            else:
+                name = f"IDX__{table.replace('.', '_')}__{name}".upper()
+        sql.append(name)
         sql.append("ON")
         sql.append(TableHelper.quote(tablename))
 
@@ -1633,10 +1654,11 @@ class SQL(BaseSQLDialect):
                 "",
                 columns.replace(" ", "").replace(",", "_").replace('"', ""),
             )
-        if trigram:
-            sql.append(f"IDX__TRGM_{table.replace('.', '_')}_{trigram.upper()}__{name}")
-        else:
-            sql.append(f"IDX__{table.replace('.', '_')}__{name}")
+            if trigram:
+                name = f"IDX__TRGM_{table.replace('.', '_')}_{trigram.upper()}__{name}"
+            else:
+                name = f"IDX__{table.replace('.', '_')}__{name}"
+        sql.append(name)
 
         sql = sqlparse.format(" ".join(sql), reindent=True, keyword_case="upper")
         return sql, tuple()

{velocity_python-0.1.38 → velocity_python-0.1.39}/src/velocity/db/servers/sqlite/sql.py

@@ -593,7 +593,15 @@ END;
 
     @classmethod
     def create_foreign_key(
-        cls, table, columns, key_to_table, key_to_columns, name=None, schema=None
+        cls,
+        table,
+        columns,
+        key_to_table,
+        key_to_columns,
+        name=None,
+        schema=None,
+        on_delete=None,
+        on_update=None,
     ):
         # SQLite foreign keys must be defined at table creation time
         return "-- SQLite foreign keys must be defined at table creation"
@@ -607,6 +615,8 @@ END;
         key_to_columns=None,
         name=None,
         schema=None,
+        on_delete=None,
+        on_update=None,
     ):
         return "-- SQLite foreign keys must be dropped by recreating table"
 

{velocity_python-0.1.38 → velocity_python-0.1.39}/src/velocity/db/servers/sqlserver/sql.py

@@ -733,7 +733,15 @@ END;
 
     @classmethod
     def create_foreign_key(
-        cls, table, columns, key_to_table, key_to_columns, name=None, schema=None
+        cls,
+        table,
+        columns,
+        key_to_table,
+        key_to_columns,
+        name=None,
+        schema=None,
+        on_delete=None,
+        on_update=None,
     ):
         if name is None:
             name = f"FK_{table}_{'_'.join(columns)}"
@@ -741,12 +749,17 @@ END;
         col_list = ", ".join(quote(col) for col in columns)
         ref_col_list = ", ".join(quote(col) for col in key_to_columns)
 
-        return f"""
+        sql = f"""
         ALTER TABLE {quote(table)}
         ADD CONSTRAINT {quote(name)}
         FOREIGN KEY ({col_list})
         REFERENCES {quote(key_to_table)} ({ref_col_list})
         """
+        if on_delete:
+            sql += f" ON DELETE {str(on_delete).upper()}"
+        if on_update:
+            sql += f" ON UPDATE {str(on_update).upper()}"
+        return sql
 
     @classmethod
     def drop_foreign_key(
@@ -757,6 +770,8 @@ END;
         key_to_columns=None,
         name=None,
         schema=None,
+        on_delete=None,
+        on_update=None,
     ):
         if name is None:
             name = f"FK_{table}_{'_'.join(columns)}"

{velocity_python-0.1.38 → velocity_python-0.1.39}/src/velocity/db/tests/postgres/test_schema_locking.py

@@ -253,6 +253,71 @@ class TestSchemaLocking(unittest.TestCase):
 
         run()
 
+    def test_ensure_schema_supports_named_indexes_and_foreign_keys(self):
+        """ensure_schema should preserve explicit names and referential actions."""
+        unlocked_engine = postgres.initialize(
+            database=test_db, schema_locked=False, pool_enabled=False
+        )
+
+        @unlocked_engine.transaction
+        def run(tx):
+            tx.table("schema_departments").ensure_schema(columns={"name": str})
+
+            summary = tx.table("schema_memberships").ensure_schema(
+                columns={
+                    "email": str,
+                    "status": str,
+                    "department_id": int,
+                },
+                unique_indexes=[
+                    {"columns": ["email"], "name": "schema_memberships_email_uq"}
+                ],
+                indexes=[
+                    {"columns": ["status"], "name": "schema_memberships_status_idx"}
+                ],
+                foreign_keys=[
+                    {
+                        "columns": ["department_id"],
+                        "ref_table": "schema_departments",
+                        "ref_columns": ["sys_id"],
+                        "name": "schema_memberships_department_fk",
+                        "on_delete": "cascade",
+                    }
+                ],
+                create_missing_foreign_keys=True,
+            )
+
+            self.assertEqual(summary["created_indexes"][0]["name"], "schema_memberships_email_uq")
+            self.assertEqual(summary["created_foreign_keys"][0]["name"], "schema_memberships_department_fk")
+            self.assertEqual(summary["created_foreign_keys"][0]["on_delete"], "CASCADE")
+
+            index_names = {
+                row["indexname"].lower()
+                for row in tx.execute(
+                    """
+                    SELECT indexname
+                    FROM pg_indexes
+                    WHERE schemaname = 'public' AND tablename = %s
+                    """,
+                    ["schema_memberships"],
+                ).as_dict().all()
+            }
+            self.assertIn("schema_memberships_email_uq", index_names)
+            self.assertIn("schema_memberships_status_idx", index_names)
+
+            fk_rules = tx.execute(
+                """
+                SELECT constraint_name, delete_rule
+                FROM information_schema.referential_constraints
+                WHERE constraint_name = %s
+                """,
+                ["schema_memberships_department_fk"],
+            ).as_dict().all()
+            self.assertEqual(len(fk_rules), 1)
+            self.assertEqual(fk_rules[0]["delete_rule"], "CASCADE")
+
+        run()
+
     def test_ensure_schema_raises_schema_conflict_for_duplicate_unique_rows(self):
         """ensure_schema should raise a schema conflict when unique index backfill finds duplicates."""
         unlocked_engine = postgres.initialize(

{velocity_python-0.1.38 → velocity_python-0.1.39/src/velocity_python.egg-info}/PKG-INFO

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