half-orm 0.18.9__tar.gz → 0.18.11__tar.gz

{half_orm-0.18.9/half_orm.egg-info → half_orm-0.18.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: half_orm
-Version: 0.18.9
+Version: 0.18.11
 Summary: A simple PostgreSQL to Python mapper.
 Home-page: https://github.com/half-orm/half-orm
 Author: Joël Maïzi

{half_orm-0.18.9 → half_orm-0.18.11}/half_orm/relation.py

@@ -429,9 +429,15 @@ class Relation:
     def ho_assert_is_singleton(self):
         """Assert that this predicate identifies exactly one row, without querying the database.
 
-        A predicate is a *singleton* when every field of a unique identifier
-        (primary key or any ``UNIQUE NOT NULL`` constraint) is set with the
-        ``=`` comparator. The check is purely structural — no SQL is executed.
+        A predicate is a *singleton* when:
+
+        * every field of a unique identifier (primary key or any
+          ``UNIQUE NOT NULL`` constraint) is set with the ``=`` comparator, **or**
+        * a FK join constrains a unique identifier of this relation: the fields
+          on *this* side of the join form a PK or UNIQUE NOT NULL, and the
+          corresponding fields on the joined relation are all fixed with ``=``.
+
+        The check is purely structural — no SQL is executed.
 
         Returns:
             self — for chaining before a write operation.
@@ -451,8 +457,14 @@ class Relation:
                 # Raises — last_name is not a unique identifier
                 Author(last_name='Martin').ho_assert_is_singleton()
 
+                # OK — FK navigation: comment.post_id fixes post.id (PK)
+                Comment(post_id=42).fk_post().ho_assert_is_singleton()
+
                 # Typical usage: guard a single-row write
                 Author(id=42).ho_assert_is_singleton().ho_update(email='new@example.com')
+
+                # Via FK navigation: delete the post linked to a specific comment
+                Comment(post_id=42).fk_post().ho_assert_is_singleton().ho_delete()
                 ```
 
         *New in version 0.18.0.*
@@ -465,6 +477,22 @@ class Relation:
         for ukey in self._ho_ukeys:
             if _fully_set(ukey):
                 return self
+        # A FK join uniquely identifies self when:
+        #   - the fields on self involved in the join form a PK or UNIQUE NOT NULL, AND
+        #   - the corresponding fields on the joined relation are all fixed with '='.
+        def _all_eq(names, rel):
+            return all(
+                rel._ho_fields.get(n.strip('"')) is not None
+                and rel._ho_fields[n.strip('"')].is_set()
+                and rel._ho_fields[n.strip('"')]._comp() == '='
+                for n in names
+            )
+        for fkey, fk_rel in self._ho_join_to.items():
+            self_fields = frozenset(fkey.names)
+            on_pk = bool(self._ho_pkey) and self_fields == frozenset(self._ho_pkey.keys())
+            on_ukey = any(self_fields == frozenset(uk.keys()) for uk in self._ho_ukeys)
+            if (on_pk or on_ukey) and _all_eq(fkey.fk_names, fk_rel):
+                return self
         if not self._ho_pkey and not self._ho_ukeys:
             raise relation_errors.NotASingletonError(
                 f"{self.__class__.__name__} has no primary key or unique NOT NULL constraint.")
@@ -532,20 +560,37 @@ class Relation:
         if not update_args:
             return None
         self._ho_query_type = 'update'
-        _, where_expr = self.__where_args()
         set_clause = []
         for field_name, new_value in update_args.items():
             col_name = self._ho_fields[field_name].name
             set_clause.append((f'"{col_name}" = %s', new_value))
-        fk_where_str, fk_values = self.__fkey_where('', [])
-        stmt = ASTUpdate(
-            table=self._qrn,
-            set_clause=set_clause,
-            where=where_expr,
-            fk_where=fk_where_str or None,
-            fk_values=fk_values,
-            returning=ASTReturning(list(args)) if args else None,
-        )
+        if self._ho_join_to:
+            # Build a subquery to avoid any DB round-trip and to correctly
+            # propagate JOIN constraints into the UPDATE predicate.
+            pk_names = list(self._ho_pkey.keys())
+            sub_sql, sub_vals = self._ho_prep_select(*pk_names)
+            if len(pk_names) == 1:
+                where = ASTRaw(f'"{pk_names[0]}" in ({sub_sql})', sub_vals)
+            else:
+                pk_cols = ', '.join(f'"{pk}"' for pk in pk_names)
+                where = ASTRaw(f'({pk_cols}) in ({sub_sql})', sub_vals)
+            stmt = ASTUpdate(
+                table=self._qrn,
+                set_clause=set_clause,
+                where=where,
+                returning=ASTReturning(list(args)) if args else None,
+            )
+        else:
+            _, where_expr = self.__where_args()
+            fk_where_str, fk_values = self.__fkey_where('', [])
+            stmt = ASTUpdate(
+                table=self._qrn,
+                set_clause=set_clause,
+                where=where_expr,
+                fk_where=fk_where_str or None,
+                fk_values=fk_values,
+                returning=ASTReturning(list(args)) if args else None,
+            )
         query, vals = stmt.to_sql()
         return query, tuple(vals), update_args
 
@@ -599,15 +644,31 @@ class Relation:
                 f'Attempt to delete all rows from {self.__class__.__name__}'
                 ' without delete_all being set to True!')
         self._ho_query_type = 'delete'
-        _, where_expr = self.__where_args()
-        fk_where_str, fk_values = self.__fkey_where('', [])
-        stmt = ASTDelete(
-            table=self._qrn,
-            where=where_expr,
-            fk_where=fk_where_str or None,
-            fk_values=fk_values,
-            returning=ASTReturning(list(args)) if args else None,
-        )
+        if self._ho_join_to:
+            # Build a subquery to avoid any DB round-trip and to correctly
+            # propagate JOIN constraints into the DELETE predicate.
+            pk_names = list(self._ho_pkey.keys())
+            sub_sql, sub_vals = self._ho_prep_select(*pk_names)
+            if len(pk_names) == 1:
+                where = ASTRaw(f'"{pk_names[0]}" in ({sub_sql})', sub_vals)
+            else:
+                pk_cols = ', '.join(f'"{pk}"' for pk in pk_names)
+                where = ASTRaw(f'({pk_cols}) in ({sub_sql})', sub_vals)
+            stmt = ASTDelete(
+                table=self._qrn,
+                where=where,
+                returning=ASTReturning(list(args)) if args else None,
+            )
+        else:
+            _, where_expr = self.__where_args()
+            fk_where_str, fk_values = self.__fkey_where('', [])
+            stmt = ASTDelete(
+                table=self._qrn,
+                where=where_expr,
+                fk_where=fk_where_str or None,
+                fk_values=fk_values,
+                returning=ASTReturning(list(args)) if args else None,
+            )
         query, vals = stmt.to_sql()
         return query, tuple(vals)
 
@@ -896,10 +957,24 @@ Fkeys = {"""
     def ho_is_set(self):
         """Return True if one field at least is set or if self has been
         constrained by at least one of its foreign keys or self is the
-        result of a combination of Relations (using set operators).
+        result of a combination of Relations (using set operators) where
+        at least one operand is itself constrained.
         """
-        joined_to = bool(self._ho_join_to)
-        return (joined_to or bool(self._ho_set_operators.operator) or bool(self._ho_neg) or
+        joined_to = any(jt_.ho_is_set() for jt_ in self._ho_join_to.values())
+        op = self._ho_set_operators.operator
+        if op:
+            left_set = self._ho_set_operators.left.ho_is_set()
+            right = self._ho_set_operators.right
+            right_set = right is not None and right.ho_is_set()
+            if op == "or":
+                # A() | B → all rows if any operand is unconstrained
+                set_op_constrained = left_set and right_set
+            else:
+                # "and" / "and not": unconstrained operand is transparent
+                set_op_constrained = left_set or right_set
+        else:
+            set_op_constrained = False
+        return (joined_to or set_op_constrained or bool(self._ho_neg) or
                 bool({field for field in self._ho_fields.values() if field.is_set()}))
 
     def __get_set_fields(self):

half_orm-0.18.11/half_orm/version.txt

@@ -0,0 +1 @@
+0.18.11

{half_orm-0.18.9 → half_orm-0.18.11/half_orm.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: half_orm
-Version: 0.18.9
+Version: 0.18.11
 Summary: A simple PostgreSQL to Python mapper.
 Home-page: https://github.com/half-orm/half-orm
 Author: Joël Maïzi

half_orm-0.18.9/half_orm/version.txt

@@ -1 +0,0 @@
-0.18.9