bump version, update docs

ormar/__init__.py

@@ -30,7 +30,7 @@ class UndefinedType:  # pragma no cover
 
 Undefined = UndefinedType()
 
-__version__ = "0.5.5"
+__version__ = "0.6.0"
 __all__ = [
     "Integer",
     "BigInteger",

ormar/models/model.py

@@ -15,7 +15,7 @@ from typing import (
 import sqlalchemy
 
 import ormar.queryset  # noqa I100
-from ormar.exceptions import ModelPersistenceError
+from ormar.exceptions import ModelPersistenceError, NoMatch
 from ormar.fields.many_to_many import ManyToManyField
 from ormar.models import NewBaseModel  # noqa I100
 from ormar.models.metaclass import ModelMeta
@@ -286,9 +286,7 @@ class Model(NewBaseModel):
         expr = self.Meta.table.select().where(self.pk_column == self.pk)
         row = await self.Meta.database.fetch_one(expr)
         if not row:  # pragma nocover
-            raise ValueError(
-                "Instance was deleted from database and cannot be refreshed"
-            )
+            raise NoMatch("Instance was deleted from database and cannot be refreshed")
         kwargs = dict(row)
         kwargs = self.translate_aliases_to_columns(kwargs)
         self.from_dict(kwargs)

ormar/queryset/queryset.py

@@ -280,7 +280,9 @@ class QuerySet:
         return await self.database.fetch_val(expr)
 
     async def update(self, each: bool = False, **kwargs: Any) -> int:
-        self_fields = self.model.extract_db_own_fields()
+        self_fields = self.model.extract_db_own_fields().union(
+            self.model.extract_related_names()
+        )
         updates = {k: v for k, v in kwargs.items() if k in self_fields}
         updates = self.model.translate_columns_to_aliases(updates)
         if not each and not self.filter_clauses:

ormar/relations/querysetproxy.py

@@ -88,7 +88,7 @@ class QuerysetProxy(ormar.QuerySetProtocol):
     async def count(self) -> int:
         return await self.queryset.count()
 
-    async def clear(self) -> int:
+    async def clear(self, keep_reversed: bool = True) -> int:
         if self.type_ == ormar.RelationType.MULTIPLE:
             queryset = ormar.QuerySet(model_cls=self.relation.through)
             owner_column = self._owner.get_name()
@@ -97,10 +97,16 @@ class QuerysetProxy(ormar.QuerySetProtocol):
             owner_column = self.related_field.name
         kwargs = {owner_column: self._owner}
         self._clean_items_on_load()
+        if keep_reversed and self.type_ == ormar.RelationType.REVERSE:
+            update_kwrgs = {f"{owner_column}": None}
+            return await queryset.filter(_exclude=False, **kwargs).update(
+                each=False, **update_kwrgs
+            )
         return await queryset.delete(**kwargs)  # type: ignore
 
     async def first(self, **kwargs: Any) -> "Model":
         first = await self.queryset.first(**kwargs)
+        self._clean_items_on_load()
         self._register_related(first)
         return first
 

ormar/relations/relation_proxy.py

@@ -38,17 +38,20 @@ class RelationProxy(list):
             and self.queryset_proxy.queryset is not None
         )
 
-    def _set_queryset(self) -> "QuerySet":
-        related_field = self._owner.resolve_relation_field(
-            self.relation.to, self._owner
-        )
-        pkname = self._owner.get_column_alias(self._owner.Meta.pkname)
+    def _check_if_model_saved(self) -> None:
         pk_value = self._owner.pk
         if not pk_value:
             raise RelationshipInstanceError(
                 "You cannot query relationships from unsaved model."
             )
-        kwargs = {f"{related_field.get_alias()}__{pkname}": pk_value}
+
+    def _set_queryset(self) -> "QuerySet":
+        related_field = self._owner.resolve_relation_field(
+            self.relation.to, self._owner
+        )
+        pkname = self._owner.get_column_alias(self._owner.Meta.pkname)
+        self._check_if_model_saved()
+        kwargs = {f"{related_field.get_alias()}__{pkname}": self._owner.pk}
         queryset = (
             ormar.QuerySet(model_cls=self.relation.to)
             .select_related(related_field.name)
@@ -56,7 +59,9 @@ class RelationProxy(list):
         )
         return queryset
 
-    async def remove(self, item: "Model") -> None:  # type: ignore
+    async def remove(  # type: ignore
+        self, item: "Model", keep_reversed: bool = True
+    ) -> None:
         if item not in self:
             raise NoMatch(
                 f"Object {self._owner.get_name()} has no "
@@ -74,8 +79,11 @@ class RelationProxy(list):
         if self.type_ == ormar.RelationType.MULTIPLE:
             await self.queryset_proxy.delete_through_instance(item)
         else:
-            setattr(item, rel_name, None)
-            await item.update()
+            if keep_reversed:
+                setattr(item, rel_name, None)
+                await item.update()
+            else:
+                await item.delete()
 
     async def add(self, item: "Model") -> None:
         if self.type_ == ormar.RelationType.MULTIPLE:
@@ -83,6 +91,7 @@ class RelationProxy(list):
             rel_name = item.resolve_relation_name(item, self._owner)
             setattr(item, rel_name, self._owner)
         else:
+            self._check_if_model_saved()
             related_field = self._owner.resolve_relation_field(
                 self.relation.to, self._owner
             )