Adding delete_match

Author: apetenchea

arangoasync/collection.py

@@ -1172,7 +1172,6 @@ async def update_match(
         keep_none: Optional[bool] = None,
         wait_for_sync: Optional[bool] = None,
         merge_objects: Optional[bool] = None,
-        allow_dirty_read: Optional[bool] = None,
     ) -> Result[int]:
         """Update matching documents.
 
@@ -1185,10 +1184,9 @@ async def update_match(
             wait_for_sync (bool | None): Wait until operation has been synced to disk.
             merge_objects (bool | None): If set to `True`, sub-dictionaries are merged
                 instead of the new one overwriting the old one.
-            allow_dirty_read (bool | None): Allow reads from followers in a cluster.
 
         Returns:
-            int: Number of documents updated.
+            int: Number of documents that got updated.
 
         Raises:
            DocumentUpdateError: If update fails.
@@ -1213,18 +1211,11 @@ async def update_match(
             "merge": merge_objects,
         }
         data = {"query": query, "bindVars": bind_vars}
-        headers: RequestHeaders = {}
-        if allow_dirty_read is not None:
-            if allow_dirty_read is True:
-                headers["x-arango-allow-dirty-read"] = "true"
-            else:
-                headers["x-arango-allow-dirty-read"] = "false"
 
         request = Request(
             method=Method.POST,
             endpoint="/_api/cursor",
             data=self.serializer.dumps(data),
-            headers=headers,
         )
 
         def response_handler(resp: Response) -> int:
@@ -1241,7 +1232,6 @@ async def replace_match(
         body: T,
         limit: Optional[int | str] = None,
         wait_for_sync: Optional[bool] = None,
-        allow_dirty_read: Optional[bool] = None,
     ) -> Result[int]:
         """Replace matching documents.
 
@@ -1250,7 +1240,6 @@ async def replace_match(
             body (dict): New document body.
             limit (int | str | None): Maximum number of documents to replace.
             wait_for_sync (bool | None): Wait until operation has been synced to disk.
-            allow_dirty_read (bool | None): Allow reads from followers in a cluster.
 
         Returns:
             int: Number of documents that got replaced.
@@ -1276,18 +1265,11 @@ async def replace_match(
             "body": body,
         }
         data = {"query": query, "bindVars": bind_vars}
-        headers: RequestHeaders = {}
-        if allow_dirty_read is not None:
-            if allow_dirty_read is True:
-                headers["x-arango-allow-dirty-read"] = "true"
-            else:
-                headers["x-arango-allow-dirty-read"] = "false"
 
         request = Request(
             method=Method.POST,
             endpoint="/_api/cursor",
             data=self.serializer.dumps(data),
-            headers=headers,
         )
 
         def response_handler(resp: Response) -> int:
@@ -1298,6 +1280,55 @@ def response_handler(resp: Response) -> int:
 
         return await self._executor.execute(request, response_handler)
 
+    async def delete_match(
+        self,
+        filters: Json,
+        limit: Optional[int | str] = None,
+        wait_for_sync: Optional[bool] = None,
+    ) -> Result[int]:
+        """Delete matching documents.
+
+        Args:
+            filters (dict | None): Query filters.
+            limit (int | str | None): Maximum number of documents to delete.
+            wait_for_sync (bool | None): Wait until operation has been synced to disk.
+
+        Returns:
+            int: Number of documents that got deleted.
+
+        Raises:
+           DocumentDeleteError: If delete fails.
+        """
+        if not self._is_none_or_dict(filters):
+            raise ValueError("filters parameter must be a dict")
+        if not (self._is_none_or_int(limit) or limit == "null"):
+            raise ValueError("limit parameter must be a non-negative int")
+
+        sync = f"waitForSync: {wait_for_sync}" if wait_for_sync is not None else ""
+        query = f"""
+            FOR doc IN @@collection
+                {self._build_filter_conditions(filters)}
+                {f"LIMIT {limit}" if limit is not None else ""}
+                REMOVE doc IN @@collection
+                {f"OPTIONS {{ {sync} }}" if sync else ""}
+        """  # noqa: E201 E202
+        bind_vars = {"@collection": self.name}
+        data = {"query": query, "bindVars": bind_vars}
+
+        request = Request(
+            method=Method.POST,
+            endpoint="/_api/cursor",
+            data=self.serializer.dumps(data),
+        )
+
+        def response_handler(resp: Response) -> int:
+            if resp.is_success:
+                result = self.deserializer.loads(resp.raw_body)
+                return cast(int, result["extra"]["stats"]["writesExecuted"])
+            raise DocumentDeleteError(resp, request)
+
+        return await self._executor.execute(request, response_handler)
+
     async def insert_many(
         self,
         documents: Sequence[T],

tests/test_document.py

@@ -523,3 +523,33 @@ async def test_document_replace_match(doc_col, bad_col, docs):
     async for doc in await doc_col.find():
         assert doc["val"] != -1
     assert count == 0
+
+
+@pytest.mark.asyncio
+async def test_document_delete_match(doc_col, bad_col, docs):
+    # Check errors first
+    with pytest.raises(DocumentDeleteError):
+        await bad_col.delete_match({})
+    with pytest.raises(ValueError):
+        await doc_col.delete_match({}, limit=-1)
+    with pytest.raises(ValueError):
+        await doc_col.delete_match("abcd")
+
+    # Delete all documents
+    await doc_col.insert_many(docs)
+    count = await doc_col.delete_match({})
+    assert count == len(docs)
+    assert await doc_col.count() == 0
+
+    # Delete documents partially
+    await doc_col.insert_many(docs)
+    count = await doc_col.delete_match({"text": "foo"})
+    async for doc in await doc_col.find():
+        assert doc["text"] != "foo"
+    assert count == sum([1 for doc in docs if doc["text"] == "foo"])
+    await doc_col.truncate()
+
+    # No matching documents
+    await doc_col.insert_many(docs)
+    count = await doc_col.delete_match({"text": "no_matching"})
+    assert count == 0