velocity-python 0.0.154__tar.gz → 0.0.156__tar.gz

{velocity_python-0.0.154 → velocity_python-0.0.156}/PKG-INFO

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

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

{velocity_python-0.0.154 → velocity_python-0.0.156}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.154"
+__version__ = version = "0.0.156"
 
 from . import aws
 from . import db

{velocity_python-0.0.154 → velocity_python-0.0.156}/src/velocity/db/core/engine.py

@@ -1,10 +1,10 @@
 import inspect
 import re
-import os
 from contextlib import contextmanager
 from functools import wraps
 from velocity.db import exceptions
 from velocity.db.core.transaction import Transaction
+from velocity.db.utils import mask_config_for_display
 
 import logging
 
@@ -27,7 +27,8 @@ class Engine:
         self.__schema_locked = schema_locked
 
     def __str__(self):
-        return f"[{self.sql.server}] engine({self.config})"
+        safe_config = mask_config_for_display(self.config)
+        return f"[{self.sql.server}] engine({safe_config})"
 
     def connect(self):
         """

{velocity_python-0.0.154 → velocity_python-0.0.156}/src/velocity/db/core/table.py

@@ -24,7 +24,24 @@ class Query:
         return self.sql
 
 
+SYSTEM_COLUMN_NAMES = (
+    "sys_id",
+    "sys_created",
+    "sys_modified",
+    "sys_modified_by",
+    "sys_modified_row",
+    "sys_modified_count",
+    "sys_dirty",
+    "sys_table",
+    "description",
+)
+
+_SYSTEM_COLUMN_SET = {name.lower() for name in SYSTEM_COLUMN_NAMES}
+
+
 class Table:
+    SYSTEM_COLUMNS = SYSTEM_COLUMN_NAMES
+
     """
     Provides an interface for performing CRUD and metadata operations on a DB table.
     """
@@ -94,9 +111,15 @@ class Table:
 
     def columns(self):
         """
-        Returns column names, excluding columns that start with 'sys_'.
+        Returns non-system column names.
         """
-        return [col for col in self.sys_columns() if not col.startswith("sys_")]
+        return [col for col in self.sys_columns() if not self.is_system_column(col)]
+
+    @staticmethod
+    def is_system_column(column_name):
+        if not column_name:
+            return False
+        return column_name.lower() in _SYSTEM_COLUMN_SET or column_name.lower().startswith("sys_")
 
     @return_default(None, (exceptions.DbObjectExistsError,))
     def create_index(
@@ -217,12 +240,8 @@ class Table:
             return self.name in [f"{x[0]}.{x[1]}" for x in result.as_tuple()]
         return self.name in [x[1] for x in result.as_tuple()]
 
-    def ensure_sys_modified_count(self, **kwds):
-        """
-        Ensure the sys_modified_count column and trigger exist for this table.
-
-        Returns early when the column is already present unless `force=True` is provided.
-        """
+    def ensure_system_columns(self, **kwds):
+        """Ensure Velocity system columns and triggers exist for this table."""
         force = kwds.get("force", False)
 
         try:
@@ -230,15 +249,21 @@ class Table:
         except Exception:
             columns = []
 
-        has_column = "sys_modified_count" in columns
-        has_row_column = "sys_modified_row" in columns
+        sql_method = getattr(self.sql, "ensure_system_columns", None)
 
-        if has_column and has_row_column and not force:
-            return
+        if sql_method is None:
+            raise AttributeError(
+                f"{self.sql.__class__.__name__} does not implement ensure_system_columns"
+            )
 
-        sql, vals = self.sql.ensure_sys_modified_count(
-            self.name, has_column=has_column, has_row_column=has_row_column
+        result = sql_method(
+            self.name, existing_columns=columns, force=force
         )
+
+        if not result:
+            return
+
+        sql, vals = result
         if kwds.get("sql_only", False):
             return sql, vals
         self.tx.execute(sql, vals, cursor=self.cursor())

{velocity_python-0.0.154 → velocity_python-0.0.156}/src/velocity/db/core/transaction.py

@@ -6,6 +6,7 @@ from velocity.db.core.result import Result
 from velocity.db.core.column import Column
 from velocity.db.core.database import Database
 from velocity.db.core.sequence import Sequence
+from velocity.db.utils import mask_config_for_display
 from velocity.misc.db import randomword
 
 debug = False
@@ -22,10 +23,14 @@ class Transaction:
         self.__pg_types = {}
 
     def __str__(self):
-        c = self.engine.config
-        server = c.get("host", c.get("server"))
-        database = c.get("database")
-        return f"{self.engine.sql.server}.transaction({server}:{database})"
+        config = mask_config_for_display(self.engine.config)
+
+        if isinstance(config, dict):
+            server = config.get("host", config.get("server"))
+            database = config.get("database", config.get("dbname"))
+            return f"{self.engine.sql.server}.transaction({server}:{database})"
+
+        return f"{self.engine.sql.server}.transaction({config})"
 
     def __enter__(self):
         return self

{velocity_python-0.0.154 → velocity_python-0.0.156}/src/velocity/db/servers/mysql/sql.py

@@ -450,19 +450,40 @@ END;
         return "\n".join(statements), tuple()
 
     @classmethod
-    def ensure_sys_modified_count(cls, name, has_column=False, has_row_column=False):
-        """Ensure sys_modified_count column and associated triggers exist for the table."""
+    def ensure_system_columns(cls, name, existing_columns=None, force=False):
+        """Ensure MySQL tables maintain the Velocity system metadata."""
+        existing_columns = {col.lower() for col in existing_columns or []}
+
         table_identifier = quote(name)
         base_name = name.split(".")[-1].replace("`", "")
         base_name_sql = base_name.replace("'", "''")
         trigger_prefix = re.sub(r"[^0-9A-Za-z_]+", "_", f"cc_sysmod_{base_name}")
 
-        statements = [
-            f"ALTER TABLE {table_identifier} ADD COLUMN IF NOT EXISTS `sys_modified_count` INT NOT NULL DEFAULT 0;",
-            f"UPDATE {table_identifier} SET `sys_modified_count` = 0 WHERE `sys_modified_count` IS NULL;",
-            f"DROP TRIGGER IF EXISTS {trigger_prefix}_bi;",
-            f"DROP TRIGGER IF EXISTS {trigger_prefix}_bu;",
-            f"""
+        has_count = "sys_modified_count" in existing_columns
+
+        add_column = not has_count
+        recreate_triggers = force or add_column
+
+        if not recreate_triggers and not force:
+            return None
+
+        statements = []
+
+        if add_column:
+            statements.append(
+                f"ALTER TABLE {table_identifier} ADD COLUMN IF NOT EXISTS `sys_modified_count` INT NOT NULL DEFAULT 0;"
+            )
+
+        statements.append(
+            f"UPDATE {table_identifier} SET `sys_modified_count` = 0 WHERE `sys_modified_count` IS NULL;"
+        )
+
+        statements.append(f"DROP TRIGGER IF EXISTS {trigger_prefix}_bi;")
+        statements.append(f"DROP TRIGGER IF EXISTS {trigger_prefix}_bu;")
+
+        statements.extend(
+            [
+                f"""
 CREATE TRIGGER {trigger_prefix}_bi
 BEFORE INSERT ON {table_identifier}
 FOR EACH ROW
@@ -474,7 +495,7 @@ BEGIN
     SET NEW.sys_table = '{base_name_sql}';
 END;
 """.strip(),
-            f"""
+                f"""
 CREATE TRIGGER {trigger_prefix}_bu
 BEFORE UPDATE ON {table_identifier}
 FOR EACH ROW
@@ -491,7 +512,8 @@ BEGIN
     SET NEW.sys_table = '{base_name_sql}';
 END;
 """.strip(),
-        ]
+            ]
+        )
 
         return "\n".join(statements), tuple()
 

{velocity_python-0.0.154 → velocity_python-0.0.156}/src/velocity/db/servers/postgres/sql.py

@@ -23,6 +23,8 @@ system_fields = [
     "sys_created",
     "sys_modified",
     "sys_modified_by",
+    "sys_modified_row",
+    "sys_modified_count",
     "sys_dirty",
     "sys_table",
     "description",
@@ -799,37 +801,13 @@ class SQL(BaseSQLDialect):
     def drop_database(cls, name):
         return f"drop database if exists {name}", tuple()
 
-    @classmethod
-    def create_table(cls, name, columns={}, drop=False):
-        if "." in name:
-            fqtn = TableHelper.quote(name)
-        else:
-            fqtn = f"public.{TableHelper.quote(name)}"
-        schema, table = fqtn.split(".")
-        name = fqtn.replace(".", "_")
-        sql = []
-        if drop:
-            sql.append(cls.drop_table(fqtn)[0])
-        sql.append(
-            f"""
-            CREATE TABLE {fqtn} (
-              sys_id BIGSERIAL PRIMARY KEY,
-              sys_created TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-              sys_modified TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-              sys_modified_by TEXT NOT NULL DEFAULT 'SYSTEM',
-              sys_modified_row TIMESTAMP NOT NULL DEFAULT CLOCK_TIMESTAMP(),
-              sys_modified_count INTEGER NOT NULL DEFAULT 0,
-              sys_dirty BOOLEAN NOT NULL DEFAULT FALSE,
-              sys_table TEXT NOT NULL,
-              description TEXT
-            );
-
-            SELECT SETVAL(PG_GET_SERIAL_SEQUENCE('{fqtn}', 'sys_id'),1000,TRUE);
-
-            CREATE OR REPLACE FUNCTION {schema}.on_sys_modified()
+    @staticmethod
+    def _sys_modified_function_sql(schema_identifier):
+        return f"""
+            CREATE OR REPLACE FUNCTION {schema_identifier}.on_sys_modified()
               RETURNS TRIGGER AS
             $BODY$
-                BEGIN
+            BEGIN
                 IF (TG_OP = 'INSERT') THEN
                     NEW.sys_table := TG_TABLE_NAME;
                     NEW.sys_created := transaction_timestamp();
@@ -847,19 +825,58 @@ class SQL(BaseSQLDialect):
                             NEW.sys_dirty := TRUE;
                         END IF;
                         NEW.sys_modified := transaction_timestamp();
+                        NEW.sys_modified_row := clock_timestamp();
                         NEW.sys_modified_count := COALESCE(OLD.sys_modified_count, 0) + 1;
                     END IF;
                 END IF;
-                
                 RETURN NEW;
-                END;
+            END;
             $BODY$
               LANGUAGE plpgsql VOLATILE
               COST 100;
+        """
+
+    @classmethod
+    def create_table(cls, name, columns={}, drop=False):
+        if "." in name:
+            fqtn = TableHelper.quote(name)
+        else:
+            fqtn = f"public.{TableHelper.quote(name)}"
 
-            CREATE TRIGGER on_update_row_{fqtn.replace('.', '_')}
+        schema, table = fqtn.split(".")
+        schema_unquoted = schema.replace('"', "")
+        table_unquoted = table.replace('"', "")
+        trigger_name = (
+            f"on_update_row_{schema_unquoted}_{table_unquoted}".replace(".", "_")
+        )
+        trigger_identifier = TableHelper.quote(trigger_name)
+        schema_identifier = TableHelper.quote(schema_unquoted)
+        sql = []
+        if drop:
+            sql.append(cls.drop_table(fqtn)[0])
+        sql.append(
+            f"""
+            CREATE TABLE {fqtn} (
+              sys_id BIGSERIAL PRIMARY KEY,
+              sys_created TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+              sys_modified TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+              sys_modified_by TEXT NOT NULL DEFAULT 'SYSTEM',
+              sys_modified_row TIMESTAMP NOT NULL DEFAULT CLOCK_TIMESTAMP(),
+              sys_modified_count INTEGER NOT NULL DEFAULT 0,
+              sys_dirty BOOLEAN NOT NULL DEFAULT FALSE,
+              sys_table TEXT NOT NULL,
+              description TEXT
+            );
+
+            SELECT SETVAL(PG_GET_SERIAL_SEQUENCE('{fqtn}', 'sys_id'),1000,TRUE);
+
+            {cls._sys_modified_function_sql(schema_identifier)}
+
+            DROP TRIGGER IF EXISTS {trigger_identifier} ON {fqtn};
+
+            CREATE TRIGGER {trigger_identifier}
             BEFORE INSERT OR UPDATE ON {fqtn}
-            FOR EACH ROW EXECUTE PROCEDURE {schema}.on_sys_modified();
+            FOR EACH ROW EXECUTE PROCEDURE {schema_identifier}.on_sys_modified();
 
         """
         )
@@ -876,81 +893,138 @@ class SQL(BaseSQLDialect):
         return sql, tuple()
 
     @classmethod
-    def ensure_sys_modified_count(
-        cls, name, has_column=False, has_row_column=False
-    ):
-        """Return SQL to backfill sys_modified_count/sys_modified_row and refresh the on_sys_modified trigger."""
+    def ensure_system_columns(cls, name, existing_columns=None, force=False):
+        """Ensure all Velocity system columns and triggers exist for the table."""
+        existing_columns = {
+            col.lower() for col in (existing_columns or [])
+        }
+
+        required_columns = [
+            "sys_id",
+            "sys_created",
+            "sys_modified",
+            "sys_modified_by",
+            "sys_modified_row",
+            "sys_modified_count",
+            "sys_dirty",
+            "sys_table",
+            "description",
+        ]
+
+        missing_columns = [
+            column for column in required_columns if column not in existing_columns
+        ]
+
+        if not missing_columns and not force:
+            return None
+
         if "." in name:
             schema_name, table_name = name.split(".", 1)
         else:
             schema_name = cls.default_schema
             table_name = name
 
-        schema_identifier = TableHelper.quote(schema_name)
-        table_identifier = TableHelper.quote(table_name)
+        schema_unquoted = schema_name.replace('"', "")
+        table_unquoted = table_name.replace('"', "")
+
+        schema_identifier = TableHelper.quote(schema_unquoted)
+        table_identifier = TableHelper.quote(table_unquoted)
         fqtn = f"{schema_identifier}.{table_identifier}"
 
         trigger_name = (
-            f"on_update_row_{schema_name}_{table_name}"
-            .replace(".", "_")
-            .replace('"', "")
+            f"on_update_row_{schema_unquoted}_{table_unquoted}".replace(".", "_")
         )
         trigger_identifier = TableHelper.quote(trigger_name)
-        column_name = TableHelper.quote("sys_modified_count")
-        row_column_name = TableHelper.quote("sys_modified_row")
-        
+
         statements = []
-        if not has_column:
+        added_columns = set()
+        columns_after = set(existing_columns)
+
+        if "sys_id" in missing_columns:
             statements.append(
-                f"ALTER TABLE {fqtn} ADD COLUMN {column_name} INTEGER NOT NULL DEFAULT 0;"
+                f"ALTER TABLE {fqtn} ADD COLUMN {TableHelper.quote('sys_id')} BIGSERIAL PRIMARY KEY;"
             )
-        if not has_row_column:
+            added_columns.add("sys_id")
+            columns_after.add("sys_id")
+
+        column_definitions = {
+            "sys_created": "TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP",
+            "sys_modified": "TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP",
+            "sys_modified_by": "TEXT NOT NULL DEFAULT 'SYSTEM'",
+            "sys_modified_row": "TIMESTAMP NOT NULL DEFAULT CLOCK_TIMESTAMP()",
+            "sys_modified_count": "INTEGER NOT NULL DEFAULT 0",
+            "sys_dirty": "BOOLEAN NOT NULL DEFAULT FALSE",
+            "sys_table": "TEXT",
+            "description": "TEXT",
+        }
+
+        for column, definition in column_definitions.items():
+            if column in missing_columns:
+                statements.append(
+                    f"ALTER TABLE {fqtn} ADD COLUMN {TableHelper.quote(column)} {definition};"
+                )
+                added_columns.add(column)
+                columns_after.add(column)
+
+        default_map = {
+            "sys_created": "CURRENT_TIMESTAMP",
+            "sys_modified": "CURRENT_TIMESTAMP",
+            "sys_modified_by": "'SYSTEM'",
+            "sys_modified_row": "CLOCK_TIMESTAMP()",
+            "sys_modified_count": "0",
+            "sys_dirty": "FALSE",
+        }
+
+        for column, default_sql in default_map.items():
+            if column in columns_after and (force or column in added_columns):
+                quoted_column = TableHelper.quote(column)
+                statements.append(
+                    f"UPDATE {fqtn} SET {quoted_column} = {default_sql} WHERE {quoted_column} IS NULL;"
+                )
+                statements.append(
+                    f"ALTER TABLE {fqtn} ALTER COLUMN {quoted_column} SET DEFAULT {default_sql};"
+                )
+
+        if "sys_table" in columns_after and (force or "sys_table" in added_columns):
+            quoted_column = TableHelper.quote("sys_table")
+            table_literal = table_unquoted.replace("'", "''")
             statements.append(
-                f"ALTER TABLE {fqtn} ADD COLUMN {row_column_name} TIMESTAMPTZ;"
+                f"UPDATE {fqtn} SET {quoted_column} = COALESCE({quoted_column}, '{table_literal}') WHERE {quoted_column} IS NULL;"
             )
 
-        statements.extend([
-            f"UPDATE {fqtn} SET {column_name} = 0 WHERE {column_name} IS NULL;",
-            f"UPDATE {fqtn} SET {row_column_name} = COALESCE({row_column_name}, clock_timestamp());",
-            f"""
-            CREATE OR REPLACE FUNCTION {schema_identifier}.on_sys_modified()
-              RETURNS TRIGGER AS
-            $BODY$
-            BEGIN
-                IF (TG_OP = 'INSERT') THEN
-                    NEW.sys_table := TG_TABLE_NAME;
-                    NEW.sys_created := transaction_timestamp();
-                    NEW.sys_modified := transaction_timestamp();
-                    NEW.sys_modified_row := clock_timestamp();
-                    NEW.sys_modified_count := 0;
-                ELSIF (TG_OP = 'UPDATE') THEN
-                    NEW.sys_table := TG_TABLE_NAME;
-                    NEW.sys_created := OLD.sys_created;
-                    NEW.sys_modified_count := COALESCE(OLD.sys_modified_count, 0);
-                    IF ROW(NEW.*) IS DISTINCT FROM ROW(OLD.*) THEN
-                        IF OLD.sys_dirty IS TRUE AND NEW.sys_dirty IS FALSE THEN
-                            NEW.sys_dirty := FALSE;
-                        ELSE
-                            NEW.sys_dirty := TRUE;
-                        END IF;
-                        NEW.sys_modified := transaction_timestamp();
-                        NEW.sys_modified_row := clock_timestamp();
-                        NEW.sys_modified_count := COALESCE(OLD.sys_modified_count, 0) + 1;
-                    END IF;
-                END IF;
-                RETURN NEW;
-            END;
-            $BODY$
-              LANGUAGE plpgsql VOLATILE
-              COST 100;
-        """,
-            f"DROP TRIGGER IF EXISTS {trigger_identifier} ON {fqtn};",
-            f"""
-            CREATE TRIGGER {trigger_identifier}
-            BEFORE INSERT OR UPDATE ON {fqtn}
-            FOR EACH ROW EXECUTE PROCEDURE {schema_identifier}.on_sys_modified();
-        """,
-        ])
+        not_null_columns = {
+            "sys_created",
+            "sys_modified",
+            "sys_modified_by",
+            "sys_modified_row",
+            "sys_modified_count",
+            "sys_dirty",
+            "sys_table",
+        }
+
+        for column in not_null_columns:
+            if column in columns_after and (force or column in added_columns):
+                statements.append(
+                    f"ALTER TABLE {fqtn} ALTER COLUMN {TableHelper.quote(column)} SET NOT NULL;"
+                )
+
+        reset_trigger = force or bool(added_columns)
+
+        if reset_trigger:
+            statements.append(
+                f"DROP TRIGGER IF EXISTS {trigger_identifier} ON {fqtn};"
+            )
+            statements.append(cls._sys_modified_function_sql(schema_identifier))
+            statements.append(
+                f"""
+                CREATE TRIGGER {trigger_identifier}
+                BEFORE INSERT OR UPDATE ON {fqtn}
+                FOR EACH ROW EXECUTE PROCEDURE {schema_identifier}.on_sys_modified();
+            """
+            )
+
+        if not statements:
+            return None
 
         sql = sqlparse.format(
             " ".join(statements), reindent=True, keyword_case="upper"

{velocity_python-0.0.154 → velocity_python-0.0.156}/src/velocity/db/servers/sqlite/sql.py

@@ -431,18 +431,40 @@ END;
         return "\n".join(statements), tuple()
 
     @classmethod
-    def ensure_sys_modified_count(cls, name, has_column=False, has_row_column=False):
-        """Ensure sys_modified_count exists for SQLite tables."""
+    def ensure_system_columns(cls, name, existing_columns=None, force=False):
+        """Ensure SQLite tables maintain the Velocity system triggers/columns."""
+        existing_columns = {col.lower() for col in existing_columns or []}
+
         table_identifier = quote(name)
         base_name = name.split(".")[-1].replace('"', "")
         base_name_sql = base_name.replace("'", "''")
         trigger_prefix = re.sub(r"[^0-9A-Za-z_]+", "_", f"cc_sysmod_{base_name}")
-        statements = [
-            f"ALTER TABLE {table_identifier} ADD COLUMN sys_modified_count INTEGER NOT NULL DEFAULT 0;",
-            f"UPDATE {table_identifier} SET sys_modified_count = 0 WHERE sys_modified_count IS NULL;",
-            f"DROP TRIGGER IF EXISTS {trigger_prefix}_ai;",
-            f"DROP TRIGGER IF EXISTS {trigger_prefix}_au;",
-            f"""
+
+        has_count = "sys_modified_count" in existing_columns
+
+        add_column = not has_count
+        recreate_triggers = force or add_column
+
+        if not recreate_triggers and not force:
+            return None
+
+        statements = []
+
+        if add_column:
+            statements.append(
+                f"ALTER TABLE {table_identifier} ADD COLUMN sys_modified_count INTEGER NOT NULL DEFAULT 0;"
+            )
+
+        statements.append(
+            f"UPDATE {table_identifier} SET sys_modified_count = 0 WHERE sys_modified_count IS NULL;"
+        )
+
+        statements.append(f"DROP TRIGGER IF EXISTS {trigger_prefix}_ai;")
+        statements.append(f"DROP TRIGGER IF EXISTS {trigger_prefix}_au;")
+
+        statements.extend(
+            [
+                f"""
 CREATE TRIGGER {trigger_prefix}_ai
 AFTER INSERT ON {table_identifier}
 FOR EACH ROW
@@ -456,7 +478,7 @@ BEGIN
     WHERE rowid = NEW.rowid;
 END;
 """.strip(),
-            f"""
+                f"""
 CREATE TRIGGER {trigger_prefix}_au
 AFTER UPDATE ON {table_identifier}
 FOR EACH ROW
@@ -470,7 +492,9 @@ BEGIN
     WHERE rowid = NEW.rowid;
 END;
 """.strip(),
-        ]
+            ]
+        )
+
         return "\n".join(statements), tuple()
 
     @classmethod