dj-queue 0.10.3__tar.gz → 0.10.4__tar.gz

{dj_queue-0.10.3 → dj_queue-0.10.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dj-queue
-Version: 0.10.3
+Version: 0.10.4
 Summary: Database-backed task queue backend for Django’s Tasks framework.
 License-Expression: MIT
 License-File: LICENSE
@@ -61,6 +61,9 @@ It has a narrow, explicit shape:
 For detailed comparisons with Celery, RQ, Procrastinate, and other alternatives,
 see [COMPARISONS.md](docs/COMPARISONS.md).
 
+For benchmarks on enqueue, promotion, recurring, claiming, worker-drain, and concurrency-contention scenarios,
+see [docs/benchmarks/](docs/benchmarks/) for the latest published reports.
+
 ## Installation
 
 `dj_queue` requires Python 3.12+ and Django 6.0+.
@@ -640,8 +643,9 @@ Run your normal application migrations on `default`, then migrate `dj_queue`
 onto the queue database:
 
 ```bash
-python manage.py migrate
+# migrate dj_queue on its queue alias first so django doesn't mark it applied on default
 python manage.py migrate dj_queue --database queue
+python manage.py migrate
 ```
 
 With this setup, `dj_queue`'s ORM queries and raw SQL helpers stay on the queue
@@ -1012,11 +1016,6 @@ Both endpoints support bearer token authentication. Set
 `Authorization: Bearer <token>`. Leave it unset if you protect these URLs at
 the network or proxy layer.
 
-## Benchmarks
-
-The repository includes a standalone benchmark harness for enqueue, promotion, recurring, worker-drain, and concurrency-contention scenarios. 
-See [`docs/benchmarks/`](docs/benchmarks/) for the latest published reports.
-
 ## License
 
 MIT

{dj_queue-0.10.3 → dj_queue-0.10.4}/README.md

@@ -35,6 +35,9 @@ It has a narrow, explicit shape:
 For detailed comparisons with Celery, RQ, Procrastinate, and other alternatives,
 see [COMPARISONS.md](docs/COMPARISONS.md).
 
+For benchmarks on enqueue, promotion, recurring, claiming, worker-drain, and concurrency-contention scenarios,
+see [docs/benchmarks/](docs/benchmarks/) for the latest published reports.
+
 ## Installation
 
 `dj_queue` requires Python 3.12+ and Django 6.0+.
@@ -614,8 +617,9 @@ Run your normal application migrations on `default`, then migrate `dj_queue`
 onto the queue database:
 
 ```bash
-python manage.py migrate
+# migrate dj_queue on its queue alias first so django doesn't mark it applied on default
 python manage.py migrate dj_queue --database queue
+python manage.py migrate
 ```
 
 With this setup, `dj_queue`'s ORM queries and raw SQL helpers stay on the queue
@@ -986,11 +990,6 @@ Both endpoints support bearer token authentication. Set
 `Authorization: Bearer <token>`. Leave it unset if you protect these URLs at
 the network or proxy layer.
 
-## Benchmarks
-
-The repository includes a standalone benchmark harness for enqueue, promotion, recurring, worker-drain, and concurrency-contention scenarios. 
-See [`docs/benchmarks/`](docs/benchmarks/) for the latest published reports.
-
 ## License
 
 MIT

{dj_queue-0.10.3 → dj_queue-0.10.4}/dj_queue/backend.py

@@ -28,7 +28,13 @@ class DjQueueBackend(BaseTaskBackend):
 
   def enqueue(self, task, args, kwargs):
     self.validate_task(task)
-    job, dispatch_outcome = enqueue_job_with_dispatch(task, args, kwargs, backend_alias=self.alias)
+    job, dispatch_outcome = enqueue_job_with_dispatch(
+      task,
+      args,
+      kwargs,
+      backend_alias=self.alias,
+      validate=False,
+    )
     return task_result_from_enqueued_job(
       job,
       task,
@@ -49,7 +55,7 @@ class DjQueueBackend(BaseTaskBackend):
       self.validate_task(task)
       jobs.append((task, args, kwargs))
 
-    created_jobs = enqueue_jobs_bulk(jobs, backend_alias=self.alias)
+    created_jobs = enqueue_jobs_bulk(jobs, backend_alias=self.alias, validate=False)
     return [
       task_result_from_enqueued_job(
         job,

{dj_queue-0.10.3 → dj_queue-0.10.4}/dj_queue/operations/_helpers.py

@@ -170,8 +170,11 @@ def _scheduled_execution_row(job, *, backend_alias, scheduled_at=None, created_a
   )
 
 
-def _create_scheduled_execution(alias, job, *, backend_alias, scheduled_at=None):
-  _ensure_no_other_execution_state(alias, job)
+def _create_scheduled_execution(
+  alias, job, *, backend_alias, scheduled_at=None, check_conflicts=True
+):
+  if check_conflicts:
+    _ensure_no_other_execution_state(alias, job)
   return ScheduledExecution.objects.using(alias).create(
     **_scheduled_execution_fields(
       job,
@@ -190,8 +193,10 @@ def _create_blocked_execution(
   expires_at,
   queue_name=None,
   priority=None,
+  check_conflicts=True,
 ):
-  _ensure_no_other_execution_state(alias, job)
+  if check_conflicts:
+    _ensure_no_other_execution_state(alias, job)
   return BlockedExecution.objects.using(alias).create(
     **_blocked_execution_fields(
       job,

{dj_queue-0.10.3 → dj_queue-0.10.4}/dj_queue/operations/concurrency.py

@@ -22,7 +22,7 @@ from dj_queue.models import (
 from dj_queue.operations._helpers import (
   _consume_selected_rows,
   _create_blocked_execution,
-  _create_ready_execution,
+  _create_ready_execution_locked,
   _lock_active_pauses,
   _task_option,
 )
@@ -247,20 +247,15 @@ def unblock_next_blocked_job(
   now = timezone.now()
 
   with _operation_atomic(alias):
-    queryset = (
-      BlockedExecution.objects.using(alias)
-      .select_related("job")
-      .filter(backend_alias=backend_alias, concurrency_key=key)
-      .order_by("-priority", "id")
+    blocked = _consume_next_blocked_job(
+      alias,
+      backend_alias=backend_alias,
+      key=key,
+      use_skip_locked=use_skip_locked,
     )
-    blocked = locked_queryset(queryset, use_skip_locked=use_skip_locked).first()
     if blocked is None:
       return None
 
-    consumed = _consume_selected_rows(alias, BlockedExecution, [blocked])
-    if not consumed:
-      return None
-
     slot_acquired = False
     if release_slot:
       slot_acquired = _handoff_released_claimed_slot(
@@ -287,37 +282,125 @@ def unblock_next_blocked_job(
         backend_alias=backend_alias,
       )
 
+    mock_job = Job(
+      id=blocked["job_id"],
+      queue_name=blocked["queue_name"],
+      priority=blocked["priority"],
+      concurrency_key=blocked["concurrency_key"],
+      backend_alias=backend_alias,
+    )
+
     if not slot_acquired:
       _create_blocked_execution(
         alias,
-        blocked.job,
+        mock_job,
         backend_alias=backend_alias,
-        queue_name=blocked.queue_name,
-        priority=blocked.priority,
-        concurrency_key=blocked.concurrency_key,
-        expires_at=blocked.expires_at,
+        queue_name=blocked["queue_name"],
+        priority=blocked["priority"],
+        concurrency_key=blocked["concurrency_key"],
+        expires_at=blocked["expires_at"],
+        check_conflicts=False,
       )
       return None
 
-    job = blocked.job
-    queue_name = blocked.queue_name
-    priority = blocked.priority
     _create_ready_execution_after_blocked_consume(
       alias,
-      job=job,
+      job=mock_job,
       backend_alias=backend_alias,
-      queue_name=queue_name,
-      priority=priority,
+      queue_name=blocked["queue_name"],
+      priority=blocked["priority"],
       ready_at=now,
     )
 
   log_event(
     "job.unblocked",
-    job_id=str(job.id),
+    job_id=str(mock_job.id),
     concurrency_key=key,
   )
-  notify_ready_queues_on_commit((job.queue_name,), backend_alias=backend_alias)
-  return job
+  notify_ready_queues_on_commit((blocked["queue_name"],), backend_alias=backend_alias)
+  return mock_job
+
+
+def _consume_next_blocked_job(alias, *, backend_alias, key, use_skip_locked):
+  capabilities = database_capabilities(alias)
+  if capabilities.backend_family == "postgresql":
+    return _postgres_consume_next_blocked_job(
+      alias,
+      backend_alias=backend_alias,
+      key=key,
+      use_skip_locked=use_skip_locked and capabilities.supports_skip_locked,
+    )
+
+  queryset = (
+    BlockedExecution.objects.using(alias)
+    .filter(backend_alias=backend_alias, concurrency_key=key)
+    .order_by("-priority", "id")
+  )
+  blocked = locked_queryset(queryset, use_skip_locked=use_skip_locked).first()
+  if blocked is None:
+    return None
+
+  consumed = _consume_selected_rows(alias, BlockedExecution, [blocked])
+  if not consumed:
+    return None
+  return _blocked_execution_values(blocked)
+
+
+def _postgres_consume_next_blocked_job(alias, *, backend_alias, key, use_skip_locked):
+  connection = connections[alias]
+  quote = connection.ops.quote_name
+  table = quote(BlockedExecution._meta.db_table)
+  pk_column = quote(BlockedExecution._meta.pk.column)
+  job_id_column = quote(BlockedExecution._meta.get_field("job").column)
+  backend_alias_column = quote(BlockedExecution._meta.get_field("backend_alias").column)
+  queue_name_column = quote(BlockedExecution._meta.get_field("queue_name").column)
+  priority_column = quote(BlockedExecution._meta.get_field("priority").column)
+  concurrency_key_column = quote(BlockedExecution._meta.get_field("concurrency_key").column)
+  expires_at_column = quote(BlockedExecution._meta.get_field("expires_at").column)
+  skip_locked_sql = " SKIP LOCKED" if use_skip_locked else ""
+
+  with connection.cursor() as cursor:
+    cursor.execute(
+      f"""
+      DELETE FROM {table}
+      WHERE {table}.{pk_column} = (
+        SELECT {pk_column}
+        FROM {table}
+        WHERE {backend_alias_column} = %s AND {concurrency_key_column} = %s
+        ORDER BY {priority_column} DESC, {pk_column} ASC
+        LIMIT 1
+        FOR UPDATE{skip_locked_sql}
+      )
+      RETURNING
+        {job_id_column},
+        {queue_name_column},
+        {priority_column},
+        {concurrency_key_column},
+        {expires_at_column}
+      """,
+      [backend_alias, key],
+    )
+    row = cursor.fetchone()
+
+  if row is None:
+    return None
+  return {
+    "job_id": row[0],
+    "queue_name": row[1],
+    "priority": row[2],
+    "concurrency_key": row[3],
+    "expires_at": row[4],
+  }
+
+
+def _blocked_execution_values(blocked):
+  return {
+    "job_id": blocked.job_id,
+    "queue_name": blocked.queue_name,
+    "priority": blocked.priority,
+    "concurrency_key": blocked.concurrency_key,
+    "expires_at": blocked.expires_at,
+  }
 
 
 def _create_ready_execution_after_blocked_consume(
@@ -455,13 +538,14 @@ def promote_expired_blocked_jobs(*, batch_size=500, backend_alias="default", use
         priority = blocked.priority
         if not uses_serialized_writes:
           blocked.delete(using=alias)
-        _create_ready_execution(
+        _create_ready_execution_locked(
           alias,
           job=job,
           backend_alias=backend_alias,
           queue_name=queue_name,
           priority=priority,
           ready_at=now,
+          check_conflicts=False,
         )
         promoted_jobs.append(job)
       else:
@@ -475,6 +559,7 @@ def promote_expired_blocked_jobs(*, batch_size=500, backend_alias="default", use
             priority=blocked.priority,
             concurrency_key=blocked.concurrency_key,
             expires_at=expires_at,
+            check_conflicts=False,
           )
         else:
           blocked.expires_at = expires_at

{dj_queue-0.10.3 → dj_queue-0.10.4}/dj_queue/operations/jobs.py

@@ -6,7 +6,6 @@ from dataclasses import dataclass
 from datetime import timedelta
 from enum import StrEnum
 
-from django.core.exceptions import ObjectDoesNotExist
 from django.db import connections, transaction
 from django.db.models import Case, IntegerField, Value, When
 from django.db.utils import OperationalError
@@ -15,7 +14,7 @@ from django.utils import timezone
 from django.utils.module_loading import import_string
 
 from dj_queue.config import load_allowed_queues, load_backend_config
-from dj_queue.db import get_database_alias, locked_queryset
+from dj_queue.db import database_capabilities, get_database_alias, locked_queryset
 from dj_queue.exceptions import EnqueueError
 from dj_queue.log import event_logging_enabled, log_event
 from dj_queue.models import (
@@ -92,9 +91,10 @@ def enqueue_job(task, args, kwargs, *, backend_alias="default"):
   return job
 
 
-def enqueue_job_with_dispatch(task, args, kwargs, *, backend_alias="default"):
-  validate_queue_allowed(task.queue_name, backend_alias=backend_alias)
-  validate_priority(task.priority)
+def enqueue_job_with_dispatch(task, args, kwargs, *, backend_alias="default", validate=True):
+  if validate:
+    validate_queue_allowed(task.queue_name, backend_alias=backend_alias)
+    validate_priority(task.priority)
   alias = get_database_alias(backend_alias)
   payload = _normalize_payload(args, kwargs)
   concurrency_key = _resolve_concurrency_key(task, args, kwargs)
@@ -130,14 +130,15 @@ def enqueue_job_with_dispatch(task, args, kwargs, *, backend_alias="default"):
   return job, dispatch_outcome
 
 
-def enqueue_jobs_bulk(task_calls, *, backend_alias="default"):
+def enqueue_jobs_bulk(task_calls, *, backend_alias="default", validate=True):
   alias = get_database_alias(backend_alias)
   now = timezone.now()
   prepared = []
 
   for index, (task, args, kwargs) in enumerate(task_calls):
-    validate_queue_allowed(task.queue_name, backend_alias=backend_alias)
-    validate_priority(task.priority)
+    if validate:
+      validate_queue_allowed(task.queue_name, backend_alias=backend_alias)
+      validate_priority(task.priority)
     payload = _normalize_payload(args, kwargs)
     concurrency_key = _resolve_concurrency_key(task, args, kwargs)
     created_at = now + timedelta(microseconds=index)
@@ -318,16 +319,9 @@ def _claim_ready_jobs_once(
 ):
 
   with transaction.atomic(using=alias):
+    claimed_insert_checks_conflicts = _claimed_insert_checks_conflicts(alias)
     queryset = (
-      ReadyExecution.objects.using(alias)
-      .select_related(
-        "job",
-        "job__scheduled_execution",
-        "job__claimed_execution",
-        "job__blocked_execution",
-        "job__failed_execution",
-      )
-      .filter(backend_alias=backend_alias)
+      ReadyExecution.objects.using(alias).select_related("job").filter(backend_alias=backend_alias)
     )
     queryset = _exclude_active_pauses(queryset, alias, backend_alias)
     ready_rows = _select_ready_rows(
@@ -339,9 +333,15 @@ def _claim_ready_jobs_once(
     if not ready_rows:
       return []
 
-    for row in ready_rows:
-      if _ready_row_has_conflicting_state(row):
-        raise EnqueueError(f"job {row.job_id} already has an execution-state row")
+    if not claimed_insert_checks_conflicts:
+      conflicting_job_ids = _job_ids_with_other_execution_state(
+        alias,
+        [row.job_id for row in ready_rows],
+        ignored_models=(ReadyExecution,),
+      )
+      if conflicting_job_ids:
+        conflicting_job_id = next(iter(conflicting_job_ids))
+        raise EnqueueError(f"job {conflicting_job_id} already has an execution-state row")
 
     paused_queue_names = _lock_active_pauses(
       alias,
@@ -361,30 +361,17 @@ def _claim_ready_jobs_once(
 
     claimed_at = timezone.now()
     worker_ids = (process.name,) if process is not None else ()
-    _bulk_create(
+    _create_claimed_executions(
       alias,
-      ClaimedExecution,
-      [ClaimedExecution(job=job, process=process, created_at=claimed_at) for job in jobs],
+      jobs,
+      process=process,
+      claimed_at=claimed_at,
+      check_conflicts=claimed_insert_checks_conflicts,
     )
 
   return [ClaimedJob(job=job, claimed_at=claimed_at, worker_ids=worker_ids) for job in jobs]
 
 
-def _ready_row_has_conflicting_state(row):
-  for relation_name in (
-    "scheduled_execution",
-    "claimed_execution",
-    "blocked_execution",
-    "failed_execution",
-  ):
-    try:
-      getattr(row.job, relation_name)
-    except ObjectDoesNotExist:
-      continue
-    return True
-  return False
-
-
 def execute_claimed_job(job, *, backend_alias="default"):
   claimed_job = None
   if isinstance(job, ClaimedJob):
@@ -432,13 +419,22 @@ def _complete_claimed_job(job, return_value, *, backend_alias="default", task=No
   job = _resolve_claimed_job(job, alias=alias, backend_alias=backend_alias)
 
   with transaction.atomic(using=alias):
-    _delete_claimed_execution(alias, job.id)
     now = timezone.now()
     config = load_backend_config(job.backend_alias)
 
     if config.preserve_finished_jobs:
-      _finish_job_if_no_execution_state(alias, job, return_value, finished_at=now)
+      if database_capabilities(alias).backend_family == "postgresql":
+        _delete_claimed_and_finish_job_if_no_execution_state(
+          alias,
+          job,
+          return_value,
+          finished_at=now,
+        )
+      else:
+        _delete_claimed_execution(alias, job.id)
+        _finish_job_if_no_execution_state(alias, job, return_value, finished_at=now)
     else:
+      _delete_claimed_execution(alias, job.id)
       _ensure_no_other_execution_state(alias, job, ignored_models=(ClaimedExecution,))
       job.delete(using=alias)
 
@@ -674,7 +670,7 @@ def promote_scheduled_jobs(*, batch_size, backend_alias="default", use_skip_lock
     for job in jobs:
       if job.pk in direct_job_ids:
         continue
-      dispatch_outcome = _dispatch_existing_job(job)
+      dispatch_outcome = _dispatch_existing_job(job, check_conflicts=False)
       if dispatch_outcome.should_notify:
         ready_queue_names.append(job.queue_name)
 
@@ -907,9 +903,11 @@ def discard_blocked_jobs(*, job_ids=None, batch_size=500, backend_alias="default
   )
 
 
-def _dispatch_existing_job(job):
+def _dispatch_existing_job(job, *, check_conflicts=True):
   task = import_string(job.task_path)
-  return _dispatch_job(job, task=task, backend_alias=job.backend_alias)
+  return _dispatch_job(
+    job, task=task, backend_alias=job.backend_alias, check_conflicts=check_conflicts
+  )
 
 
 def _dispatch_job(job, *, task, backend_alias, now=None, check_conflicts=True):
@@ -923,6 +921,7 @@ def _dispatch_job(job, *, task, backend_alias, now=None, check_conflicts=True):
       job=job,
       backend_alias=backend_alias,
       scheduled_at=job.scheduled_at,
+      check_conflicts=check_conflicts,
     )
     return DispatchOutcome.SCHEDULED
 
@@ -966,6 +965,7 @@ def _dispatch_job(job, *, task, backend_alias, now=None, check_conflicts=True):
     backend_alias=backend_alias,
     concurrency_key=job.concurrency_key,
     expires_at=now + timedelta(seconds=duration_seconds),
+    check_conflicts=check_conflicts,
   )
   return DispatchOutcome.BLOCKED
 
@@ -1107,6 +1107,105 @@ def _select_ready_rows(queryset, *, limit, queues, use_skip_locked):
   return selected_rows
 
 
+def _claimed_insert_checks_conflicts(alias):
+  return database_capabilities(alias).backend_family == "postgresql"
+
+
+def _create_claimed_executions(alias, jobs, *, process, claimed_at, check_conflicts):
+  if check_conflicts:
+    return _postgres_create_claimed_executions_if_no_other_state(
+      alias,
+      jobs,
+      process=process,
+      claimed_at=claimed_at,
+    )
+
+  return _bulk_create(
+    alias,
+    ClaimedExecution,
+    [ClaimedExecution(job=job, process=process, created_at=claimed_at) for job in jobs],
+  )
+
+
+def _postgres_create_claimed_executions_if_no_other_state(
+  alias,
+  jobs,
+  *,
+  process,
+  claimed_at,
+):
+  connection = connections[alias]
+  quote = connection.ops.quote_name
+  claimed_table = quote(ClaimedExecution._meta.db_table)
+  job_id_column = quote(ClaimedExecution._meta.get_field("job").column)
+  process_id_column = quote(ClaimedExecution._meta.get_field("process").column)
+  created_at_column = quote(ClaimedExecution._meta.get_field("created_at").column)
+  values_sql = ", ".join(["(%s::uuid, %s::bigint, %s::timestamptz)"] * len(jobs))
+  state_checks = " AND ".join(
+    _state_absence_for_job_id_sql(
+      model,
+      job_id_reference="claimed_input.job_id",
+      quote=quote,
+    )
+    for model in (
+      ReadyExecution,
+      ScheduledExecution,
+      ClaimedExecution,
+      BlockedExecution,
+      FailedExecution,
+    )
+  )
+  params = []
+  process_id = process.pk if process is not None else None
+  job_id_field = Job._meta.get_field("id")
+  for job in jobs:
+    params.extend(
+      [
+        job_id_field.get_db_prep_value(job.pk, connection=connection, prepared=False),
+        process_id,
+        claimed_at,
+      ]
+    )
+
+  with connection.cursor() as cursor:
+    cursor.execute(
+      f"""
+      INSERT INTO {claimed_table} (
+        {job_id_column},
+        {process_id_column},
+        {created_at_column}
+      )
+      SELECT
+        claimed_input.job_id,
+        claimed_input.process_id,
+        claimed_input.created_at
+      FROM (VALUES {values_sql}) AS claimed_input(job_id, process_id, created_at)
+      WHERE {state_checks}
+      """,
+      params,
+    )
+    created = cursor.rowcount
+
+  if created != len(jobs):
+    conflicting_job_ids = _job_ids_with_other_execution_state(alias, [job.pk for job in jobs])
+    if conflicting_job_ids:
+      conflicting_job_id = next(iter(conflicting_job_ids))
+      raise EnqueueError(f"job {conflicting_job_id} already has an execution-state row")
+    raise EnqueueError("could not claim selected jobs")
+  return None
+
+
+def _state_absence_for_job_id_sql(model, *, job_id_reference, quote):
+  state_table = quote(model._meta.db_table)
+  state_job_id_column = quote(model._meta.get_field("job").column)
+  return (
+    f"NOT EXISTS ("
+    f"SELECT 1 FROM {state_table} "
+    f"WHERE {state_table}.{state_job_id_column} = {job_id_reference}"
+    f")"
+  )
+
+
 def _select_exact_selector_rows(queryset, selectors, *, limit, use_skip_locked):
   selected_rows = []
   for selector in dict.fromkeys(selectors):
@@ -1182,6 +1281,74 @@ def _delete_claimed_execution(alias, job_id):
     raise ClaimedExecution.DoesNotExist
 
 
+def _delete_claimed_and_finish_job_if_no_execution_state(alias, job, return_value, *, finished_at):
+  connection = connections[alias]
+  quote = connection.ops.quote_name
+  claimed_table = quote(ClaimedExecution._meta.db_table)
+  claimed_job_id_column = quote(ClaimedExecution._meta.get_field("job").column)
+  jobs_table = quote(Job._meta.db_table)
+  job_id_column = quote(Job._meta.get_field("id").column)
+  backend_alias_column = quote(Job._meta.get_field("backend_alias").column)
+  finished_at_column = quote(Job._meta.get_field("finished_at").column)
+  return_value_column = quote(Job._meta.get_field("return_value").column)
+  updated_at_column = quote(Job._meta.get_field("updated_at").column)
+  state_checks = " AND ".join(
+    _state_absence_sql(model, jobs_table=jobs_table, job_id_column=job_id_column, quote=quote)
+    for model in (
+      ReadyExecution,
+      ScheduledExecution,
+      BlockedExecution,
+      FailedExecution,
+    )
+  )
+  job_id = Job._meta.get_field("id").get_db_prep_value(
+    job.pk,
+    connection=connection,
+    prepared=False,
+  )
+  prepared_return_value = Job._meta.get_field("return_value").get_db_prep_save(
+    return_value,
+    connection=connection,
+  )
+
+  with connection.cursor() as cursor:
+    cursor.execute(
+      f"""
+      WITH deleted_claim AS (
+        DELETE FROM {claimed_table}
+        WHERE {claimed_table}.{claimed_job_id_column} = %s
+        RETURNING {claimed_job_id_column}
+      ),
+      updated_job AS (
+        UPDATE {jobs_table}
+        SET
+          {finished_at_column} = %s,
+          {return_value_column} = %s,
+          {updated_at_column} = %s
+        WHERE
+          {jobs_table}.{job_id_column} = %s
+          AND {jobs_table}.{backend_alias_column} = %s
+          AND EXISTS (SELECT 1 FROM deleted_claim)
+          AND {state_checks}
+        RETURNING {job_id_column}
+      )
+      SELECT
+        (SELECT COUNT(*) FROM deleted_claim),
+        (SELECT COUNT(*) FROM updated_job)
+      """,
+      [job_id, finished_at, prepared_return_value, finished_at, job_id, job.backend_alias],
+    )
+    deleted_count, updated_count = cursor.fetchone()
+
+  if deleted_count != 1:
+    raise ClaimedExecution.DoesNotExist
+  if updated_count != 1:
+    raise EnqueueError(f"job {job.id} already has an execution-state row")
+  job.finished_at = finished_at
+  job.return_value = return_value
+  job.updated_at = finished_at
+
+
 def _finish_job_if_no_execution_state(alias, job, return_value, *, finished_at):
   connection = connections[alias]
   quote = connection.ops.quote_name

{dj_queue-0.10.3 → dj_queue-0.10.4}/dj_queue/runtime/base.py

@@ -244,16 +244,23 @@ class BaseRunner:
     if interval <= 0:
       return
     self._heartbeat_stop_event.clear()
-    self._heartbeat_thread = threading.Thread(target=self._heartbeat_loop, daemon=True)
+    self._heartbeat_thread = threading.Thread(
+      target=self._heartbeat_loop,
+      name=f"dj_queue-heartbeat-{self.name}",
+      daemon=True,
+    )
     self._heartbeat_thread.start()
 
   def _stop_heartbeat_thread(self):
     thread = self._heartbeat_thread
     if thread is None:
-      return
+      return True
     self._heartbeat_stop_event.set()
     thread.join(timeout=max(self._effective_heartbeat_interval(), 0.1) + 0.1)
+    if thread.is_alive():
+      return False
     self._heartbeat_thread = None
+    return True
 
   def _heartbeat_loop(self):
     interval = self._effective_heartbeat_interval()

{dj_queue-0.10.3 → dj_queue-0.10.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "dj-queue"
-version = "0.10.3"
+version = "0.10.4"
 description = "Database-backed task queue backend for Django’s Tasks framework."
 readme = "README.md"
 license = "MIT"