dj-queue 0.7.0__tar.gz → 0.8.0__tar.gz

{dj_queue-0.7.0 → dj_queue-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dj-queue
-Version: 0.7.0
+Version: 0.8.0
 Summary: Database-backed task queue backend for Django’s Tasks framework.
 License-Expression: MIT
 License-File: LICENSE
@@ -461,7 +461,7 @@ expecting one semaphore namespace per backend alias.
 tables:
 
 ```python
-from dj_queue.api import QueueInfo
+from dj_queue.api import QueueInfo, claim_ready_jobs, execute_claimed_job
 
 orders = QueueInfo("orders")
 
@@ -472,6 +472,10 @@ print(orders.paused)
 orders.pause()
 orders.resume()
 orders.clear()
+
+claimed_jobs = claim_ready_jobs(limit=1, queues=["orders"])
+if claimed_jobs:
+  execute_claimed_job(claimed_jobs[0])
 ```
 
 Notes:
@@ -480,6 +484,8 @@ Notes:
 - pause rows are scoped per backend alias
 - `clear()` discards ready jobs only
 - pass `backend_alias=` when you want to target a non-default `TASKS` alias
+- `claim_ready_jobs()` returns `ClaimedJob` objects, so inspect `claimed_job.job` for the persisted row
+- the low-level claim/execute helpers are exposed on `dj_queue.api` for scripts and examples
 
 Operational commands:
 
@@ -506,32 +512,26 @@ queue database, including the exception class, message, and traceback.
 
 You can retry and discard failed jobs through Django admin, and any raw job
 detail page can enqueue a fresh copy of that stored job. The failed-job actions
-also stay available directly through the operations layer:
+also stay available through the public API:
 
 ```python
-from dj_queue.operations.jobs import discard_failed_job, retry_failed_job
+from dj_queue.api import (
+  discard_blocked_jobs,
+  discard_failed_job,
+  discard_failed_jobs,
+  discard_ready_jobs,
+  discard_scheduled_jobs,
+  retry_failed_job,
+  retry_failed_jobs,
+)
 
 retry_failed_job(job_id)
 discard_failed_job(job_id)
-```
-
-Model helpers are available too:
-
-```python
-from dj_queue.exceptions import UndiscardableError
-from dj_queue.models import ClaimedExecution, FailedExecution
-
-failed = FailedExecution.objects.get(job_id=job_id)
-failed.retry()
-failed.discard()
-
-FailedExecution.retry_all(FailedExecution.objects.order_by("job_id"))
-FailedExecution.discard_all_in_batches()
-
-try:
-  ClaimedExecution.discard_all_in_batches()
-except UndiscardableError:
-  pass
+retry_failed_jobs(job_ids=[job_id_a, job_id_b], batch_size=2)
+discard_ready_jobs(job_ids=[ready_job_id], batch_size=1)
+discard_failed_jobs(batch_size=500)
+discard_scheduled_jobs(job_ids=[scheduled_job_id], batch_size=1)
+discard_blocked_jobs(job_ids=[blocked_job_id], batch_size=1)
 ```
 
 Failures stay inspectable until you act on them.

{dj_queue-0.7.0 → dj_queue-0.8.0}/README.md

@@ -433,7 +433,7 @@ expecting one semaphore namespace per backend alias.
 tables:
 
 ```python
-from dj_queue.api import QueueInfo
+from dj_queue.api import QueueInfo, claim_ready_jobs, execute_claimed_job
 
 orders = QueueInfo("orders")
 
@@ -444,6 +444,10 @@ print(orders.paused)
 orders.pause()
 orders.resume()
 orders.clear()
+
+claimed_jobs = claim_ready_jobs(limit=1, queues=["orders"])
+if claimed_jobs:
+  execute_claimed_job(claimed_jobs[0])
 ```
 
 Notes:
@@ -452,6 +456,8 @@ Notes:
 - pause rows are scoped per backend alias
 - `clear()` discards ready jobs only
 - pass `backend_alias=` when you want to target a non-default `TASKS` alias
+- `claim_ready_jobs()` returns `ClaimedJob` objects, so inspect `claimed_job.job` for the persisted row
+- the low-level claim/execute helpers are exposed on `dj_queue.api` for scripts and examples
 
 Operational commands:
 
@@ -478,32 +484,26 @@ queue database, including the exception class, message, and traceback.
 
 You can retry and discard failed jobs through Django admin, and any raw job
 detail page can enqueue a fresh copy of that stored job. The failed-job actions
-also stay available directly through the operations layer:
+also stay available through the public API:
 
 ```python
-from dj_queue.operations.jobs import discard_failed_job, retry_failed_job
+from dj_queue.api import (
+  discard_blocked_jobs,
+  discard_failed_job,
+  discard_failed_jobs,
+  discard_ready_jobs,
+  discard_scheduled_jobs,
+  retry_failed_job,
+  retry_failed_jobs,
+)
 
 retry_failed_job(job_id)
 discard_failed_job(job_id)
-```
-
-Model helpers are available too:
-
-```python
-from dj_queue.exceptions import UndiscardableError
-from dj_queue.models import ClaimedExecution, FailedExecution
-
-failed = FailedExecution.objects.get(job_id=job_id)
-failed.retry()
-failed.discard()
-
-FailedExecution.retry_all(FailedExecution.objects.order_by("job_id"))
-FailedExecution.discard_all_in_batches()
-
-try:
-  ClaimedExecution.discard_all_in_batches()
-except UndiscardableError:
-  pass
+retry_failed_jobs(job_ids=[job_id_a, job_id_b], batch_size=2)
+discard_ready_jobs(job_ids=[ready_job_id], batch_size=1)
+discard_failed_jobs(batch_size=500)
+discard_scheduled_jobs(job_ids=[scheduled_job_id], batch_size=1)
+discard_blocked_jobs(job_ids=[blocked_job_id], batch_size=1)
 ```
 
 Failures stay inspectable until you act on them.

{dj_queue-0.7.0 → dj_queue-0.8.0}/dj_queue/admin.py

@@ -28,7 +28,13 @@ from dj_queue.models import (
   RecurringTask,
   Semaphore,
 )
-from dj_queue.operations.jobs import dispatch_scheduled_job_now, enqueue_job_again
+from dj_queue.operations.jobs import (
+  discard_failed_job,
+  dispatch_scheduled_job_now,
+  enqueue_job_again,
+  retry_failed_job,
+  retry_failed_jobs,
+)
 
 
 class DjQueueFirstAdminSite(admin.AdminSite):
@@ -648,12 +654,12 @@ class JobAdmin(HiddenSidebarAdminMixin, admin.ModelAdmin):
       return self._current_object_redirect(obj, backend_alias=obj.backend_alias)
 
     if action == "retry":
-      obj.failed_execution.retry()
+      retry_failed_job(obj.failed_execution.job_id, backend_alias=obj.backend_alias)
       self.message_user(request, "Retried failed job", level=messages.SUCCESS)
       return self._current_object_redirect(obj, backend_alias=obj.backend_alias)
 
     if action == "discard":
-      obj.failed_execution.discard()
+      discard_failed_job(obj.failed_execution.job_id, backend_alias=obj.backend_alias)
       self.message_user(request, "Discarded failed job", level=messages.SUCCESS)
       return HttpResponseRedirect(self._changelist_url(backend_alias=obj.backend_alias))
 
@@ -676,14 +682,18 @@ class FailedExecutionAdmin(HiddenSidebarAdminMixin, admin.ModelAdmin):
 
   @admin.action(description="Retry selected failed jobs")
   def retry_jobs(self, request, queryset):
-    retried = FailedExecution.retry_all(queryset)
+    retried = retry_failed_jobs(
+      job_ids=list(queryset.values_list("job_id", flat=True)),
+      batch_size=queryset.count() or 1,
+      backend_alias=self._backend_alias(request),
+    )
     self.message_user(request, f"Retried {retried} failed jobs", level=messages.SUCCESS)
 
   @admin.action(description="Discard selected failed jobs")
   def discard_jobs(self, request, queryset):
     discarded = 0
     for execution in queryset.select_related("job"):
-      discarded += execution.discard()
+      discarded += discard_failed_job(execution.job_id, backend_alias=execution.job.backend_alias)
     self.message_user(request, f"Discarded {discarded} failed jobs", level=messages.SUCCESS)
 
   @admin.display(description="created at", ordering="created_at")
@@ -707,13 +717,13 @@ class FailedExecutionAdmin(HiddenSidebarAdminMixin, admin.ModelAdmin):
 
     if action == "retry":
       job_id = obj.job_id
-      obj.retry()
+      retry_failed_job(job_id, backend_alias=backend_alias)
       self.message_user(request, "Retried failed job", level=messages.SUCCESS)
       url = reverse("admin:dj_queue_job_change", args=[job_id])
       return HttpResponseRedirect(f"{url}?{urlencode({'backend': backend_alias})}")
 
     if action == "discard":
-      obj.discard()
+      discard_failed_job(obj.job_id, backend_alias=backend_alias)
       self.message_user(request, "Discarded failed job", level=messages.SUCCESS)
       return HttpResponseRedirect(self._changelist_url(backend_alias=backend_alias))
 

{dj_queue-0.7.0 → dj_queue-0.8.0}/dj_queue/api.py

@@ -3,10 +3,40 @@ from functools import partial
 from django.db.models.functions import Coalesce
 from django.db import transaction
 from django.utils import timezone
-from django.utils.module_loading import import_string
 
 from dj_queue.db import get_database_alias
 from dj_queue.models import Pause, ReadyExecution
+from dj_queue.operations.jobs import (
+  ClaimedJob,
+  claim_ready_jobs,
+  discard_blocked_jobs,
+  discard_failed_job,
+  discard_failed_jobs,
+  discard_ready_jobs,
+  discard_scheduled_jobs,
+  execute_claimed_job,
+  retry_failed_job,
+  retry_failed_jobs,
+)
+from dj_queue.operations.queues import pause_queue, resume_queue
+from dj_queue.operations.recurring import schedule_recurring_task, unschedule_recurring_task
+
+__all__ = [
+  "ClaimedJob",
+  "QueueInfo",
+  "claim_ready_jobs",
+  "discard_blocked_jobs",
+  "discard_failed_job",
+  "discard_failed_jobs",
+  "discard_ready_jobs",
+  "discard_scheduled_jobs",
+  "enqueue_on_commit",
+  "execute_claimed_job",
+  "retry_failed_job",
+  "retry_failed_jobs",
+  "schedule_recurring_task",
+  "unschedule_recurring_task",
+]
 
 
 class QueueInfo:
@@ -44,11 +74,9 @@ class QueueInfo:
     )
 
   def pause(self):
-    pause_queue = import_string("dj_queue.operations.queues.pause_queue")
     pause_queue(self.queue_name, backend_alias=self.backend_alias)
 
   def resume(self):
-    resume_queue = import_string("dj_queue.operations.queues.resume_queue")
     resume_queue(self.queue_name, backend_alias=self.backend_alias)
 
   def clear(self, *, batch_size=500):
@@ -57,7 +85,7 @@ class QueueInfo:
       job_ids = list(self._ready_queryset().values_list("job_id", flat=True)[:batch_size])
       if not job_ids:
         return deleted
-      deleted += _discard_ready_jobs(
+      deleted += discard_ready_jobs(
         job_ids=job_ids,
         batch_size=batch_size,
         backend_alias=self.backend_alias,
@@ -86,41 +114,5 @@ class QueueInfo:
     )
 
 
-def _discard_ready_jobs(*, job_ids, batch_size, backend_alias):
-  discard_ready_jobs = import_string("dj_queue.operations.jobs.discard_ready_jobs")
-  return discard_ready_jobs(job_ids=job_ids, batch_size=batch_size, backend_alias=backend_alias)
-
-
 def enqueue_on_commit(task, *args, using=None, **kwargs):
   transaction.on_commit(partial(task.enqueue, *args, **kwargs), using=using)
-
-
-def schedule_recurring_task(
-  *,
-  key,
-  task_path,
-  schedule,
-  args=(),
-  kwargs=None,
-  queue_name="default",
-  priority=0,
-  description="",
-  backend_alias="default",
-):
-  operation = import_string("dj_queue.operations.recurring.schedule_recurring_task")
-  return operation(
-    key=key,
-    task_path=task_path,
-    schedule=schedule,
-    args=args,
-    kwargs=kwargs,
-    queue_name=queue_name,
-    priority=priority,
-    description=description,
-    backend_alias=backend_alias,
-  )
-
-
-def unschedule_recurring_task(key, *, backend_alias="default"):
-  operation = import_string("dj_queue.operations.recurring.unschedule_recurring_task")
-  return operation(key, backend_alias=backend_alias)

{dj_queue-0.7.0 → dj_queue-0.8.0}/dj_queue/dashboard.py

@@ -13,13 +13,14 @@ from dj_queue import observability
 from dj_queue.api import QueueInfo
 from dj_queue.config import load_backend_config
 from dj_queue.db import database_capabilities, get_database_alias
-from dj_queue.models import FailedExecution, Job
+from dj_queue.models import Job
 from dj_queue.operations.jobs import (
   discard_blocked_jobs,
   discard_failed_jobs,
   discard_ready_jobs,
   discard_scheduled_jobs,
   enqueue_job_again,
+  retry_failed_jobs,
 )
 
 QUEUE_STATE_CONFIG = {
@@ -521,13 +522,11 @@ def apply_job_action(*, backend_alias, queue_name, state, action, job_ids):
     return f"discarded {deleted} blocked jobs from {queue_name}"
 
   if state == "failed" and action == "retry":
-    alias = get_database_alias(backend_alias)
-    queryset = FailedExecution.objects.using(alias).filter(
-      job_id__in=job_ids,
-      job__backend_alias=backend_alias,
-      job__queue_name=queue_name,
+    retried = retry_failed_jobs(
+      job_ids=job_ids,
+      batch_size=max(len(job_ids), 1),
+      backend_alias=backend_alias,
     )
-    retried = FailedExecution.retry_all(queryset.select_related("job"))
     return f"retried {retried} failed jobs from {queue_name}"
 
   if state == "failed" and action == "discard":

{dj_queue-0.7.0 → dj_queue-0.8.0}/dj_queue/exceptions.py

@@ -6,10 +6,6 @@ class EnqueueError(DjQueueError):
   pass
 
 
-class UndiscardableError(DjQueueError):
-  pass
-
-
 class AlreadyRecorded(DjQueueError):
   pass
 

{dj_queue-0.7.0 → dj_queue-0.8.0}/dj_queue/migrations/0008_remove_blockedexecution_dj_queue_bl_concurr_1ce730_idx_and_more.py

@@ -98,68 +98,64 @@ class Migration(migrations.Migration):
       model_name="blockedexecution",
       index=models.Index(
         fields=["backend_alias", "concurrency_key", "priority", "id"],
-        name="dj_queue_bl_backend_conc_idx",
+        name="djq_bl_b_conc_idx",
       ),
     ),
     migrations.AddIndex(
       model_name="blockedexecution",
       index=models.Index(
         fields=["backend_alias", "expires_at", "concurrency_key"],
-        name="dj_queue_bl_backend_exp_conc_idx",
+        name="djq_bl_b_exp_conc_idx",
       ),
     ),
     migrations.AddIndex(
       model_name="blockedexecution",
       index=models.Index(
         fields=["backend_alias", "concurrency_key", "-priority", "id"],
-        name="dj_queue_bl_backend_conc_desc_idx",
+        name="djq_bl_b_conc_d_idx",
       ),
     ),
     migrations.AddIndex(
       model_name="blockedexecution",
       index=models.Index(
         fields=["backend_alias", "expires_at", "-priority", "id"],
-        name="dj_queue_bl_backend_exp_desc_idx",
+        name="djq_bl_b_exp_d_idx",
       ),
     ),
     migrations.AddIndex(
       model_name="readyexecution",
-      index=models.Index(
-        fields=["backend_alias", "priority", "id"], name="dj_queue_re_backend_prio_idx"
-      ),
+      index=models.Index(fields=["backend_alias", "priority", "id"], name="djq_re_b_prio_idx"),
     ),
     migrations.AddIndex(
       model_name="readyexecution",
       index=models.Index(
         fields=["backend_alias", "queue_name", "priority", "id"],
-        name="dj_queue_re_backend_queue_idx",
+        name="djq_re_b_queue_idx",
       ),
     ),
     migrations.AddIndex(
       model_name="readyexecution",
-      index=models.Index(
-        fields=["backend_alias", "-priority", "id"], name="dj_queue_re_backend_prio_desc_idx"
-      ),
+      index=models.Index(fields=["backend_alias", "-priority", "id"], name="djq_re_b_prio_d_idx"),
     ),
     migrations.AddIndex(
       model_name="readyexecution",
       index=models.Index(
         fields=["backend_alias", "queue_name", "-priority", "id"],
-        name="dj_queue_re_backend_queue_desc_idx",
+        name="djq_re_b_queue_d_idx",
       ),
     ),
     migrations.AddIndex(
       model_name="scheduledexecution",
       index=models.Index(
         fields=["backend_alias", "scheduled_at", "priority", "id"],
-        name="dj_queue_se_backend_due_idx",
+        name="djq_se_b_due_idx",
       ),
     ),
     migrations.AddIndex(
       model_name="scheduledexecution",
       index=models.Index(
         fields=["backend_alias", "scheduled_at", "-priority", "id"],
-        name="dj_queue_se_backend_due_desc_idx",
+        name="djq_se_b_due_d_idx",
       ),
     ),
   ]

{dj_queue-0.7.0 → dj_queue-0.8.0}/dj_queue/models/jobs.py

@@ -3,10 +3,6 @@ import uuid
 from django.core.exceptions import ObjectDoesNotExist
 from django.db import models
 from django.db.models import Q
-from django.utils.module_loading import import_string
-
-from dj_queue.db import get_database_alias
-from dj_queue.exceptions import UndiscardableError
 
 JOB_STATUS_RELATIONS = (
   ("ready", "ready_execution"),
@@ -125,33 +121,21 @@ class ReadyExecution(models.Model):
   class Meta:
     db_table = "dj_queue_ready_executions"
     indexes = [
-      models.Index(
-        fields=["backend_alias", "priority", "id"], name="dj_queue_re_backend_prio_idx"
-      ),
+      models.Index(fields=["backend_alias", "priority", "id"], name="djq_re_b_prio_idx"),
       models.Index(
         fields=["backend_alias", "queue_name", "priority", "id"],
-        name="dj_queue_re_backend_queue_idx",
+        name="djq_re_b_queue_idx",
       ),
       models.Index(
         fields=["backend_alias", "-priority", "id"],
-        name="dj_queue_re_backend_prio_desc_idx",
+        name="djq_re_b_prio_d_idx",
       ),
       models.Index(
         fields=["backend_alias", "queue_name", "-priority", "id"],
-        name="dj_queue_re_backend_queue_desc_idx",
+        name="djq_re_b_queue_d_idx",
       ),
     ]
 
-  @classmethod
-  def discard_all_in_batches(cls, *, batch_size=500, backend_alias="default"):
-    operation = import_string("dj_queue.operations.jobs.discard_ready_jobs")
-    return _discard_jobs_for_state(
-      cls,
-      operation,
-      batch_size=batch_size,
-      backend_alias=backend_alias,
-    )
-
 
 class ScheduledExecution(models.Model):
   job = models.OneToOneField(
@@ -170,11 +154,11 @@ class ScheduledExecution(models.Model):
     indexes = [
       models.Index(
         fields=["backend_alias", "scheduled_at", "priority", "id"],
-        name="dj_queue_se_backend_due_idx",
+        name="djq_se_b_due_idx",
       ),
       models.Index(
         fields=["backend_alias", "scheduled_at", "-priority", "id"],
-        name="dj_queue_se_backend_due_desc_idx",
+        name="djq_se_b_due_d_idx",
       ),
     ]
 
@@ -198,10 +182,6 @@ class ClaimedExecution(models.Model):
     db_table = "dj_queue_claimed_executions"
     indexes = [models.Index(fields=["process", "job"])]
 
-  @classmethod
-  def discard_all_in_batches(cls, **_kwargs):
-    raise UndiscardableError("cannot discard in-progress jobs")
-
 
 class BlockedExecution(models.Model):
   job = models.OneToOneField(
@@ -221,32 +201,22 @@ class BlockedExecution(models.Model):
     indexes = [
       models.Index(
         fields=["backend_alias", "concurrency_key", "priority", "id"],
-        name="dj_queue_bl_backend_conc_idx",
+        name="djq_bl_b_conc_idx",
       ),
       models.Index(
         fields=["backend_alias", "expires_at", "concurrency_key"],
-        name="dj_queue_bl_backend_exp_conc_idx",
+        name="djq_bl_b_exp_conc_idx",
       ),
       models.Index(
         fields=["backend_alias", "concurrency_key", "-priority", "id"],
-        name="dj_queue_bl_backend_conc_desc_idx",
+        name="djq_bl_b_conc_d_idx",
       ),
       models.Index(
         fields=["backend_alias", "expires_at", "-priority", "id"],
-        name="dj_queue_bl_backend_exp_desc_idx",
+        name="djq_bl_b_exp_d_idx",
       ),
     ]
 
-  @classmethod
-  def discard_all_in_batches(cls, *, batch_size=500, backend_alias="default"):
-    operation = import_string("dj_queue.operations.jobs.discard_blocked_jobs")
-    return _discard_jobs_for_state(
-      cls,
-      operation,
-      batch_size=batch_size,
-      backend_alias=backend_alias,
-    )
-
 
 class FailedExecution(models.Model):
   job = models.OneToOneField(
@@ -262,56 +232,3 @@ class FailedExecution(models.Model):
   class Meta:
     db_table = "dj_queue_failed_executions"
     indexes = [models.Index(fields=["created_at", "job"])]
-
-  def retry(self):
-    return _retry_failed_job(self.job_id, backend_alias=self.job.backend_alias)
-
-  def discard(self):
-    return _discard_failed_job(self.job_id, backend_alias=self.job.backend_alias)
-
-  @classmethod
-  def retry_all(cls, queryset):
-    retried = 0
-    for execution in queryset.select_related("job"):
-      execution.retry()
-      retried += 1
-    return retried
-
-  @classmethod
-  def discard_all_in_batches(cls, *, batch_size=500, backend_alias="default"):
-    operation = import_string("dj_queue.operations.jobs.discard_failed_jobs")
-    return _discard_jobs_for_state(
-      cls,
-      operation,
-      batch_size=batch_size,
-      backend_alias=backend_alias,
-    )
-
-
-def _retry_failed_job(job_id, *, backend_alias):
-  operation = import_string("dj_queue.operations.jobs.retry_failed_job")
-  return operation(job_id, backend_alias=backend_alias)
-
-
-def _discard_failed_job(job_id, *, backend_alias):
-  operation = import_string("dj_queue.operations.jobs.discard_failed_job")
-  return operation(job_id, backend_alias=backend_alias)
-
-
-def _discard_jobs_for_state(model, operation, *, batch_size, backend_alias):
-  alias = get_database_alias(backend_alias)
-  deleted = 0
-  while True:
-    filter_kwargs = (
-      {"backend_alias": backend_alias}
-      if any(field.name == "backend_alias" for field in model._meta.fields)
-      else {"job__backend_alias": backend_alias}
-    )
-    job_ids = list(
-      model.objects.using(alias)
-      .filter(**filter_kwargs)
-      .values_list("job_id", flat=True)[:batch_size]
-    )
-    if not job_ids:
-      return deleted
-    deleted += operation(job_ids=job_ids, batch_size=batch_size, backend_alias=backend_alias)

dj_queue-0.8.0/dj_queue/operations/_helpers.py

@@ -0,0 +1,41 @@
+import json
+
+from dj_queue.db import database_capabilities
+from dj_queue.exceptions import EnqueueError
+from dj_queue.models import Pause
+
+
+def _normalize_payload(args, kwargs):
+  try:
+    return json.loads(json.dumps({"args": list(args), "kwargs": dict(kwargs)}))
+  except (TypeError, ValueError) as exc:
+    raise EnqueueError("payload must be JSON round-trippable") from exc
+
+
+def _task_option(task, name, default=None):
+  if hasattr(task, name):
+    return getattr(task, name)
+  return getattr(task.func, name, default)
+
+
+def _lock_active_pauses(alias, backend_alias, queue_names=None):
+  queryset = Pause.objects.using(alias).select_for_update().filter(backend_alias=backend_alias)
+  if queue_names is not None:
+    active_queue_names = tuple(queue_name for queue_name in queue_names if queue_name)
+    if not active_queue_names:
+      return set()
+    queryset = queryset.filter(queue_name__in=active_queue_names)
+  return set(queryset.values_list("queue_name", flat=True))
+
+
+def _consume_selected_rows(alias, model, rows):
+  if not database_capabilities(alias).uses_serialized_writes:
+    model.objects.using(alias).filter(pk__in=[row.pk for row in rows]).delete()
+    return rows
+
+  consumed_rows = []
+  for row in rows:
+    deleted, _ = model.objects.using(alias).filter(pk=row.pk).delete()
+    if deleted:
+      consumed_rows.append(row)
+  return consumed_rows