velocity-python 0.0.153__py3-none-any.whl → 0.0.160__py3-none-any.whl

velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.153"
+__version__ = version = "0.0.160"
 
 from . import aws
 from . import db

velocity/aws/handlers/context.py

@@ -1,3 +1,4 @@
+import json
 import os
 import boto3
 import uuid
@@ -24,6 +25,8 @@ class Context:
         self.__aws_event = aws_event
         self.__aws_context = aws_context
         self.__log = log
+        self._job_record_cache = {}
+        self._job_cancelled_flag = False
 
     def postdata(self, keys=-1, default=None):
         if keys == -1:
@@ -87,9 +90,9 @@ class Context:
         if self.postdata("job_id"):
             # Sanitize data before storing in database
             sanitized_data = self._sanitize_job_data(data)
-            tx.table("aws_job_activity").update(
-                sanitized_data, {"job_id": self.postdata("job_id")}
-            )
+            job_id = self.postdata("job_id")
+            tx.table("aws_job_activity").update(sanitized_data, {"job_id": job_id})
+            self._job_record_cache.pop(job_id, None)
             tx.commit()
 
     def create_job(self, tx, job_data=None):
@@ -98,6 +101,9 @@ class Context:
             return
         sanitized_data = self._sanitize_job_data(job_data)
         tx.table("aws_job_activity").insert(sanitized_data)
+        job_id = sanitized_data.get("job_id")
+        if job_id:
+            self._job_record_cache.pop(job_id, None)
         tx.commit()
 
     def _sanitize_job_data(self, data):
@@ -183,6 +189,84 @@ class Context:
 
         return sanitized
 
+    def _get_job_record(self, tx, job_id=None, refresh=False):
+        job_id = job_id or self.postdata("job_id")
+        if not job_id:
+            return None
+
+        if refresh or job_id not in self._job_record_cache:
+            record = tx.table("aws_job_activity").find({"job_id": job_id})
+            if record is not None:
+                self._job_record_cache[job_id] = record
+            elif job_id in self._job_record_cache:
+                del self._job_record_cache[job_id]
+
+        return self._job_record_cache.get(job_id)
+
+    def is_job_cancel_requested(self, tx, force_refresh=False):
+        job = self._get_job_record(tx, refresh=force_refresh)
+        if not job:
+            return False
+
+        status = (job.get("status") or "").lower()
+        if status in {"cancelrequested", "cancelled"}:
+            return True
+
+        message_raw = job.get("message")
+        if not message_raw:
+            return False
+
+        if isinstance(message_raw, dict):
+            message = message_raw
+        else:
+            try:
+                message = json.loads(message_raw)
+            except (TypeError, ValueError, json.JSONDecodeError):
+                return False
+
+        return bool(message.get("cancel_requested") or message.get("cancelled"))
+
+    def mark_job_cancelled(self, tx, detail=None, requested_by=None):
+        job_id = self.postdata("job_id")
+        if not job_id:
+            return
+
+        job = self._get_job_record(tx, refresh=True) or {}
+        message_raw = job.get("message")
+        if isinstance(message_raw, dict):
+            message = dict(message_raw)
+        else:
+            try:
+                message = json.loads(message_raw) if message_raw else {}
+            except (TypeError, ValueError, json.JSONDecodeError):
+                message = {}
+
+        message.update(
+            {
+                "detail": detail or "Job cancelled",
+                "cancelled": True,
+            }
+        )
+
+        tx.table("aws_job_activity").update(
+            {
+                "status": "Cancelled",
+                "message": to_json(message),
+                "handler_complete_timestamp": datetime.now(),
+                "sys_modified": datetime.now(),
+                "sys_modified_by": requested_by
+                or self.session().get("email_address")
+                or "system",
+            },
+            {"job_id": job_id},
+        )
+        tx.commit()
+        self._job_record_cache.pop(job_id, None)
+        self._job_cancelled_flag = True
+
+    def was_job_cancelled(self):
+        return self._job_cancelled_flag
+
     def enqueue(self, action, payload={}, user=None, suppress_job_activity=False):
         """
         Enqueue jobs to SQS with independent job activity tracking.

velocity/db/core/decorators.py

@@ -4,10 +4,27 @@ from functools import wraps
 from velocity.db import exceptions
 
 
+_PRIMARY_KEY_PATTERNS = (
+    "primary key",
+    "key 'primary'",
+    'key "primary"',
+)
+
+
+def _is_primary_key_duplicate(error):
+    """Return True when the duplicate-key error is targeting the primary key."""
+
+    message = str(error or "")
+    lowered = message.lower()
+
+    if "sys_id" in lowered:
+        return True
+
+    return any(pattern in lowered for pattern in _PRIMARY_KEY_PATTERNS)
+
+
 def retry_on_dup_key(func):
-    """
-    Retries a function call if it raises DbDuplicateKeyError, up to max_retries.
-    """
+    """Retry when insert/update fails because the primary key already exists."""
 
     @wraps(func)
     def retry_decorator(self, *args, **kwds):
@@ -19,10 +36,12 @@ def retry_on_dup_key(func):
                 result = func(self, *args, **kwds)
                 self.tx.release_savepoint(sp, cursor=self.cursor())
                 return result
-            except exceptions.DbDuplicateKeyError:
+            except exceptions.DbDuplicateKeyError as error:
                 self.tx.rollback_savepoint(sp, cursor=self.cursor())
                 if "sys_id" in kwds.get("data", {}):
                     raise
+                if not _is_primary_key_duplicate(error):
+                    raise
                 retries += 1
                 if retries >= max_retries:
                     raise
@@ -34,9 +53,7 @@ def retry_on_dup_key(func):
 
 
 def reset_id_on_dup_key(func):
-    """
-    Wraps an INSERT/UPSERT to reset the sys_id sequence on duplicate key collisions.
-    """
+    """Retry sys_id sequence bump only when the primary key collides."""
 
     @wraps(func)
     def reset_decorator(self, *args, retries=0, **kwds):
@@ -45,10 +62,12 @@ def reset_id_on_dup_key(func):
             result = func(self, *args, **kwds)
             self.tx.release_savepoint(sp, cursor=self.cursor())
             return result
-        except exceptions.DbDuplicateKeyError:
+        except exceptions.DbDuplicateKeyError as error:
             self.tx.rollback_savepoint(sp, cursor=self.cursor())
             if "sys_id" in kwds.get("data", {}):
                 raise
+            if not _is_primary_key_duplicate(error):
+                raise
             if retries < 3:
                 backoff_time = (2**retries) * 0.01 + random.uniform(0, 0.02)
                 time.sleep(backoff_time)

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/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())
@@ -321,29 +346,65 @@ class Table:
         sys_id = self.tx.execute(sql, vals).scalar()
         return self.row(sys_id, lock=lock)
 
+    def _normalize_lookup_where(self, where):
+        if where is None:
+            raise Exception("None is not allowed as a primary key.")
+        if isinstance(where, Row):
+            return dict(where.pk)
+        if isinstance(where, int):
+            return {"sys_id": where}
+        if not isinstance(where, Mapping):
+            raise TypeError(
+                "Lookup criteria must be an int, Row, or mapping of column -> value."
+            )
+        return dict(where)
+
+    def _select_sys_ids(
+        self,
+        where,
+        *,
+        lock=None,
+        orderby=None,
+        skip_locked=None,
+        limit=2,
+    ):
+        select_kwargs = {
+            "where": where,
+            "lock": lock,
+            "orderby": orderby,
+            "skip_locked": skip_locked,
+        }
+        if limit is not None:
+            select_kwargs["qty"] = limit
+        return self.select("sys_id", **select_kwargs).all()
+
+    def _clean_where_for_insert(self, where):
+        clean = {}
+        for key, val in where.items():
+            if not isinstance(key, str):
+                continue
+            if set("<>!=%").intersection(key):
+                continue
+            clean.setdefault(key, val)
+        return clean
+
     def get(self, where, lock=None, use_where=False):
         """
         Gets or creates a row matching `where`. If multiple rows match, raises DuplicateRowsFoundError.
         If none match, a new row is created with the non-operator aspects of `where`.
         """
-        if where is None:
-            raise Exception("None is not allowed as a primary key.")
-        if isinstance(where, int):
-            where = {"sys_id": where}
-        result = self.select("sys_id", where=where, lock=lock).all()
+        lookup = self._normalize_lookup_where(where)
+        result = self._select_sys_ids(lookup, lock=lock, limit=2)
         if len(result) > 1:
-            sql = self.select("sys_id", sql_only=True, where=where, lock=lock)
+            sql = self.select("sys_id", sql_only=True, where=lookup, lock=lock)
             raise exceptions.DuplicateRowsFoundError(
                 f"More than one entry found. {sql}"
             )
         if not result:
-            new_data = where.copy()
-            for k in list(new_data.keys()):
-                if set("<>!=%").intersection(k):
-                    new_data.pop(k)
+            new_data = self._clean_where_for_insert(lookup)
             return self.new(new_data, lock=lock)
         if use_where:
-            return Row(self, where, lock=lock)
+            return Row(self, lookup, lock=lock)
         return Row(self, result[0]["sys_id"], lock=lock)
 
     @return_default(None)
@@ -352,24 +413,21 @@ class Table:
         Finds a single row matching `where`, or returns None if none found unless
         ``raise_if_missing`` is True. Raises DuplicateRowsFoundError if multiple rows match.
         """
-        if where is None:
-            raise Exception("None is not allowed as a primary key.")
-        if isinstance(where, int):
-            where = {"sys_id": where}
-        result = self.select("sys_id", where=where, lock=lock).all()
+        lookup = self._normalize_lookup_where(where)
+        result = self._select_sys_ids(lookup, lock=lock, limit=2)
         if not result:
             if raise_if_missing:
                 raise LookupError(
-                    f"No rows found in `{self.name}` for criteria: {where!r}"
+                    f"No rows found in `{self.name}` for criteria: {lookup!r}"
                 )
             return None
         if len(result) > 1:
-            sql = self.select("sys_id", sql_only=True, where=where, lock=lock)
+            sql = self.select("sys_id", sql_only=True, where=lookup, lock=lock)
             raise exceptions.DuplicateRowsFoundError(
                 f"More than one entry found. {sql}"
             )
         if use_where:
-            return Row(self, where, lock=lock)
+            return Row(self, lookup, lock=lock)
         return Row(self, result[0]["sys_id"], lock=lock)
 
     one = find
@@ -387,23 +445,21 @@ class Table:
         """
         Finds the first matching row (by `orderby`) or creates one if `create_new=True` and none found.
         """
-        if where is None:
-            raise Exception("None is not allowed as a where clause.")
-        if isinstance(where, int):
-            where = {"sys_id": where}
-        results = self.select(
-            "sys_id", where=where, orderby=orderby, skip_locked=skip_locked
-        ).all()
+        lookup = self._normalize_lookup_where(where)
+        results = self._select_sys_ids(
+            lookup,
+            lock=lock,
+            orderby=orderby,
+            skip_locked=skip_locked,
+            limit=1,
+        )
         if not results:
             if create_new:
-                new_data = where.copy()
-                for k in list(new_data.keys()):
-                    if set("<>!=%").intersection(k):
-                        new_data.pop(k)
+                new_data = self._clean_where_for_insert(lookup)
                 return self.new(new_data, lock=lock)
             return None
         if use_where:
-            return Row(self, where, lock=lock)
+            return Row(self, lookup, lock=lock)
         return Row(self, results[0]["sys_id"], lock=lock)
 
     def primary_keys(self):
@@ -484,10 +540,8 @@ class Table:
         if not isinstance(columns, dict):
             raise Exception("Columns must be a dict.")
         columns = self.lower_keys(columns)
-        diff = []
-        for k in columns.keys():
-            if k not in self.sys_columns():
-                diff.append(k)
+        existing_columns = {col.lower() for col in self.sys_columns()}
+        diff = [col for col in columns.keys() if col not in existing_columns]
         if diff:
             newcols = {key: columns[key] for key in diff}
             sql, vals = self.sql.alter_add(self.name, newcols)

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/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/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/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

velocity/db/servers/sqlserver/sql.py

@@ -485,10 +485,10 @@ 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 SQL Server tables along with maintenance triggers."""
+    def ensure_system_columns(cls, name, existing_columns=None, force=False):
+        """Ensure SQL Server tables maintain Velocity system metadata."""
+        existing_columns = {col.lower() for col in existing_columns or []}
+
         if "." in name:
             schema, table_name = name.split(".", 1)
         else:
@@ -501,17 +501,35 @@ END;
         table_name_sql = table_name.replace("'", "''")
         trigger_prefix = re.sub(r"[^0-9A-Za-z_]+", "_", f"CC_SYS_MOD_{table_name}")
 
+        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 not has_column:
+
+        if add_column:
             statements.append(
                 f"IF COL_LENGTH(N'{object_name}', 'sys_modified_count') IS NULL BEGIN ALTER TABLE {table_identifier} ADD sys_modified_count INT NOT NULL CONSTRAINT DF_{trigger_prefix}_COUNT DEFAULT (0); END;"
             )
 
-        statements.extend([
-            f"UPDATE {table_identifier} SET sys_modified_count = 0 WHERE sys_modified_count IS NULL;",
-            f"IF OBJECT_ID(N'{schema_identifier}.{trigger_prefix}_insert', N'TR') IS NOT NULL DROP TRIGGER {schema_identifier}.{trigger_prefix}_insert;",
-            f"IF OBJECT_ID(N'{schema_identifier}.{trigger_prefix}_update', N'TR') IS NOT NULL DROP TRIGGER {schema_identifier}.{trigger_prefix}_update;",
-            f"""
+        statements.append(
+            f"UPDATE {table_identifier} SET sys_modified_count = 0 WHERE sys_modified_count IS NULL;"
+        )
+
+        statements.append(
+            f"IF OBJECT_ID(N'{schema_identifier}.{trigger_prefix}_insert', N'TR') IS NOT NULL DROP TRIGGER {schema_identifier}.{trigger_prefix}_insert;"
+        )
+        statements.append(
+            f"IF OBJECT_ID(N'{schema_identifier}.{trigger_prefix}_update', N'TR') IS NOT NULL DROP TRIGGER {schema_identifier}.{trigger_prefix}_update;"
+        )
+
+        statements.extend(
+            [
+                f"""
 CREATE TRIGGER {schema_identifier}.{trigger_prefix}_insert
 ON {table_identifier}
 AFTER INSERT
@@ -528,7 +546,7 @@ BEGIN
     INNER JOIN inserted AS i ON t.sys_id = i.sys_id;
 END;
 """.strip(),
-            f"""
+                f"""
 CREATE TRIGGER {schema_identifier}.{trigger_prefix}_update
 ON {table_identifier}
 AFTER UPDATE
@@ -546,7 +564,8 @@ BEGIN
     INNER JOIN deleted AS d ON d.sys_id = i.sys_id;
 END;
 """.strip(),
-        ])
+            ]
+        )
 
         return "\n".join(statements), tuple()
 

velocity/db/tests/postgres/test_table_comprehensive.py

@@ -199,7 +199,9 @@ class TestTableComprehensive(CommonPostgresTest):
         
         # Test column filtering (non-sys columns)
         filtered_columns = table.columns()
-        sys_column_count = len([col for col in filtered_columns if col.startswith("sys_")])
+        sys_column_count = len(
+            [col for col in filtered_columns if table.is_system_column(col)]
+        )
         self.assertEqual(sys_column_count, 0)
 
     def test_table_row_count(self, tx):

velocity/db/tests/test_db_utils.py

@@ -11,6 +11,8 @@ from src.velocity.db.utils import (
     safe_sort_rows,
     group_by_fields,
     safe_sort_grouped_rows,
+    mask_config_for_display,
+    mask_sensitive_in_string,
 )
 
 
@@ -216,6 +218,53 @@ class TestDatabaseUtils(unittest.TestCase):
         expected = ["2024-06", "2024-12", None]
         self.assertEqual(exp_dates, expected)
 
+    def test_mask_config_for_display_redacts_direct_passwords(self):
+        """Ensure direct password/token fields are masked."""
+        config = {
+            "host": "db.local",
+            "password": "supersecret",
+            "token": "abc123",
+        }
+
+        masked = mask_config_for_display(config)
+
+        self.assertEqual(masked["host"], "db.local")
+        self.assertEqual(masked["password"], "*****")
+        self.assertEqual(masked["token"], "*****")
+
+    def test_mask_config_for_display_handles_nested_structures(self):
+        """Verify masking applies to nested dicts, lists, tuples, and DSN strings."""
+        config = {
+            "options": {
+                "passwd": "innersecret",
+                "hosts": [
+                    {"url": "postgresql://user:pwd@localhost/db"},
+                    ("token=xyz",),
+                ],
+            }
+        }
+
+        masked = mask_config_for_display(config)
+
+        self.assertEqual(masked["options"]["passwd"], "*****")
+        self.assertEqual(
+            masked["options"]["hosts"][0]["url"],
+            "postgresql://user:*****@localhost/db",
+        )
+        self.assertEqual(masked["options"]["hosts"][1][0], "token=*****")
+
+    def test_mask_sensitive_in_string_redacts_key_value_pairs(self):
+        """Key/value DSN parameters should be redacted."""
+        dsn = "host=db password=abc123;user=test"
+        masked = mask_sensitive_in_string(dsn)
+        self.assertEqual(masked, "host=db password=*****;user=test")
+
+    def test_mask_sensitive_in_string_redacts_url_credentials(self):
+        """URL style credentials should hide the password portion."""
+        url = "postgresql://user:secret@host/db"
+        masked = mask_sensitive_in_string(url)
+        self.assertEqual(masked, "postgresql://user:*****@host/db")
+
 
 if __name__ == "__main__":
     unittest.main()

velocity/db/utils.py

@@ -1,12 +1,75 @@
-"""
-Database utility functions for common operations.
+"""Utility helpers for velocity.db modules.
 
-This module provides utility functions to handle common database operations
-safely, including sorting with None values and other edge cases.
+This module provides helpers for redacting sensitive configuration values along
+with common collection utilities used across the velocity database codebase.
 """
 
+import re
 from typing import Any, Callable, List
 
+_SENSITIVE_KEYWORDS = {
+    "password",
+    "passwd",
+    "pwd",
+    "secret",
+    "token",
+    "apikey",
+    "api_key",
+}
+
+_SENSITIVE_PATTERNS = [
+    re.compile(r"(password\s*=\s*)([^\s;]+)", re.IGNORECASE),
+    re.compile(r"(passwd\s*=\s*)([^\s;]+)", re.IGNORECASE),
+    re.compile(r"(pwd\s*=\s*)([^\s;]+)", re.IGNORECASE),
+    re.compile(r"(secret\s*=\s*)([^\s;]+)", re.IGNORECASE),
+    re.compile(r"(token\s*=\s*)([^\s;]+)", re.IGNORECASE),
+    re.compile(r"(api[_-]?key\s*=\s*)([^\s;]+)", re.IGNORECASE),
+]
+
+_URL_CREDENTIAL_PATTERN = re.compile(r"(://[^:\s]+:)([^@/\s]+)")
+
+
+def mask_sensitive_in_string(value: str) -> str:
+    """Return ``value`` with credential-like substrings redacted."""
+
+    if not value:
+        return value
+
+    masked = value
+    for pattern in _SENSITIVE_PATTERNS:
+        masked = pattern.sub(lambda match: match.group(1) + "*****", masked)
+
+    return _URL_CREDENTIAL_PATTERN.sub(r"\1*****", masked)
+
+
+def mask_config_for_display(config: Any) -> Any:
+    """Return ``config`` with common secret fields masked for logging/str()."""
+
+    if isinstance(config, dict):
+        masked = {}
+        for key, value in config.items():
+            if isinstance(key, str) and _contains_sensitive_keyword(key):
+                masked[key] = "*****"
+            else:
+                masked[key] = mask_config_for_display(value)
+        return masked
+
+    if isinstance(config, tuple):
+        return tuple(mask_config_for_display(item) for item in config)
+
+    if isinstance(config, list):
+        return [mask_config_for_display(item) for item in config]
+
+    if isinstance(config, str):
+        return mask_sensitive_in_string(config)
+
+    return config
+
+
+def _contains_sensitive_keyword(key: str) -> bool:
+    lowered = key.lower()
+    return any(token in lowered for token in _SENSITIVE_KEYWORDS)
+
 
 def safe_sort_key_none_last(field_name: str) -> Callable[[dict], tuple]:
     """

{velocity_python-0.0.153.dist-info → velocity_python-0.0.160.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.153
+Version: 0.0.160
 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.153.dist-info → velocity_python-0.0.160.dist-info}/RECORD

@@ -1,4 +1,4 @@
-velocity/__init__.py,sha256=9s-bNUFexw6PJX1-0uXQBwF6tuficIqPpR43ZzohYyo,147
+velocity/__init__.py,sha256=t8R519NPfB30baxwfHpQFR_kMmzXUu0_bglALFT14QM,147
 velocity/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 velocity/app/invoices.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 velocity/app/orders.py,sha256=C7ewngMpO8nD3ul_82o4FhZBdRkWvJtnuEbEJUKDCno,6151
@@ -12,7 +12,7 @@ velocity/aws/__init__.py,sha256=0nEsX68Q4I7Z7ybECJnNWsC8QhWOijn4NpaFgyzyfXA,685
 velocity/aws/amplify.py,sha256=VgSgon0XxboIozz0tKyUohgLIigelhe4W7EH8kwbnLg,15330
 velocity/aws/handlers/__init__.py,sha256=4-NKj8dBzjYEdIlNdfm_Ip5mI0oOGcpjjBcMwU42yhQ,227
 velocity/aws/handlers/base_handler.py,sha256=bapdzWss5lXesoLPsVwJo9hQMZLdz7XOubo3sK70xC8,7960
-velocity/aws/handlers/context.py,sha256=0kPZ8y-XjmBZY5NcexynR5htnWYfF0nwM1n5UH-6c5w,8413
+velocity/aws/handlers/context.py,sha256=yL1oA8y6q0b1Vg3KUB0XWJ0hqnToScZuBXEHpWif8V0,11259
 velocity/aws/handlers/exceptions.py,sha256=i4wcB8ZSWUHglX2xnesDlWLsU9AMYU72cHCWRBDmjQ8,361
 velocity/aws/handlers/lambda_handler.py,sha256=0wa_CHyJOaI5RsHqB0Ae83-B-SwlKR0qkGUlc7jitQI,4427
 velocity/aws/handlers/response.py,sha256=s2Kw7yv5zAir1mEmfv6yBVIvRcRQ__xyryf1SrvtiRc,9317
@@ -28,17 +28,17 @@ velocity/aws/tests/test_lambda_handler_json_serialization.py,sha256=VuikDD_tbRbA
 velocity/aws/tests/test_response.py,sha256=sCg6qOSDWNncnmkuf4N3gO5fxQQ3PyFNMRsYy195nKo,6546
 velocity/db/__init__.py,sha256=7XRUHY2af0HL1jvL0SAMpxSe5a2Phbkm-YLJCvC1C_0,739
 velocity/db/exceptions.py,sha256=LbgYJfY2nCBu7tBC_U1BwdczypJ24S6CUyREG_N5gO0,2345
-velocity/db/utils.py,sha256=IoXeAL_0wZE15gbxlb2TtNdHzUSV9bIvw8jNkqjz38o,7020
+velocity/db/utils.py,sha256=qfnxN67B91pIXqMEp8mP5RuzFlBI20zwMMWBoHHO29g,8864
 velocity/db/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 velocity/db/core/column.py,sha256=tAr8tL3a2nyaYpNHhGl508FrY_pGZTzyYgjAV5CEBv4,4092
 velocity/db/core/database.py,sha256=3zNGItklu9tZCKsbx2T2vCcU1so8AL9PPL0DLjvaz6s,3554
-velocity/db/core/decorators.py,sha256=quhjMoEmK_l2jF7jXyL5Fgv8uisIpBz34Au5d3U6UHs,5276
-velocity/db/core/engine.py,sha256=mNlaFPruHO935phKPVrsxZprGYUvxW-zp2sBcBZ-KCg,20666
+velocity/db/core/decorators.py,sha256=GpMw_2BkWvEKgEfsPnCnlN7uyUvIXOJX_TeYCp0O_2I,5804
+velocity/db/core/engine.py,sha256=84jz1taX-t4nqXN99kz9WyczpgsRLGFNnc_hpaCi3lE,20769
 velocity/db/core/result.py,sha256=b0ie3yZAOj9S57x32uFFGKZ95zhImmZ0iXl0X1qYszc,12813
 velocity/db/core/row.py,sha256=GOWm-HEBPCBwdqMHMBRc41m0Hoht4vRVQLkvdogX1fU,7729
 velocity/db/core/sequence.py,sha256=VMBc0ZjGnOaWTwKW6xMNTdP8rZ2umQ8ml4fHTTwuGq4,3904
-velocity/db/core/table.py,sha256=_OXKXG7abhVUBja-LVlhHcINmMbKZ-VRN_I_FDfbZ9M,42164
-velocity/db/core/transaction.py,sha256=VrEp37b2d_rRDHKYYm-0D0BiVtYZVltM3zooer25Klg,6918
+velocity/db/core/table.py,sha256=BN_tY2bVSLCGmr0el0wAcm6binOxAc1OBvco3DI7_zY,43379
+velocity/db/core/transaction.py,sha256=LDwwAXk666sBdT4J01bvu3rAYfWwxvxVVQUBbQlX-hY,7155
 velocity/db/servers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 velocity/db/servers/tablehelper.py,sha256=Q48ObN5KD_U2sBP0GUcjaQjKeE4Hr351sPQirwQ0_1s,22163
 velocity/db/servers/base/__init__.py,sha256=5--XJUeEAm7O6Ns2C_ODCr5TjFhdAge-zApZCT0LGTQ,285
@@ -49,27 +49,27 @@ velocity/db/servers/base/types.py,sha256=3LBxFCD35eeIsIqftpAJh0JjUVonDYemz2n6AMt
 velocity/db/servers/mysql/__init__.py,sha256=mASO5JB0xkzYngwx2X79yyKifYRqxIdfKFWutIHuw7k,2661
 velocity/db/servers/mysql/operators.py,sha256=wHmVSPxlPGbOdvQEmsfKhD25H8djovSbNcmacLHDVkI,1273
 velocity/db/servers/mysql/reserved.py,sha256=s-aFMwYJpZ_1FBcCMU8fOdhml2ET58-59ZnUm7iw5OU,3312
-velocity/db/servers/mysql/sql.py,sha256=CxskGe86I-8idLNZmcG7IPqlc-BQM9cpJU6WS5KdCA0,22210
+velocity/db/servers/mysql/sql.py,sha256=pVUuxQnwxbCDHBltX7vjoVSyGodHm_eYpU0XfF0QwL4,22681
 velocity/db/servers/mysql/types.py,sha256=BMQf4TpsRo1JN-yOl1nSItTO-Juu2piSTNy5o_djBeM,3486
 velocity/db/servers/postgres/__init__.py,sha256=6YcTLXposmsrEaJgdUAM_QgD1TZDSILQrGcwWZ-dibk,2457
 velocity/db/servers/postgres/operators.py,sha256=y9k6enReeR5hJxU_lYYR2epoaw4qCxEqmYJJ5jjaVWA,1166
 velocity/db/servers/postgres/reserved.py,sha256=5tKLaqFV-HrWRj-nsrxl5KGbmeM3ukn_bPZK36XEu8M,3648
-velocity/db/servers/postgres/sql.py,sha256=oF0Bll75sTOrRQhBNo3dklRpUFhLixil4i09eVC9Y8Y,54450
+velocity/db/servers/postgres/sql.py,sha256=zmn8cd1kxo7xAhR6BbP4XYx4m8Y7cTI-Ypw7qGGf22I,56789
 velocity/db/servers/postgres/types.py,sha256=W71x8iRx-IIJkQSjb29k-KGkqp-QS6SxB0BHYXd4k8w,6955
 velocity/db/servers/sqlite/__init__.py,sha256=EIx09YN1-Vm-4CXVcEf9DBgvd8FhIN9rEqIaSRrEcIk,2293
 velocity/db/servers/sqlite/operators.py,sha256=VzZgph8RrnHkIVqqWGqnJwcafgBzc_8ZQp-M8tMl-mw,1221
 velocity/db/servers/sqlite/reserved.py,sha256=4vOI06bjt8wg9KxdzDTF-iOd-ewY23NvSzthpdty2fA,1298
-velocity/db/servers/sqlite/sql.py,sha256=iAENHbN8mfVsQHoqnEppynVMP_PdqXJX8jZQDNzr0ro,20948
+velocity/db/servers/sqlite/sql.py,sha256=FAWhzfM-D25Qaug1omMlcnu2NEHvnMfZIf7yR7HA-TQ,21456
 velocity/db/servers/sqlite/types.py,sha256=jpCJeV25x4Iytf6D6GXgK3hVYFAAFV4WKJC-d-m4kdU,3102
 velocity/db/servers/sqlserver/__init__.py,sha256=LN8OycN7W8da_ZPRYnPQ-O3Bv_xjret9qV1ZCitZlOU,2708
 velocity/db/servers/sqlserver/operators.py,sha256=xK8_doDLssS38SRs1NoAI7XTO0-gNGMDS76nTVru4kE,1104
 velocity/db/servers/sqlserver/reserved.py,sha256=Gn5n9DjxcjM-7PsIZPYigD6XLvMAYGnz1IrPuN7Dp2Y,2120
-velocity/db/servers/sqlserver/sql.py,sha256=h4fnVuNWaQE2c2sEEkLSIlBGf3xZP-lDtwILhF2-g3c,26368
+velocity/db/servers/sqlserver/sql.py,sha256=Uh_XbBKJw5NZUoDxMYQjS26pXSA5OJj3XDsGPZ1S9Io,26754
 velocity/db/servers/sqlserver/types.py,sha256=FAODYEO137m-WugpM89f9bQN9q6S2cjjUaz0a9gfE6M,3745
 velocity/db/tests/__init__.py,sha256=7-hilWb43cKnSnCeXcjFG-6LpziN5k443IpsIvuevP0,24
 velocity/db/tests/common_db_test.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 velocity/db/tests/test_cursor_rowcount_fix.py,sha256=mZRL1SBb9Knh67CSFyvfwj_LAarE_ilfVwpQHW18Yy8,5507
-velocity/db/tests/test_db_utils.py,sha256=mSbEQXYKpWidX1FEnjrmt3q3K4ra0YTtQclrS46ufEE,8426
+velocity/db/tests/test_db_utils.py,sha256=UmBh2Bmz95GI6uYwEnilcz3gmuxPgLVpsj_6ekSnkWY,10297
 velocity/db/tests/test_postgres.py,sha256=NoBydNkGmXn8olXwva4C4sYV3cKzERd6Df0wHixxoyE,15554
 velocity/db/tests/test_postgres_unchanged.py,sha256=rNcy7S_HXazi_MjU8QjRZO4q8dULMeG4tg6eN-rPPz8,2998
 velocity/db/tests/test_process_error_robustness.py,sha256=CZr_co_o6PK7dejOr_gwdn0iKTzjWPTY5k-PwJ6oh9s,11361
@@ -96,7 +96,7 @@ velocity/db/tests/postgres/test_schema_locking_unit.py,sha256=5Ifa7BEiR1zJwttuuV
 velocity/db/tests/postgres/test_sequence.py,sha256=UoI4x2z8RvucuvZk4Tf1Ue_obtRHt0QCX0ae87iQ7mY,672
 velocity/db/tests/postgres/test_sql_comprehensive.py,sha256=6eSnAMvnC257OD1EnUmiuXwzhuZlKrdK_W30OEu1yAY,18474
 velocity/db/tests/postgres/test_table.py,sha256=D55TpJl0fh8b9Q-ijS3Cj6BeXrS_XQs8qfJFu3G2WL8,2306
-velocity/db/tests/postgres/test_table_comprehensive.py,sha256=KOn6YKZT81FwuVj0bHVE0ECtDGNTHBKxBkQuGfozSdI,24011
+velocity/db/tests/postgres/test_table_comprehensive.py,sha256=NxpOFTjgjqMG5WMwxzRdsphSCq6VQDqItV95i5yplPk,24038
 velocity/db/tests/postgres/test_transaction.py,sha256=Hek8rXmz7Cuz1-Fmmgq7eyhMG9GYKkCKpUUMx5prnjc,2406
 velocity/db/tests/sql/__init__.py,sha256=evafiIjAB0jyhqZ8HfiPgRujXJkRpQ7a34Bjac4qyv8,12
 velocity/db/tests/sql/common.py,sha256=bXRob_RcZoonjCcwY712muraqGiW6HRMSpz5OOtixUM,5811
@@ -122,8 +122,8 @@ velocity/misc/tests/test_merge.py,sha256=Vm5_jY5cVczw0hZF-3TYzmxFw81heJOJB-dvhCg
 velocity/misc/tests/test_oconv.py,sha256=fy4DwWGn_v486r2d_3ACpuBD-K1oOngNq1HJCGH7X-M,4694
 velocity/misc/tests/test_original_error.py,sha256=iWSd18tckOA54LoPQOGV5j9LAz2W-3_ZOwmyZ8-4YQc,1742
 velocity/misc/tests/test_timer.py,sha256=l9nrF84kHaFofvQYKInJmfoqC01wBhsUB18lVBgXCoo,2758
-velocity_python-0.0.153.dist-info/licenses/LICENSE,sha256=aoN245GG8s9oRUU89KNiGTU4_4OtnNmVi4hQeChg6rM,1076
-velocity_python-0.0.153.dist-info/METADATA,sha256=WkqWt5YdgAqOWMGp0ZErqq44s1vA9PDoh-D01hCTOhY,34266
-velocity_python-0.0.153.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-velocity_python-0.0.153.dist-info/top_level.txt,sha256=JW2vJPmodgdgSz7H6yoZvnxF8S3fTMIv-YJWCT1sNW0,9
-velocity_python-0.0.153.dist-info/RECORD,,
+velocity_python-0.0.160.dist-info/licenses/LICENSE,sha256=aoN245GG8s9oRUU89KNiGTU4_4OtnNmVi4hQeChg6rM,1076
+velocity_python-0.0.160.dist-info/METADATA,sha256=Gq-LK_UyNdBt4epmv7xgrwbcsSPIRa8XsiyB_BoSQyo,34266
+velocity_python-0.0.160.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+velocity_python-0.0.160.dist-info/top_level.txt,sha256=JW2vJPmodgdgSz7H6yoZvnxF8S3fTMIv-YJWCT1sNW0,9
+velocity_python-0.0.160.dist-info/RECORD,,