velocity-python 0.0.138__py3-none-any.whl → 0.0.152__py3-none-any.whl

velocity/db/servers/mysql/sql.py

@@ -18,6 +18,18 @@ TableHelper.reserved = reserved_words
 TableHelper.operators = OPERATORS
 
 
+system_fields = [
+    "sys_id",
+    "sys_created",
+    "sys_modified",
+    "sys_modified_by",
+    "sys_dirty",
+    "sys_table",
+    "sys_modified_count",
+    "description",
+]
+
+
 def quote(data):
     """Quote MySQL identifiers."""
     if isinstance(data, list):
@@ -361,12 +373,127 @@ class SQL(BaseSQLDialect):
 
     @classmethod
     def create_table(cls, name, columns=None, drop=False):
+        if not name or not isinstance(name, str):
+            raise ValueError("Table name must be a non-empty string")
+
+        columns = 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 = []
         if drop:
-            drop_sql = f"DROP TABLE IF EXISTS {quote(name)}"
-            return drop_sql
-        
-        # Basic CREATE TABLE - would need more implementation
-        return f"CREATE TABLE {quote(name)} (id INT PRIMARY KEY AUTO_INCREMENT)"
+            statements.append(f"DROP TABLE IF EXISTS {table_identifier};")
+
+        statements.append(
+            f"""
+CREATE TABLE {table_identifier} (
+  `sys_id` BIGINT NOT NULL AUTO_INCREMENT,
+  `sys_table` TEXT,
+  `sys_created` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  `sys_modified` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  `sys_modified_by` TEXT,
+  `sys_modified_count` INT NOT NULL DEFAULT 0,
+  `sys_dirty` TINYINT(1) NOT NULL DEFAULT 0,
+  `description` TEXT,
+  PRIMARY KEY (`sys_id`)
+) ENGINE=InnoDB;
+""".strip()
+        )
+
+        for key, val in columns.items():
+            clean_key = re.sub("<>!=%", "", key)
+            if clean_key in system_fields:
+                continue
+            col_type = TYPES.get_type(val)
+            statements.append(
+                f"ALTER TABLE {table_identifier} ADD COLUMN {quote(clean_key)} {col_type};"
+            )
+
+        statements.extend(
+            [
+                f"DROP TRIGGER IF EXISTS {trigger_prefix}_bi;",
+                f"DROP TRIGGER IF EXISTS {trigger_prefix}_bu;",
+                f"""
+CREATE TRIGGER {trigger_prefix}_bi
+BEFORE INSERT ON {table_identifier}
+FOR EACH ROW
+BEGIN
+    SET NEW.sys_created = COALESCE(NEW.sys_created, NOW());
+    SET NEW.sys_modified = NOW();
+    SET NEW.sys_modified_count = 0;
+    SET NEW.sys_dirty = IFNULL(NEW.sys_dirty, 0);
+    SET NEW.sys_table = '{base_name_sql}';
+END;
+""".strip(),
+                f"""
+CREATE TRIGGER {trigger_prefix}_bu
+BEFORE UPDATE ON {table_identifier}
+FOR EACH ROW
+BEGIN
+    IF OLD.sys_dirty = TRUE AND NEW.sys_dirty = FALSE THEN
+        SET NEW.sys_dirty = 0;
+        SET NEW.sys_modified_count = IFNULL(OLD.sys_modified_count, 0);
+    ELSE
+        SET NEW.sys_dirty = 1;
+        SET NEW.sys_modified_count = IFNULL(OLD.sys_modified_count, 0) + 1;
+    END IF;
+    SET NEW.sys_created = OLD.sys_created;
+    SET NEW.sys_modified = NOW();
+    SET NEW.sys_table = '{base_name_sql}';
+END;
+""".strip(),
+            ]
+        )
+
+        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."""
+        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"""
+CREATE TRIGGER {trigger_prefix}_bi
+BEFORE INSERT ON {table_identifier}
+FOR EACH ROW
+BEGIN
+    SET NEW.sys_created = COALESCE(NEW.sys_created, NOW());
+    SET NEW.sys_modified = NOW();
+    SET NEW.sys_modified_count = 0;
+    SET NEW.sys_dirty = IFNULL(NEW.sys_dirty, 0);
+    SET NEW.sys_table = '{base_name_sql}';
+END;
+""".strip(),
+            f"""
+CREATE TRIGGER {trigger_prefix}_bu
+BEFORE UPDATE ON {table_identifier}
+FOR EACH ROW
+BEGIN
+    IF OLD.sys_dirty = TRUE AND NEW.sys_dirty = FALSE THEN
+        SET NEW.sys_dirty = 0;
+        SET NEW.sys_modified_count = IFNULL(OLD.sys_modified_count, 0);
+    ELSE
+        SET NEW.sys_dirty = 1;
+        SET NEW.sys_modified_count = IFNULL(OLD.sys_modified_count, 0) + 1;
+    END IF;
+    SET NEW.sys_created = OLD.sys_created;
+    SET NEW.sys_modified = NOW();
+    SET NEW.sys_table = '{base_name_sql}';
+END;
+""".strip(),
+        ]
+
+        return "\n".join(statements), tuple()
 
     @classmethod
     def drop_table(cls, name):

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()
@@ -734,11 +814,13 @@ class SQL(BaseSQLDialect):
             f"""
             CREATE TABLE {fqtn} (
               sys_id BIGSERIAL PRIMARY KEY,
-              sys_modified TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
               sys_created TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-              sys_modified_by TEXT,
+              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,
+              sys_table TEXT NOT NULL,
               description TEXT
             );
 
@@ -747,19 +829,30 @@ class SQL(BaseSQLDialect):
             CREATE OR REPLACE FUNCTION {schema}.on_sys_modified()
               RETURNS TRIGGER AS
             $BODY$
-                        BEGIN
-                        -- update sys_modified on each insert/update.
-                        NEW.sys_modified := now();
-                        if (TG_OP = 'INSERT') THEN
-                            NEW.sys_created :=now();
-                        ELSEIF (TG_OP = 'UDPATE') THEN
-                         -- Do not allow sys_created to be modified.
-                            NEW.sys_created := OLD.sys_created;
+                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;
-                        -- Insert table name to row
-                        NEW.sys_table := TG_TABLE_NAME;
-                        RETURN NEW;
-                        END;
+                        NEW.sys_modified := transaction_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;
@@ -782,6 +875,88 @@ class SQL(BaseSQLDialect):
         sql = sqlparse.format(" ".join(sql), reindent=True, keyword_case="upper")
         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."""
+        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)
+        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")
+        
+        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_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();
+        """,
+        ])
+
+        sql = sqlparse.format(
+            " ".join(statements), reindent=True, keyword_case="upper"
+        )
+        return sql, tuple()
+
     @classmethod
     def drop_table(cls, name):
         return f"drop table if exists {TableHelper.quote(name)} cascade;", tuple()