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

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

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

{velocity_python-0.1.37 → velocity_python-0.1.39}/pyproject.toml

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

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

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

{velocity_python-0.1.37 → velocity_python-0.1.39}/src/velocity/db/core/decorators.py

@@ -1,6 +1,7 @@
 import logging
 import time
 import random
+from collections.abc import Mapping, Sequence
 from functools import wraps
 from velocity.db import exceptions
 
@@ -148,6 +149,73 @@ def return_default(
     return decorator
 
 
+def _merge_schema_seed(target, value):
+    """Collect representative columns from dict payloads or lists of dict rows."""
+
+    if isinstance(value, Mapping):
+        for key, val in value.items():
+            if isinstance(key, str) and key not in target:
+                target[key] = val
+        return
+
+    if isinstance(value, Sequence) and not isinstance(value, (str, bytes, bytearray)):
+        for item in value:
+            if isinstance(item, Mapping):
+                _merge_schema_seed(target, item)
+
+
+def _collect_schema_seed(args, kwds):
+    data = {}
+
+    for key in ("pk", "data"):
+        _merge_schema_seed(data, kwds.get(key))
+
+    for arg in args:
+        _merge_schema_seed(data, arg)
+
+    return data
+
+
+def _normalize_conflict_columns(pk):
+    if pk is None:
+        return []
+    if isinstance(pk, str):
+        return [pk]
+    if isinstance(pk, Mapping):
+        return [str(key) for key in pk.keys()]
+    if isinstance(pk, Sequence) and not isinstance(pk, (str, bytes, bytearray)):
+        return [str(column) for column in pk]
+
+    try:
+        return [str(column) for column in pk]
+    except TypeError:
+        return [str(pk)]
+
+
+def _infer_conflict_columns(func, args, kwds):
+    """Infer explicit ON CONFLICT columns for upsert operations."""
+
+    if func.__name__ not in {"merge", "upsert_many"}:
+        return []
+
+    pk = kwds.get("pk")
+    if pk is None and len(args) >= 2:
+        pk = args[1]
+
+    columns = [column.lower() for column in _normalize_conflict_columns(pk) if column]
+    if len(columns) == 1 and columns[0] == "sys_id":
+        return []
+    return columns
+
+
+def _missing_conflict_constraint_error(exc):
+    message = str(exc or "").lower()
+    return (
+        "no unique or exclusion constraint matching the on conflict specification"
+        in message
+    )
+
+
 def create_missing(func):
     """
     If the function call fails with DbColumnMissingError or DbTableMissingError,
@@ -161,6 +229,8 @@ def create_missing(func):
 
     @wraps(func)
     def wrapper(self, *args, **kwds):
+        conflict_columns = _infer_conflict_columns(func, args, kwds)
+
         sp = self.tx.create_savepoint(cursor=self.cursor())
         try:
             result = func(self, *args, **kwds)
@@ -181,14 +251,7 @@ def create_missing(func):
                 ) from e
 
             # Existing logic for automatic creation
-            data = {}
-            if "pk" in kwds:
-                data.update(kwds["pk"])
-            if "data" in kwds:
-                data.update(kwds["data"])
-            for i, arg in enumerate(args):
-                if isinstance(arg, dict):
-                    data.update(arg)
+            data = _collect_schema_seed(args, kwds)
 
             # ALTER TABLE ADD COLUMN IF NOT EXISTS — acquire an advisory
             # lock to serialize DDL across concurrent Lambda containers,
@@ -220,15 +283,7 @@ def create_missing(func):
                 ) from e
 
             # Existing logic for automatic creation
-            data = {}
-            if "pk" in kwds:
-                data.update(kwds["pk"])
-            if "data" in kwds:
-                data.update(kwds["data"])
-            for i, arg in enumerate(args):
-                if isinstance(arg, dict):
-                    data.update(arg)
-
+            data = _collect_schema_seed(args, kwds)
             # CREATE TABLE IF NOT EXISTS — acquire advisory lock then
             # guard against concurrent creation with a savepoint.
             try:
@@ -242,6 +297,37 @@ def create_missing(func):
             except exceptions.DbObjectExistsError:
                 self.tx.rollback_savepoint(sp2, cursor=self.cursor())
 
+            if conflict_columns:
+                self.create_index(conflict_columns, unique=True)
+
+            return func(self, *args, **kwds)
+        except exceptions.DbException as e:
+            self.tx.rollback_savepoint(sp, cursor=self.cursor())
+
+            if not conflict_columns or not _missing_conflict_constraint_error(e):
+                raise
+
+            if self.tx.engine.schema_locked:
+                logger.warning(
+                    "@create_missing triggered on locked schema: table=%s error=%s",
+                    self.name, e,
+                    extra={
+                        "table_name": self.name,
+                        "operation": "create_missing_conflict_index",
+                        "schema_locked": True,
+                    },
+                )
+                raise exceptions.DbSchemaLockedError(
+                    "Cannot create missing unique index: schema is locked. "
+                    f"Original error: {e}"
+                ) from e
+
+            try:
+                self.tx.advisory_lock(f"velocity_ddl_{self.name}")
+            except Exception:
+                pass
+
+            self.create_index(conflict_columns, unique=True)
             return func(self, *args, **kwds)
 
     return wrapper