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

velocity/__init__.py

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

velocity/app/orders.py

@@ -115,9 +115,7 @@ class Order:
             for key, default in defaults.items():
                 if key not in target:
                     target[key] = default() if callable(default) else default
-                elif key == "updated_at":
-                    # Always update updated_at if present
-                    target[key] = default() if callable(default) else default
+
 
     def _validate(self):
         self._apply_defaults()

velocity/aws/handlers/mixins/aws_session_mixin.py

@@ -0,0 +1,192 @@
+"""
+Error Handler Mixin for Lambda Handlers.
+
+Provides standardized error handling, logging, and notification functionality
+for Lambda handlers.
+"""
+
+import copy
+import os
+import pprint
+import time
+from abc import ABC, abstractmethod
+from typing import Dict, Any, Optional
+
+
+class AwsSessionMixin(ABC):
+    """
+    Mixin class providing standardized error handling for Lambda handlers.
+    
+    Handles error logging to sys_log table, email notifications to administrators,
+    and error metrics collection.
+    """
+    
+    def handle_standard_error(self, tx, context, exception: Exception, tb_string: str):
+        """Handle errors with consistent logging and notification patterns"""
+        
+        # Log to sys_log for centralized logging
+        self.log_error_to_system(tx, context, exception, tb_string)
+        
+        # Determine if this error requires notification
+        if self._should_notify_error(exception):
+            self.send_error_notification(tx, context, exception, tb_string)
+        
+        # Log error metrics for monitoring
+        self.log_error_metrics(tx, context, exception)
+    
+    def log_error_to_system(self, tx, context, exception: Exception, tb_string: str):
+        """Log error to sys_log table"""
+        error_data = {
+            "level": "ERROR",
+            "message": str(exception),
+            "function": f"{self.__class__.__name__}.{context.action()}",
+            "traceback": tb_string,
+            "exception_type": exception.__class__.__name__,
+            "handler_name": self.__class__.__name__,
+            "action": context.action(),
+            "user_branch": os.environ.get("USER_BRANCH", "Unknown"),
+            "function_name": os.environ.get("AWS_LAMBDA_FUNCTION_NAME", "Unknown"),
+            "app_name": os.environ.get("ProjectName", "Unknown"),
+            "user_agent": "AWS Lambda",
+            "device_type": "Lambda",
+            "sys_modified_by": "Lambda",
+        }
+        
+        # Add user context if available
+        try:
+            if hasattr(self, 'current_user') and self.current_user:
+                error_data["user_email"] = self.current_user.get("email_address")
+        except:
+            pass
+            
+        tx.table("sys_log").insert(error_data)
+    
+    def send_error_notification(self, tx, context, exception: Exception, tb_string: str):
+        """Send error notification email to administrators"""
+        try:
+            # Import here to avoid circular dependency
+            from support.app import helpers
+            
+            environment = os.environ.get('USER_BRANCH', 'Unknown').title()
+            function_name = os.environ.get('AWS_LAMBDA_FUNCTION_NAME', 'Unknown')
+            
+            subject = f"{environment} Lambda Error - {function_name}"
+            
+            body = f"""
+Error Details:
+- Handler: {self.__class__.__name__}
+- Action: {context.action()}
+- Exception: {exception.__class__.__name__}
+- Message: {str(exception)}
+- Environment: {environment}
+- Function: {function_name}
+
+Full Traceback:
+{tb_string}
+
+Request Details:
+{self._get_error_context(context)}
+            """
+            
+            sender = self._get_error_notification_sender()
+            recipients = self._get_error_notification_recipients()
+            
+            helpers.sendmail(
+                tx,
+                subject=subject,
+                body=body,
+                html=None,
+                sender=sender,
+                recipient=recipients[0],
+                cc=recipients[1:] if len(recipients) > 1 else None,
+                bcc=None,
+                email_settings_id=1001,
+            )
+        except Exception as email_error:
+            print(f"Failed to send error notification email: {email_error}")
+    
+    def _should_notify_error(self, exception: Exception) -> bool:
+        """Determine if an error should trigger email notifications"""
+        # Don't notify for user authentication errors or validation errors
+        non_notification_types = [
+            "AuthenticationError", 
+            "ValidationError", 
+            "ValueError",
+            "AlertError"
+        ]
+        
+        exception_name = exception.__class__.__name__
+        
+        # Check for authentication-related exceptions
+        if "Authentication" in exception_name or "Auth" in exception_name:
+            return False
+            
+        return exception_name not in non_notification_types
+    
+    @abstractmethod
+    def _get_error_notification_recipients(self) -> list:
+        """
+        Get list of email recipients for error notifications.
+        
+        Must be implemented by the handler class.
+        
+        Returns:
+            List of email addresses to notify when errors occur
+            
+        Example:
+            return ["admin@company.com", "devops@company.com"]
+        """
+        pass
+    
+    @abstractmethod
+    def _get_error_notification_sender(self) -> str:
+        """
+        Get email sender for error notifications.
+        
+        Must be implemented by the handler class.
+        
+        Returns:
+            Email address to use as sender for error notifications
+            
+        Example:
+            return "no-reply@company.com"
+        """
+        pass
+    
+    def _get_error_context(self, context) -> str:
+        """Get sanitized request context for error reporting"""
+        try:
+            postdata = context.postdata()
+            sanitized = copy.deepcopy(postdata)
+            
+            # Remove sensitive data
+            if "payload" in sanitized and isinstance(sanitized["payload"], dict):
+                sanitized["payload"].pop("cognito_user", None)
+                
+            return pprint.pformat(sanitized)
+        except:
+            return "Unable to retrieve request context"
+    
+    def log_error_metrics(self, tx, context, exception: Exception):
+        """Log error metrics for monitoring and alerting"""
+        try:
+            metrics_data = {
+                "metric_type": "error_count",
+                "handler_name": self.__class__.__name__,
+                "action": context.action(),
+                "exception_type": exception.__class__.__name__,
+                "environment": os.environ.get("USER_BRANCH", "Unknown"),
+                "function_name": os.environ.get("AWS_LAMBDA_FUNCTION_NAME", "Unknown"),
+                "timestamp": time.time(),
+                "sys_modified_by": "Lambda"
+            }
+            
+            # Try to insert into metrics table if it exists
+            try:
+                tx.table("lambda_metrics").insert(metrics_data)
+            except:
+                # Metrics table might not exist yet, don't fail error handler
+                pass
+        except:
+            # Don't fail the error handler if metrics logging fails
+            pass

velocity/db/core/row.py

@@ -44,7 +44,12 @@ class Row:
     def __setitem__(self, key, val):
         if key in self.pk:
             raise Exception("Cannot update a primary key.")
-        self.table.upsert({key: val}, self.pk)
+        if hasattr(self.table, "updins"):
+            self.table.updins({key: val}, pk=self.pk)
+        elif hasattr(self.table, "upsert"):
+            self.table.upsert({key: val}, pk=self.pk)
+        else:
+            self.table.update({key: val}, pk=self.pk)
 
     def __delitem__(self, key):
         if key in self.pk:
@@ -121,7 +126,12 @@ class Row:
         if kwds:
             data.update(kwds)
         if data:
-            self.table.upsert(data, self.pk)
+            if hasattr(self.table, "updins"):
+                self.table.updins(data, pk=self.pk)
+            elif hasattr(self.table, "upsert"):
+                self.table.upsert(data, pk=self.pk)
+            else:
+                self.table.update(data, pk=self.pk)
         return self
 
     def __cmp__(self, other):

velocity/db/core/table.py

@@ -1,4 +1,5 @@
 import sqlparse
+from collections.abc import Iterable, Mapping
 from velocity.db import exceptions
 from velocity.db.core.row import Row
 from velocity.db.core.result import Result
@@ -119,6 +120,59 @@ class Table:
             return sql, vals
         self.tx.execute(sql, vals, cursor=self.cursor())
 
+    def create_indexes(self, indexes, **kwds):
+        """
+        Convenience wrapper to create multiple indexes in order.
+
+        Accepts an iterable of definitions. Each definition may be either:
+        - Mapping with a required "columns" entry plus optional "unique",
+          "direction", "where", and "lower" keys.
+        - A simple sequence/string of columns, in which case defaults apply.
+
+        When sql_only=True, a list of (sql, params) tuples is returned.
+        """
+
+        if indexes is None:
+            return [] if kwds.get("sql_only", False) else None
+
+        if not isinstance(indexes, Iterable) or isinstance(indexes, (str, bytes)):
+            raise TypeError("indexes must be an iterable of index definitions")
+
+        sql_only = kwds.get("sql_only", False)
+        statements = []
+
+        for definition in indexes:
+            if isinstance(definition, Mapping):
+                columns = definition.get("columns")
+                if not columns:
+                    raise ValueError("Index definition requires a non-empty 'columns' entry")
+                params = {
+                    "unique": definition.get("unique", False),
+                    "direction": definition.get("direction"),
+                    "where": definition.get("where"),
+                    "lower": definition.get("lower"),
+                }
+            else:
+                columns = definition
+                params = {
+                    "unique": False,
+                    "direction": None,
+                    "where": None,
+                    "lower": None,
+                }
+
+            if isinstance(columns, str):
+                columns = columns.split(",")
+
+            if not columns:
+                raise ValueError("Index columns cannot be empty")
+
+            result = self.create_index(columns, **params, **kwds)
+            if sql_only:
+                statements.append(result)
+
+        return statements if sql_only else None
+
     @return_default(None)
     def drop_index(self, columns, **kwds):
         """
@@ -177,10 +231,14 @@ class Table:
             columns = []
 
         has_column = "sys_modified_count" in columns
-        if has_column and not force:
+        has_row_column = "sys_modified_row" in columns
+
+        if has_column and has_row_column and not force:
             return
 
-        sql, vals = self.sql.ensure_sys_modified_count(self.name, has_column=has_column)
+        sql, vals = self.sql.ensure_sys_modified_count(
+            self.name, has_column=has_column, has_row_column=has_row_column
+        )
         if kwds.get("sql_only", False):
             return sql, vals
         self.tx.execute(sql, vals, cursor=self.cursor())
@@ -289,10 +347,10 @@ class Table:
         return Row(self, result[0]["sys_id"], lock=lock)
 
     @return_default(None)
-    def find(self, where, lock=None, use_where=False):
+    def find(self, where, lock=None, use_where=False, raise_if_missing=False):
         """
-        Finds a single row matching `where`, or returns None if none found.
-        Raises DuplicateRowsFoundError if multiple rows match.
+        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.")
@@ -300,6 +358,10 @@ class Table:
             where = {"sys_id": where}
         result = self.select("sys_id", where=where, lock=lock).all()
         if not result:
+            if raise_if_missing:
+                raise LookupError(
+                    f"No rows found in `{self.name}` for criteria: {where!r}"
+                )
             return None
         if len(result) > 1:
             sql = self.select("sys_id", sql_only=True, where=where, lock=lock)
@@ -487,6 +549,104 @@ class Table:
         result = self.tx.execute(sql, vals, cursor=self.cursor())
         return result.cursor.rowcount if result.cursor else 0
 
+    @create_missing
+    def update_or_insert(self, update_data, insert_data=None, where=None, pk=None, **kwds):
+        """
+        Attempts an UPDATE first; if no rows change, performs an INSERT guarded by NOT EXISTS.
+
+        :param update_data: Mapping of columns to update.
+        :param insert_data: Optional mapping used for the INSERT. When omitted, values are
+                             derived from update_data combined with simple equality predicates
+                             from ``where`` and primary key values.
+        :param where: Criteria for the UPDATE and existence check.
+        :param pk: Optional primary key mapping for UPDATE (merged into WHERE) and INSERT.
+        :param sql_only: When True, return the SQL/parameter tuples for both phases instead of executing.
+        :return: Number of rows affected, or a dict with ``update``/``insert`` entries when sql_only=True.
+        """
+        sql_only = kwds.get("sql_only", False)
+        if not isinstance(update_data, Mapping) or not update_data:
+            raise ValueError("update_data must be a non-empty mapping of column-value pairs.")
+        if where is None and pk is None:
+            raise ValueError("Either where or pk must be provided for update_or_insert.")
+
+        update_stmt = None
+        if sql_only:
+            update_stmt = self.update(update_data, where=where, pk=pk, sql_only=True)
+        else:
+            updated = self.update(update_data, where=where, pk=pk)
+            if updated:
+                return updated
+
+        if insert_data is not None:
+            if not isinstance(insert_data, Mapping):
+                raise ValueError("insert_data must be a mapping when provided.")
+            insert_payload = dict(insert_data)
+        else:
+            insert_payload = dict(update_data)
+            if isinstance(where, Mapping):
+                for key, val in where.items():
+                    if not isinstance(key, str):
+                        continue
+                    if set("<>!=%").intersection(key):
+                        continue
+                    insert_payload.setdefault(key, val)
+            if isinstance(pk, Mapping):
+                for key, val in pk.items():
+                    insert_payload.setdefault(key, val)
+
+        if not insert_payload:
+            raise ValueError("Unable to derive insert payload for update_or_insert.")
+
+        exists_where = None
+        if where is not None and pk is not None:
+            if isinstance(where, Mapping) and isinstance(pk, Mapping):
+                combined = dict(where)
+                combined.update(pk)
+                exists_where = combined
+            else:
+                exists_where = where
+        elif where is not None:
+            exists_where = where
+        else:
+            exists_where = pk
+
+        ins_builder = getattr(self.sql, "insnx", None) or getattr(
+            self.sql, "insert_if_not_exists", None
+        )
+        if ins_builder is None:
+            raise NotImplementedError(
+                "Current SQL dialect does not support insert-if-not-exists operations."
+            )
+
+        sql, vals = ins_builder(self.tx, self.name, insert_payload, exists_where)
+        if sql_only:
+            return {"update": update_stmt, "insert": (sql, vals)}
+        result = self.tx.execute(sql, vals, cursor=self.cursor())
+        return result.cursor.rowcount if result.cursor else 0
+
+    updins = update_or_insert
+
+    @create_missing
+    def insert_if_not_exists(self, data, where=None, **kwds):
+        """
+        Inserts `data` into the table only if the existence check (`where`) does not match any rows.
+
+        Usage:
+            table.insert_if_not_exists({'key_col': 'k', 'value': 'v'}, where={'key_col': 'k'})
+
+        :param data: dict of column -> value for insert
+        :param where: mapping/list/str used for the EXISTS check; if None primary keys are used and
+                      must be present in `data`.
+        :return: rowcount (0 or 1) or (sql, params) when sql_only=True
+        """
+        sql, vals = self.sql.insert_if_not_exists(self.tx, self.name, data, where)
+        if kwds.get("sql_only", False):
+            return sql, vals
+        result = self.tx.execute(sql, vals, cursor=self.cursor())
+        return result.cursor.rowcount if result.cursor else 0
+
+    insnx = insert_if_not_exists
+
     upsert = merge
     indate = merge
 

velocity/db/core/transaction.py

@@ -164,17 +164,25 @@ class Transaction:
         """
         return Row(self.table(tablename), pk, lock=lock)
 
-    def get(self, tablename, where, lock=None):
-        """
-        Shortcut to table.get().
-        """
-        return self.table(tablename).get(where, lock=lock)
-
-    def find(self, tablename, where, lock=None):
-        """
-        Shortcut to table.find().
-        """
-        return self.table(tablename).find(where, lock=lock)
+    def get(self, tablename, where, lock=None, use_where=False):
+        """Shortcut to table.get() with optional ``use_where`` passthrough."""
+        return self.table(tablename).get(where, lock=lock, use_where=use_where)
+
+    def find(
+        self,
+        tablename,
+        where,
+        lock=None,
+        use_where=False,
+        raise_if_missing=False,
+    ):
+        """Shortcut to table.find() with ``use_where``/``raise_if_missing`` passthrough."""
+        return self.table(tablename).find(
+            where,
+            lock=lock,
+            use_where=use_where,
+            raise_if_missing=raise_if_missing,
+        )
 
     def column(self, tablename, colname):
         """

velocity/db/servers/mysql/sql.py

@@ -450,7 +450,7 @@ END;
         return "\n".join(statements), tuple()
 
     @classmethod
-    def ensure_sys_modified_count(cls, name):
+    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."""
         table_identifier = quote(name)
         base_name = name.split(".")[-1].replace("`", "")

velocity/db/servers/postgres/sql.py

@@ -18,39 +18,6 @@ TableHelper.reserved = reserved_words
 TableHelper.operators = OPERATORS
 
 
-def _get_table_helper(tx, table):
-    """
-    Utility function to create a TableHelper instance.
-    Ensures consistent configuration across all SQL methods.
-    """
-    return TableHelper(tx, table)
-
-
-def _validate_table_name(table):
-    """Validate table name format."""
-    if not table or not isinstance(table, str):
-        raise ValueError("Table name must be a non-empty string")
-    # Add more validation as needed
-    return table.strip()
-
-
-def _handle_predicate_errors(predicates, operation="WHERE"):
-    """Process a list of predicates with error handling."""
-    sql_parts = []
-    vals = []
-
-    for pred, val in predicates:
-        sql_parts.append(pred)
-        if val is None:
-            pass
-        elif isinstance(val, tuple):
-            vals.extend(val)
-        else:
-            vals.append(val)
-
-    return sql_parts, vals
-
-
 system_fields = [
     "sys_id",
     "sys_created",
@@ -143,7 +110,7 @@ class SQL(BaseSQLDialect):
         vals = []
 
         # Create table helper instance
-        th = _get_table_helper(tx, table)
+        th = TableHelper(tx, table)
 
         # Handle columns and DISTINCT before aliasing
         if columns is None:
@@ -447,7 +414,7 @@ class SQL(BaseSQLDialect):
         if not isinstance(data, Mapping) or not data:
             raise ValueError("data must be a non-empty mapping of column-value pairs.")
 
-        th = _get_table_helper(tx, table)
+        th = TableHelper(tx, table)
         set_clauses = []
         vals = []
 
@@ -595,51 +562,164 @@ class SQL(BaseSQLDialect):
 
     @classmethod
     def merge(cls, tx, table, data, pk, on_conflict_do_nothing, on_conflict_update):
+        if not isinstance(data, Mapping) or not data:
+            raise ValueError("data must be a non-empty mapping of column-value pairs.")
+
+        table_helper = TableHelper(tx, table)
+        data = dict(data)  # work with a copy to avoid mutating the caller's dict
+
         if pk is None:
             pkeys = tx.table(table).primary_keys()
             if not pkeys:
                 raise ValueError("Primary key required for merge.")
-            # If there are multiple primary keys, use all of them
-            if len(pkeys) > 1:
-                pk = {pk: data[pk] for pk in pkeys}
-            else:
-                pk = {pkeys[0]: data[pkeys[0]]}
-            # Remove primary keys from data; they will be used in the conflict target
-            data = {k: v for k, v in data.items() if k not in pk}
+            missing = [key for key in pkeys if key not in data]
+            if missing:
+                missing_cols = ", ".join(missing)
+                raise ValueError(
+                    "Primary key values missing from data for merge: "
+                    f"{missing_cols}. Provide pk=... or include the key values in data."
+                )
+            pk = {key: data[key] for key in pkeys}
+        else:
+            pk = dict(pk)
+            for key, value in pk.items():
+                if key in data and data[key] != value:
+                    raise ValueError(
+                        f"Conflicting values for primary key '{key}' between data and pk arguments."
+                    )
 
-        # Create a merged dictionary for insert (data + primary key columns)
-        full_data = {}
-        full_data.update(data)
-        full_data.update(pk)
+        insert_data = dict(data)
+        insert_data.update(pk)
 
-        sql, vals = cls.insert(table, full_data)
-        sql = [sql]
-        vals = list(vals)  # Convert to a mutable list
+        update_data = {k: v for k, v in data.items() if k not in pk}
 
-        if on_conflict_do_nothing != on_conflict_update:
-            sql.append("ON CONFLICT")
-            sql.append("(")
-            sql.append(",".join(pk.keys()))
-            sql.append(")")
-            sql.append("DO")
-            if on_conflict_do_nothing:
-                sql.append("NOTHING")
-            elif on_conflict_update:
-                # Call update() with excluded=True to produce the SET clause for the upsert.
-                sql_update, vals_update = cls.update(tx, table, data, pk, excluded=True)
-                sql.append(sql_update)
-                # Use list.extend to add the update values to vals.
-                vals.extend(vals_update)
-        else:
+        if not update_data and on_conflict_update:
+            # Nothing to update, fall back to a no-op on conflict resolution.
+            on_conflict_do_nothing = True
+            on_conflict_update = False
+
+        if on_conflict_do_nothing == on_conflict_update:
             raise Exception(
                 "Update on conflict must have one and only one option to complete on conflict."
             )
 
+        sql, vals = cls.insert(table, insert_data)
+        sql = [sql]
+        vals = list(vals)  # Convert to a mutable list
+
+        sql.append("ON CONFLICT")
+        conflict_columns = [TableHelper.quote(column) for column in pk.keys()]
+        sql.append("(")
+        sql.append(", ".join(conflict_columns))
+        sql.append(")")
+        sql.append("DO")
+        if on_conflict_do_nothing:
+            sql.append("NOTHING")
+        elif on_conflict_update:
+            sql_update, vals_update = cls.update(
+                tx, table, update_data, pk, excluded=True
+            )
+            sql.append(sql_update)
+            vals.extend(vals_update)
+
         import sqlparse
 
         final_sql = sqlparse.format(" ".join(sql), reindent=True, keyword_case="upper")
         return final_sql, tuple(vals)
 
+    @classmethod
+    def insnx(cls, tx, table, data, where=None):
+        """Insert only when the supplied predicate finds no existing row."""
+        if not table:
+            raise ValueError("Table name is required.")
+        if not isinstance(data, Mapping) or not data:
+            raise ValueError("data must be a non-empty mapping of column-value pairs.")
+
+        # Helper used for quoting and foreign key resolution
+        th = TableHelper(tx, table)
+        quote_helper = TableHelper(None, table)
+
+        columns_sql = []
+        select_parts = []
+        vals = []
+
+        for key, val in data.items():
+            columns_sql.append(quote_helper.quote(key.lower()))
+            if isinstance(val, str) and len(val) > 2 and val.startswith("@@") and val[2:]:
+                select_parts.append(val[2:])
+            else:
+                select_parts.append("%s")
+                vals.append(val)
+
+        if not select_parts:
+            raise ValueError("At least one column is required for insert.")
+
+        if where is None:
+            if tx is None:
+                raise ValueError(
+                    "A transaction context is required when deriving WHERE from primary keys."
+                )
+            pk_cols = tx.table(table).primary_keys()
+            if not pk_cols:
+                raise ValueError("Primary key required to derive WHERE clause.")
+            missing = [pk for pk in pk_cols if pk not in data]
+            if missing:
+                raise ValueError(
+                    "Missing primary key value(s) for insert condition: " + ", ".join(missing)
+                )
+            where = {pk: data[pk] for pk in pk_cols}
+
+        where_clauses = []
+        where_vals = []
+
+        if isinstance(where, Mapping):
+            compiled = []
+            for key, val in where.items():
+                compiled.append(th.make_predicate(key, val))
+            where = compiled
+
+        if isinstance(where, str):
+            where_clauses.append(where)
+        else:
+            try:
+                for predicate, value in where:
+                    where_clauses.append(predicate)
+                    if value is None:
+                        continue
+                    if isinstance(value, tuple):
+                        where_vals.extend(value)
+                    else:
+                        where_vals.append(value)
+            except (TypeError, ValueError) as exc:
+                raise ValueError(
+                    "Invalid WHERE clause format. Expected mapping, SQL string, or iterable of predicate/value pairs."
+                ) from exc
+
+        vals.extend(where_vals)
+
+        exists_sql = [
+            "SELECT 1 FROM",
+            TableHelper.quote(table),
+        ]
+        if where_clauses:
+            exists_sql.append("WHERE " + " AND ".join(where_clauses))
+
+        sql_parts = [
+            "INSERT INTO",
+            TableHelper.quote(table),
+            f"({','.join(columns_sql)})",
+            "SELECT",
+            ", ".join(select_parts),
+            "WHERE NOT EXISTS (",
+            " ".join(exists_sql),
+            ")",
+        ]
+
+        final_sql = sqlparse.format(" ".join(sql_parts), reindent=True, keyword_case="upper")
+        return final_sql, tuple(vals)
+
+    insert_if_not_exists = insnx
+
     @classmethod
     def version(cls):
         return "select version()", tuple()
@@ -737,6 +817,7 @@ class SQL(BaseSQLDialect):
               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,
@@ -751,8 +832,9 @@ class SQL(BaseSQLDialect):
                 BEGIN
                 IF (TG_OP = 'INSERT') THEN
                     NEW.sys_table := TG_TABLE_NAME;
-                    NEW.sys_created := clock_timestamp();
-                    NEW.sys_modified := clock_timestamp();
+                    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;
@@ -764,7 +846,7 @@ class SQL(BaseSQLDialect):
                         ELSE
                             NEW.sys_dirty := TRUE;
                         END IF;
-                        NEW.sys_modified := clock_timestamp();
+                        NEW.sys_modified := transaction_timestamp();
                         NEW.sys_modified_count := COALESCE(OLD.sys_modified_count, 0) + 1;
                     END IF;
                 END IF;
@@ -794,28 +876,52 @@ class SQL(BaseSQLDialect):
         return sql, tuple()
 
     @classmethod
-    def ensure_sys_modified_count(cls, name):
-        """Return SQL to backfill sys_modified_count and refresh the on_sys_modified trigger."""
+    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."""
         if "." in name:
-            fqtn = TableHelper.quote(name)
+            schema_name, table_name = name.split(".", 1)
         else:
-            fqtn = f"public.{TableHelper.quote(name)}"
-        schema, _ = fqtn.split(".")
-        trigger_name = f"on_update_row_{fqtn.replace('.', '_')}"
+            schema_name = cls.default_schema
+            table_name = name
+
+        schema_identifier = TableHelper.quote(schema_name)
+        table_identifier = TableHelper.quote(table_name)
+        fqtn = f"{schema_identifier}.{table_identifier}"
+
+        trigger_name = (
+            f"on_update_row_{schema_name}_{table_name}"
+            .replace(".", "_")
+            .replace('"', "")
+        )
+        trigger_identifier = TableHelper.quote(trigger_name)
         column_name = TableHelper.quote("sys_modified_count")
+        row_column_name = TableHelper.quote("sys_modified_row")
         
-        sql = [
-            f"ALTER TABLE {fqtn} ADD COLUMN {column_name} INTEGER NOT NULL DEFAULT 0;",
+        statements = []
+        if not has_column:
+            statements.append(
+                f"ALTER TABLE {fqtn} ADD COLUMN {column_name} INTEGER NOT NULL DEFAULT 0;"
+            )
+        if not has_row_column:
+            statements.append(
+                f"ALTER TABLE {fqtn} ADD COLUMN {row_column_name} TIMESTAMPTZ;"
+            )
+
+        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}.on_sys_modified()
+            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 := clock_timestamp();
-                    NEW.sys_modified := clock_timestamp();
+                    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;
@@ -827,7 +933,8 @@ class SQL(BaseSQLDialect):
                         ELSE
                             NEW.sys_dirty := TRUE;
                         END IF;
-                        NEW.sys_modified := clock_timestamp();
+                        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;
@@ -837,15 +944,17 @@ class SQL(BaseSQLDialect):
               LANGUAGE plpgsql VOLATILE
               COST 100;
         """,
-            f"DROP TRIGGER IF EXISTS {trigger_name} ON {fqtn};",
+            f"DROP TRIGGER IF EXISTS {trigger_identifier} ON {fqtn};",
             f"""
-            CREATE TRIGGER {trigger_name}
+            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();
         """,
-            ]
+        ])
 
-        sql = sqlparse.format(" ".join(sql), reindent=True, keyword_case="upper")
+        sql = sqlparse.format(
+            " ".join(statements), reindent=True, keyword_case="upper"
+        )
         return sql, tuple()
 
     @classmethod

velocity/db/servers/sqlite/sql.py

@@ -431,7 +431,7 @@ END;
         return "\n".join(statements), tuple()
 
     @classmethod
-    def ensure_sys_modified_count(cls, name):
+    def ensure_sys_modified_count(cls, name, has_column=False, has_row_column=False):
         """Ensure sys_modified_count exists for SQLite tables."""
         table_identifier = quote(name)
         base_name = name.split(".")[-1].replace('"', "")

velocity/db/servers/sqlserver/sql.py

@@ -485,7 +485,9 @@ END;
         return "\n".join(statements), tuple()
 
     @classmethod
-    def ensure_sys_modified_count(cls, name):
+    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."""
         if "." in name:
             schema, table_name = name.split(".", 1)
@@ -499,8 +501,13 @@ END;
         table_name_sql = table_name.replace("'", "''")
         trigger_prefix = re.sub(r"[^0-9A-Za-z_]+", "_", f"CC_SYS_MOD_{table_name}")
 
-        statements = [
-            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 = []
+        if not has_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;",
@@ -539,7 +546,7 @@ BEGIN
     INNER JOIN deleted AS d ON d.sys_id = i.sys_id;
 END;
 """.strip(),
-        ]
+        ])
 
         return "\n".join(statements), tuple()
 

velocity/db/tests/test_postgres.py

@@ -1,8 +1,11 @@
 import unittest
 import decimal
+from types import SimpleNamespace
+from unittest import mock
 from velocity.db.servers.postgres.sql import SQL
 from velocity.db.servers.tablehelper import TableHelper
 from velocity.db.servers.postgres.types import TYPES
+from velocity.db.core.table import Table
 
 
 class MockTx:
@@ -21,6 +24,51 @@ class MockTable:
     def column(self, column_name):
         return MockColumn()
 
+    def primary_keys(self):
+        return ["id"]
+
+
+class DummyCursor:
+    def __init__(self, rowcount=0):
+        self.rowcount = rowcount
+
+
+class DummyResult:
+    def __init__(self, rowcount=0):
+        self.cursor = DummyCursor(rowcount)
+
+
+class DummyTx:
+    def __init__(self):
+        self.engine = SimpleNamespace(sql=SimpleNamespace(), schema_locked=False)
+        self.executed = []
+        self.next_results = []
+
+    def cursor(self):
+        return DummyCursor()
+
+    def create_savepoint(self, cursor=None):
+        sp_id = f"sp_{len(self.executed)}"
+        return sp_id
+
+    def release_savepoint(self, sp, cursor=None):
+        return None
+
+    def rollback_savepoint(self, sp, cursor=None):
+        return None
+
+    def execute(self, sql, params, cursor=None):
+        self.executed.append((sql, params))
+        if self.next_results:
+            return self.next_results.pop(0)
+        return DummyResult(0)
+
+    def table(self, table_name):
+        return MockTable()
+
+    def primary_keys(self):
+        return ["id"]
+
 class MockColumn:
     def __init__(self):
         self.py_type = str
@@ -218,6 +266,147 @@ class TestSQLModule(unittest.TestCase):
         self.assertIn("SET", sql_query)
         self.assertEqual(params, ("value1", 1))
 
+    def test_sql_insnx_with_explicit_where(self):
+        mock_tx = MockTx()
+        sql_query, params = SQL.insnx(
+            mock_tx,
+            table="my_table",
+            data={"id": 1, "column1": "value1"},
+            where={"column1": "value1"},
+        )
+        self.assertIn("INSERT INTO", sql_query)
+        self.assertIn("WHERE NOT EXISTS", sql_query)
+        self.assertIn("SELECT 1 FROM my_table", sql_query)
+        self.assertEqual(params, (1, "value1", "value1"))
+
+    def test_sql_insert_if_not_exists_alias(self):
+        mock_tx = MockTx()
+        sql_alias, params_alias = SQL.insert_if_not_exists(
+            mock_tx,
+            table="my_table",
+            data={"id": 1, "column1": "value1"},
+            where={"column1": "value1"},
+        )
+        sql_main, params_main = SQL.insnx(
+            mock_tx,
+            table="my_table",
+            data={"id": 1, "column1": "value1"},
+            where={"column1": "value1"},
+        )
+        self.assertEqual(sql_alias, sql_main)
+        self.assertEqual(params_alias, params_main)
+
+    def test_table_update_or_insert_updates_only(self):
+        tx = DummyTx()
+        table = Table(tx, "my_table")
+        table.cursor = mock.MagicMock(return_value=None)
+        table.update = mock.MagicMock(return_value=1)
+        ins_builder = mock.MagicMock()
+        table.sql = SimpleNamespace(insnx=ins_builder, insert_if_not_exists=ins_builder)
+
+        affected = table.update_or_insert(
+            update_data={"value": "new"},
+            insert_data={"id": 1, "value": "new"},
+            where={"id": 1},
+        )
+
+        self.assertEqual(affected, 1)
+        table.update.assert_called_once()
+        ins_builder.assert_not_called()
+
+    def test_table_update_or_insert_falls_back_to_insert(self):
+        tx = DummyTx()
+        table = Table(tx, "my_table")
+        table.cursor = mock.MagicMock(return_value=None)
+        table.update = mock.MagicMock(return_value=0)
+
+        captured = {}
+
+        def fake_insnx(tx_ctx, table_name, data, where):
+            captured["tx"] = tx_ctx
+            captured["table"] = table_name
+            captured["data"] = dict(data)
+            captured["where"] = where
+            return ("INSERT", ("a", "b"))
+
+        ins_builder = mock.MagicMock(side_effect=fake_insnx)
+        table.sql = SimpleNamespace(insnx=ins_builder, insert_if_not_exists=ins_builder)
+        tx.next_results.append(DummyResult(1))
+
+        affected = table.update_or_insert(
+            update_data={"value": "new"},
+            where={"id": 1},
+            pk={"id": 1},
+        )
+
+        self.assertEqual(affected, 1)
+        table.update.assert_called_once()
+        ins_builder.assert_called_once()
+        self.assertEqual(captured["table"], "my_table")
+        self.assertEqual(captured["data"], {"value": "new", "id": 1})
+        self.assertEqual(captured["where"], {"id": 1})
+
+    def test_table_update_or_insert_sql_only(self):
+        tx = DummyTx()
+        table = Table(tx, "my_table")
+        table.cursor = mock.MagicMock(return_value=None)
+        table.update = mock.MagicMock(return_value=("UPDATE sql", ("u",)))
+
+        ins_builder = mock.MagicMock(return_value=("INSERT sql", ("i",)))
+        table.sql = SimpleNamespace(insnx=ins_builder, insert_if_not_exists=ins_builder)
+
+        result = table.update_or_insert(
+            update_data={"value": "new"},
+            where={"id": 1},
+            pk={"id": 1},
+            sql_only=True,
+        )
+
+        self.assertEqual(result["update"], ("UPDATE sql", ("u",)))
+        self.assertEqual(result["insert"], ("INSERT sql", ("i",)))
+        table.update.assert_called_once_with({"value": "new"}, where={"id": 1}, pk={"id": 1}, sql_only=True)
+        ins_builder.assert_called_once()
+
+    def test_sql_merge_conflict_columns_are_quoted(self):
+        mock_tx = MockTx()
+        sql_query, _ = SQL.merge(
+            mock_tx,
+            table="my_table",
+            data={"payload": "value"},
+            pk={"select": 1},
+            on_conflict_do_nothing=False,
+            on_conflict_update=True,
+        )
+        self.assertIn('on conflict ("select")'.upper(), sql_query.upper())
+
+    def test_sql_merge_missing_auto_pk_values(self):
+        mock_tx = MockTx()
+        with self.assertRaisesRegex(
+            ValueError, "Primary key values missing from data for merge"
+        ):
+            SQL.merge(
+                mock_tx,
+                table="my_table",
+                data={"column1": "value1"},
+                pk=None,
+                on_conflict_do_nothing=False,
+                on_conflict_update=True,
+            )
+
+    def test_sql_merge_auto_pk_without_update_columns_falls_back_to_do_nothing(self):
+        mock_tx = MockTx()
+        sql_query, params = SQL.merge(
+            mock_tx,
+            table="my_table",
+            data={"id": 1},
+            pk=None,
+            on_conflict_do_nothing=False,
+            on_conflict_update=True,
+        )
+        self.assertIn("DO NOTHING", sql_query)
+        self.assertNotIn(" DO UPDATE", sql_query)
+        self.assertEqual(params, (1,))
+
     def test_get_type_mapping(self):
         self.assertEqual(TYPES.get_type("string"), "TEXT")
         self.assertEqual(TYPES.get_type(123), "BIGINT")

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.142
+Version: 0.0.153
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT
@@ -497,7 +497,7 @@ def update_user(tx):
     # Find and update using dictionary syntax
     user = users.find(123)  # Returns a row that behaves like a dict
     user['name'] = 'Updated Name'         # Direct assignment like a dict
-    user['updated_at'] = datetime.now()   # No special methods needed
+    user['important_date'] = datetime.now()   # No special methods needed
     
     # Check if columns exist before updating
     if 'phone' in user:

{velocity_python-0.0.142.dist-info → velocity_python-0.0.153.dist-info}/RECORD

@@ -1,7 +1,7 @@
-velocity/__init__.py,sha256=SkDlRMRyhFqq5GpLQPd_olQYdhQHS2BT3Y4ioTVxupg,147
+velocity/__init__.py,sha256=9s-bNUFexw6PJX1-0uXQBwF6tuficIqPpR43ZzohYyo,147
 velocity/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 velocity/app/invoices.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-velocity/app/orders.py,sha256=fr1oTBjSFfyeMBUXRG06LV4jgwrlwYNL5mbEBleFwf0,6328
+velocity/app/orders.py,sha256=C7ewngMpO8nD3ul_82o4FhZBdRkWvJtnuEbEJUKDCno,6151
 velocity/app/payments.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 velocity/app/purchase_orders.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 velocity/app/tests/__init__.py,sha256=mqbNes8CjWTYLgCEgmu3EZudF6HZj671friAsAa4m_E,19
@@ -19,6 +19,7 @@ velocity/aws/handlers/response.py,sha256=s2Kw7yv5zAir1mEmfv6yBVIvRcRQ__xyryf1Srv
 velocity/aws/handlers/sqs_handler.py,sha256=azuV8DrFOh0hM13EnPzyYVBS-3fLe2fn9OPc4ho7sGc,3375
 velocity/aws/handlers/mixins/__init__.py,sha256=_zyEpsnKikF7D7X-F0GA4cyIrQ6wBq7k5j6Vhp17vaQ,623
 velocity/aws/handlers/mixins/activity_tracker.py,sha256=vyQ_8kpSprjzLoALDv7g2rVkfstn89Tbsg6Zb9GmVOk,6579
+velocity/aws/handlers/mixins/aws_session_mixin.py,sha256=yTa2-n4zgv23wbW3uZUp-L4CUJy8vSL8IMMNjMlYFVg,6806
 velocity/aws/handlers/mixins/error_handler.py,sha256=uN2YF9v-3LzS3o_HdVpO-XMcPy3sS7SHjUg_LfbsG7Q,6803
 velocity/aws/handlers/mixins/legacy_mixin.py,sha256=_YhiPU-zzXQjGNSAKhoUwfTFlnczmU-3BkwNFqr0hYE,2117
 velocity/aws/handlers/mixins/standard_mixin.py,sha256=-wBX0PFlZAnxQsaMDEWr-xmU8TcRbQ4BZD3wmAKR2d0,2489
@@ -34,10 +35,10 @@ velocity/db/core/database.py,sha256=3zNGItklu9tZCKsbx2T2vCcU1so8AL9PPL0DLjvaz6s,
 velocity/db/core/decorators.py,sha256=quhjMoEmK_l2jF7jXyL5Fgv8uisIpBz34Au5d3U6UHs,5276
 velocity/db/core/engine.py,sha256=mNlaFPruHO935phKPVrsxZprGYUvxW-zp2sBcBZ-KCg,20666
 velocity/db/core/result.py,sha256=b0ie3yZAOj9S57x32uFFGKZ95zhImmZ0iXl0X1qYszc,12813
-velocity/db/core/row.py,sha256=yqxm03uEDy3oSbnkCtKyiqFdSqG3zXTq2HIHYKOvPY4,7291
+velocity/db/core/row.py,sha256=GOWm-HEBPCBwdqMHMBRc41m0Hoht4vRVQLkvdogX1fU,7729
 velocity/db/core/sequence.py,sha256=VMBc0ZjGnOaWTwKW6xMNTdP8rZ2umQ8ml4fHTTwuGq4,3904
-velocity/db/core/table.py,sha256=zzyVZA8azaxB0QPxNjGFUOEwhk62emAZvHhkFlnACyY,35450
-velocity/db/core/transaction.py,sha256=unjmVkkfb7D8Wow6V8V8aLaxUZo316i--ksZxc4-I1Q,6613
+velocity/db/core/table.py,sha256=_OXKXG7abhVUBja-LVlhHcINmMbKZ-VRN_I_FDfbZ9M,42164
+velocity/db/core/transaction.py,sha256=VrEp37b2d_rRDHKYYm-0D0BiVtYZVltM3zooer25Klg,6918
 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
@@ -48,28 +49,28 @@ 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=_Ea84IJwILV4Mf70zM3r3PdFL2VHU2jWSCujFhiJlQM,22170
+velocity/db/servers/mysql/sql.py,sha256=CxskGe86I-8idLNZmcG7IPqlc-BQM9cpJU6WS5KdCA0,22210
 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=iZxvALFr3dpJm9BX_WE97E9RdM2RDCmi4M35HwXknVA,50141
+velocity/db/servers/postgres/sql.py,sha256=oF0Bll75sTOrRQhBNo3dklRpUFhLixil4i09eVC9Y8Y,54450
 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=GD5m4oxvWTisfn-umnKtM0Qz8VUXTUnAqQWi9Uv2trQ,20908
+velocity/db/servers/sqlite/sql.py,sha256=iAENHbN8mfVsQHoqnEppynVMP_PdqXJX8jZQDNzr0ro,20948
 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=sdmFFzt_Np9mVRGPkFsnWfYPD8z88V9Sp5no3-maPHM,26208
+velocity/db/servers/sqlserver/sql.py,sha256=h4fnVuNWaQE2c2sEEkLSIlBGf3xZP-lDtwILhF2-g3c,26368
 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_postgres.py,sha256=xp2gqsefCsvBZaG3ADT0lCPI-I2FbZeZ7GvXr77XvWc,9315
+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
 velocity/db/tests/test_result_caching.py,sha256=DgsGXWL4G79MZOslCjq_t8qtdhCcXkHjQqV5zsF6i6M,8960
@@ -121,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.142.dist-info/licenses/LICENSE,sha256=aoN245GG8s9oRUU89KNiGTU4_4OtnNmVi4hQeChg6rM,1076
-velocity_python-0.0.142.dist-info/METADATA,sha256=lOnWDl2eeeGGfq1hv56p2mGXGz-LzGodk7wWdVpRoH0,34262
-velocity_python-0.0.142.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-velocity_python-0.0.142.dist-info/top_level.txt,sha256=JW2vJPmodgdgSz7H6yoZvnxF8S3fTMIv-YJWCT1sNW0,9
-velocity_python-0.0.142.dist-info/RECORD,,
+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,,