sqlobjects 1.4.0__tar.gz → 1.6.0__tar.gz

{sqlobjects-1.4.0 → sqlobjects-1.6.0}/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 1.6.0 (2026-03-18)
+
+### Feat
+
+- **metadata**: add foreignkey()    constraint builder
+
+## 1.5.0 (2026-03-16)
+
+### Feat
+
+- **cascade**: unify cascade strategy with auto-detection for Model.delete()
+
 ## 1.4.0 (2026-03-11)
 
 ### Feat

{sqlobjects-1.4.0/sqlobjects.egg-info → sqlobjects-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlobjects
-Version: 1.4.0
+Version: 1.6.0
 Summary: Django-style async ORM library based on SQLAlchemy with chainable queries, Q objects, and relationship loading
 Author-email: XtraVisions <gitadmin@xtravisions.com>, Chen Hao <chenhao@xtravisions.com>
 Maintainer-email: XtraVisions <gitadmin@xtravisions.com>, Chen Hao <chenhao@xtravisions.com>

{sqlobjects-1.4.0 → sqlobjects-1.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sqlobjects"
-version = "1.4.0"
+version = "1.6.0"
 description = "Django-style async ORM library based on SQLAlchemy with chainable queries, Q objects, and relationship loading"
 readme = "README.md"
 license = "MIT"

{sqlobjects-1.4.0 → sqlobjects-1.6.0}/sqlobjects/cascade.py

@@ -28,6 +28,7 @@ __all__ = [
     "normalize_onupdate",
     "normalize_cascade",
     "has_cascade_delete_relations",
+    "has_delete_signals",
 ]
 
 
@@ -130,6 +131,30 @@ def has_cascade_delete_relations(model_class) -> bool:
     return False
 
 
+def has_delete_signals(model_class) -> bool:
+    """Check if model class has delete signal handlers defined.
+
+    Args:
+        model_class: Model class to check
+
+    Returns:
+        True if model has before_delete/after_delete handlers, False otherwise
+    """
+    from .signals import SignalMixin
+
+    if not issubclass(model_class, SignalMixin):
+        return False
+
+    for method_name in ("before_delete", "after_delete"):
+        method = getattr(model_class, method_name, None)
+        if method is None:
+            continue
+        # Must be defined on the model itself, not inherited from SignalMixin
+        if method_name in model_class.__dict__:
+            return True
+    return False
+
+
 def normalize_cascade(cascade: CascadeType) -> str:
     """Normalize cascade parameter to SQLAlchemy string format."""
     if cascade is None:
@@ -344,7 +369,7 @@ class CascadeExecutor:
         return instance
 
     async def execute_delete_operation(
-        self, target, cascade_strategy: str = "full", session: "AsyncSession | None" = None
+        self, target, cascade_strategy: str = "auto", session: "AsyncSession | None" = None
     ) -> int:
         """Execute delete operation with cascade handling."""
         if session is None:
@@ -355,7 +380,8 @@ class CascadeExecutor:
             return await self._execute_queryset_delete(target, cascade_strategy, session)
 
         # Handle single instance deletion
-        await self._delete_related_objects(target, session)
+        if has_cascade_delete_relations(target.__class__):
+            await self._delete_related_objects(target, session)
         await target._delete_internal(session=session)  # noqa
         return 1
 
@@ -478,6 +504,15 @@ class CascadeExecutor:
 
     async def _execute_queryset_delete(self, queryset, cascade_strategy: str, session: "AsyncSession") -> int:
         """Execute QuerySet delete with different cascade strategies."""
+        if cascade_strategy == "auto":
+            model_class = queryset._model_class
+            if has_delete_signals(model_class):
+                cascade_strategy = "full"
+            elif has_cascade_delete_relations(model_class):
+                cascade_strategy = "fast"
+            else:
+                cascade_strategy = "none"
+
         if cascade_strategy == "full":
             return await self._delete_with_full_cascade(queryset, session)
         elif cascade_strategy == "fast":

{sqlobjects-1.4.0 → sqlobjects-1.6.0}/sqlobjects/metadata.py

@@ -22,6 +22,7 @@ __all__ = [
     "index",
     "constraint",
     "unique",
+    "foreignkey",
 ]
 
 _FIELD_NAME_PATTERN = re.compile(r"\b([a-zA-Z_][a-zA-Z0-9_]*)\b")
@@ -37,7 +38,7 @@ class _RawModelConfig:
     verbose_name_plural: str | None = None
     ordering: list[str] = field(default_factory=list)
     indexes: list[Index] = field(default_factory=list)
-    constraints: list[CheckConstraint | UniqueConstraint] = field(default_factory=list)
+    constraints: list[CheckConstraint | UniqueConstraint | ForeignKeyConstraint] = field(default_factory=list)
     description: str | None = None
     db_options: dict[str, dict[str, Any]] = field(default_factory=dict)
     custom: dict[str, Any] = field(default_factory=dict)
@@ -52,7 +53,7 @@ class ModelConfig:
     verbose_name_plural: str
     ordering: list[str] = field(default_factory=list)
     indexes: list[Index] = field(default_factory=list)
-    constraints: list[CheckConstraint | UniqueConstraint] = field(default_factory=list)
+    constraints: list[CheckConstraint | UniqueConstraint | ForeignKeyConstraint] = field(default_factory=list)
     description: str | None = None
     db_options: dict[str, dict[str, Any]] = field(default_factory=dict)
     custom: dict[str, Any] = field(default_factory=dict)
@@ -1109,3 +1110,55 @@ def unique(
         >>> unique("first_name", "last_name", name="uq_full_name")
     """
     return UniqueConstraint(*fields, name=name, **kwargs)
+
+
+def foreignkey(
+    fields: str | list[str],
+    references: str | list[str],
+    *,
+    name: str | None = None,
+    ondelete: str | None = None,
+    onupdate: str | None = None,
+    deferrable: bool = False,
+    initially: str = "IMMEDIATE",
+    **kwargs: Any,
+) -> ForeignKeyConstraint:
+    """Create a ForeignKeyConstraint with convenient field name support.
+
+    Use this in Config.constraints for explicit constraint definition, custom
+    names, or composite foreign keys. For simple single-column foreign keys,
+    prefer the ``foreign_key()`` field descriptor instead.
+
+    Args:
+        fields: Local field name(s) as string or list of strings.
+        references: Referenced column(s) as "Table.column" or list thereof.
+            Supports class names (e.g. "User.id") or table names (e.g. "users.id").
+        name: Constraint name (optional, auto-generated if not provided).
+        ondelete: Referential action on delete (CASCADE, SET NULL, RESTRICT, etc.).
+        onupdate: Referential action on update.
+        deferrable: Whether the constraint can be deferred.
+        initially: Initial deferral state ("IMMEDIATE" or "DEFERRED").
+        **kwargs: Additional SQLAlchemy ForeignKeyConstraint arguments.
+
+    Returns:
+        SQLAlchemy ForeignKeyConstraint instance.
+
+    Examples:
+        >>> foreignkey("author_id", "User.id")
+        >>> foreignkey("author_id", "User.id", name="fk_posts_author", ondelete="CASCADE")
+        >>> foreignkey(["a_id", "b_id"], ["A.id", "B.id"])
+    """
+    if isinstance(fields, str):
+        fields = [fields]
+    if isinstance(references, str):
+        references = [references]
+    return ForeignKeyConstraint(
+        fields,
+        references,
+        name=name,
+        ondelete=ondelete,
+        onupdate=onupdate,
+        deferrable=deferrable or None,
+        initially=initially if deferrable else None,
+        **kwargs,
+    )

{sqlobjects-1.4.0 → sqlobjects-1.6.0}/sqlobjects/model.py

@@ -278,11 +278,14 @@ class ModelMixin(DataConversionMixin, SignalMixin):
         return await self._save_internal(validate=validate, session=session)
 
     @emit_signals(Operation.DELETE)
-    async def delete(self, cascade: bool = True):
+    async def delete(self, cascade: bool | None = None):
         """Delete this model instance from the database with cascade support.
 
         Args:
-            cascade: Whether to handle cascade deletion (default: True)
+            cascade: Whether to handle cascade deletion.
+                None (default): auto-detect based on model relationships
+                True: force cascade handling
+                False: skip cascade, direct delete
 
         Raises:
             PrimaryKeyError: If instance has no primary key values or delete fails
@@ -292,6 +295,10 @@ class ModelMixin(DataConversionMixin, SignalMixin):
 
         session = self.get_session()
 
+        # Auto-detect cascade need when not explicitly specified
+        if cascade is None:
+            cascade = self._has_on_delete_relations()
+
         # Use cascade executor for cascade operations
         if cascade:
             executor = CascadeExecutor()

{sqlobjects-1.4.0 → sqlobjects-1.6.0}/sqlobjects/queryset.py

@@ -1221,12 +1221,13 @@ class QuerySet(Generic[T]):
         return await executor.execute_update_operation(self, values)
 
     @emit_signals(Operation.DELETE, is_bulk=True)
-    async def delete(self, cascade: str = "full") -> int:
+    async def delete(self, cascade: str = "auto") -> int:
         """Perform bulk delete on objects matching query conditions.
 
         Args:
             cascade: Cascade deletion strategy
-                - "full" (default): Complete cascade deletion with full ORM functionality
+                - "auto" (default): Automatically choose based on model relationships
+                - "full": Complete cascade deletion with full ORM functionality
                 - "fast": Fast cascade deletion with minimal ORM processing
                 - "none": Direct SQL deletion without ORM cascade processing
 

{sqlobjects-1.4.0 → sqlobjects-1.6.0/sqlobjects.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlobjects
-Version: 1.4.0
+Version: 1.6.0
 Summary: Django-style async ORM library based on SQLAlchemy with chainable queries, Q objects, and relationship loading
 Author-email: XtraVisions <gitadmin@xtravisions.com>, Chen Hao <chenhao@xtravisions.com>
 Maintainer-email: XtraVisions <gitadmin@xtravisions.com>, Chen Hao <chenhao@xtravisions.com>