dj-queue 0.10.5__tar.gz → 0.10.6__tar.gz

{dj_queue-0.10.5 → dj_queue-0.10.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dj-queue
-Version: 0.10.5
+Version: 0.10.6
 Summary: Database-backed task queue backend for Django’s Tasks framework.
 License-Expression: MIT
 License-File: LICENSE

{dj_queue-0.10.5 → dj_queue-0.10.6}/dj_queue/config.py

@@ -149,12 +149,14 @@ def load_backend_config(
   if tasks_settings is None:
     tasks_settings = getattr(settings, "TASKS", {})
 
+  ensure_dj_queue_backend_alias(tasks_settings, backend_alias)
+  backend_block = _backend_block(tasks_settings, backend_alias)
   env_values = {key: env.get(key) for key in CONFIG_ENV_KEYS if env.get(key) is not None}
   cache_key = (
     backend_alias,
     _cache_key(cli_overrides),
     _cache_key(env_values),
-    _cache_key(tasks_settings),
+    _cache_key(backend_block),
   )
   if cache_key not in _BACKEND_CONFIG_CACHE:
     _BACKEND_CONFIG_CACHE[cache_key] = _load_backend_config_uncached(

{dj_queue-0.10.5 → dj_queue-0.10.6}/dj_queue/contrib/asgi.py

@@ -24,13 +24,18 @@ class DjQueueLifespan:
       self.supervisor is not None and self._poll_stop is not None and not self._poll_stop.is_set()
     ):
       try:
-        await asyncio.to_thread(self.supervisor.poll_once)
+        poll_once = getattr(self.supervisor, "poll_once_if_running", self.supervisor.poll_once)
+        keep_polling = await asyncio.to_thread(poll_once)
       except Exception as error:
         handle_thread_error(
           error,
           context="supervisor.run",
           backend_alias=self.supervisor.backend_alias,
         )
+        keep_polling = True
+
+      if keep_polling is False:
+        return
 
       if self.supervisor is None or self._poll_stop is None or self._poll_stop.is_set():
         return

{dj_queue-0.10.5 → dj_queue-0.10.6}/dj_queue/contrib/gunicorn.py

@@ -21,11 +21,17 @@ def _set_supervisor_state(worker, **state):
 
 
 def _start_embedded_supervisor(worker, *, backend_alias="default"):
+  if getattr(worker, "_dj_queue_supervisor_exiting", False):
+    return None
+
   lock_file = _try_acquire_supervisor_lock(backend_alias=backend_alias)
   if lock_file is None:
     return None
 
   try:
+    if getattr(worker, "_dj_queue_supervisor_exiting", False):
+      _release_supervisor_lock(lock_file)
+      return None
     supervisor = build_supervisor(backend_alias=backend_alias)
     poll_stop = threading.Event()
     _set_supervisor_state(
@@ -35,6 +41,17 @@ def _start_embedded_supervisor(worker, *, backend_alias="default"):
       supervisor_poll_stop=poll_stop,
     )
     supervisor.start()
+    if getattr(worker, "_dj_queue_supervisor_exiting", False):
+      supervisor.stop()
+      _release_supervisor_lock(lock_file)
+      _set_supervisor_state(
+        worker,
+        supervisor_lock=None,
+        supervisor=None,
+        supervisor_poll_stop=None,
+        supervisor_poll_thread=None,
+      )
+      return None
   except Exception:
     _release_supervisor_lock(lock_file)
     _set_supervisor_state(
@@ -50,7 +67,9 @@ def _start_embedded_supervisor(worker, *, backend_alias="default"):
     stop_event = worker._dj_queue_supervisor_poll_stop
     while stop_event.wait(supervisor.polling_interval) is False:
       try:
-        supervisor.poll_once()
+        poll_once = getattr(supervisor, "poll_once_if_running", supervisor.poll_once)
+        if poll_once() is False:
+          return
       except Exception as error:
         handle_thread_error(
           error,
@@ -97,6 +116,7 @@ def post_fork(server, worker):
     supervisor_poll_thread=None,
     supervisor_retry_stop=None,
     supervisor_retry_thread=None,
+    supervisor_exiting=False,
   )
   supervisor = _start_embedded_supervisor(worker, backend_alias=backend_alias)
   if supervisor is not None:
@@ -107,10 +127,7 @@ def post_fork(server, worker):
 
 
 def worker_exit(_server, worker):
-  supervisor = getattr(worker, "_dj_queue_supervisor", None)
-  lock_file = getattr(worker, "_dj_queue_supervisor_lock", None)
-  stop_event = getattr(worker, "_dj_queue_supervisor_poll_stop", None)
-  poll_thread = getattr(worker, "_dj_queue_supervisor_poll_thread", None)
+  worker._dj_queue_supervisor_exiting = True
   retry_stop = getattr(worker, "_dj_queue_supervisor_retry_stop", None)
   retry_thread = getattr(worker, "_dj_queue_supervisor_retry_thread", None)
 
@@ -121,6 +138,11 @@ def worker_exit(_server, worker):
     worker._dj_queue_supervisor_retry_thread = None
   worker._dj_queue_supervisor_retry_stop = None
 
+  supervisor = getattr(worker, "_dj_queue_supervisor", None)
+  lock_file = getattr(worker, "_dj_queue_supervisor_lock", None)
+  stop_event = getattr(worker, "_dj_queue_supervisor_poll_stop", None)
+  poll_thread = getattr(worker, "_dj_queue_supervisor_poll_thread", None)
+
   if stop_event is not None:
     stop_event.set()
   if poll_thread is not None:

{dj_queue-0.10.5 → dj_queue-0.10.6}/dj_queue/dashboard.py

@@ -268,8 +268,8 @@ def dashboard_context(*, backend_alias, query_params=None):
     query_params = {}
 
   snapshot = observability.backend_snapshot(backend_alias=backend_alias)
-  queue_rows = snapshot["queue_rows"]
-  process_rows = snapshot["process_rows"]
+  queue_rows = snapshot.queue_rows
+  process_rows = snapshot.process_rows
   recurring_rows = [
     {
       **row,
@@ -278,7 +278,7 @@ def dashboard_context(*, backend_alias, query_params=None):
         recurring_task_key=row["key"],
       ),
     }
-    for row in snapshot["recurring_rows"]
+    for row in snapshot.recurring_rows
   ]
   semaphore_rows = [
     {
@@ -288,14 +288,14 @@ def dashboard_context(*, backend_alias, query_params=None):
         concurrency_key=row["key"],
       ),
     }
-    for row in snapshot["semaphore_rows"]
+    for row in snapshot.semaphore_rows
   ]
 
   return {
     "backend_alias": backend_alias,
     "backend_choices": backend_choices(),
     "config": config,
-    "queue_database_alias": snapshot["queue_database_alias"],
+    "queue_database_alias": snapshot.queue_database_alias,
     "summary_cards": _summary_cards(
       backend_alias=backend_alias,
       queue_rows=queue_rows,
@@ -305,7 +305,7 @@ def dashboard_context(*, backend_alias, query_params=None):
     ),
     "backend_facts": _backend_facts(
       config=config,
-      queue_database_alias=snapshot["queue_database_alias"],
+      queue_database_alias=snapshot.queue_database_alias,
       recurring_count=len(recurring_rows),
       semaphore_count=len(semaphore_rows),
     ),

{dj_queue-0.10.5 → dj_queue-0.10.6}/dj_queue/metrics.py

@@ -35,11 +35,11 @@ def metric_families(*, snapshots=None):
   seen_queue_databases = set()
 
   for snapshot in snapshots:
-    backend_alias = snapshot["backend_alias"]
-    queue_database_alias = snapshot["queue_database_alias"]
-    runner_metrics = snapshot["runner_metrics"]
+    backend_alias = snapshot.backend_alias
+    queue_database_alias = snapshot.queue_database_alias
+    runner_metrics = snapshot.runner_metrics
 
-    for queue in snapshot["queue_rows"]:
+    for queue in snapshot.queue_rows:
       for definition in QUEUE_STATE_DEFINITIONS:
         queue_jobs.append(
           MetricSample(
@@ -86,13 +86,13 @@ def metric_families(*, snapshots=None):
     recurring_tasks.append(
       MetricSample(
         labels=(backend_alias,),
-        value=len(snapshot["recurring_rows"]),
+        value=len(snapshot.recurring_rows),
       )
     )
     process_rows.append(
       MetricSample(
         labels=(backend_alias,),
-        value=len(snapshot["process_rows"]),
+        value=len(snapshot.process_rows),
       )
     )
 
@@ -102,7 +102,7 @@ def metric_families(*, snapshots=None):
     semaphores.append(
       MetricSample(
         labels=(queue_database_alias,),
-        value=len(snapshot["semaphore_rows"]),
+        value=len(snapshot.semaphore_rows),
       )
     )
 

{dj_queue-0.10.5 → dj_queue-0.10.6}/dj_queue/observability.py

@@ -4,8 +4,7 @@ from dataclasses import dataclass
 from datetime import timedelta
 
 from django.conf import settings
-from django.db.models import Count, Max, Min
-from django.db.models.functions import Coalesce
+from django.db.models import Count, Max
 from django.utils import timezone
 
 from dj_queue.config import configured_backend_aliases as configured_dj_queue_backend_aliases
@@ -14,19 +13,18 @@ from dj_queue.cron import next_cron_run
 from dj_queue.db import get_database_alias
 from dj_queue.models import (
   BlockedExecution,
-  ClaimedExecution,
-  FailedExecution,
-  Job,
   Pause,
   Process,
-  ReadyExecution,
   RecurringExecution,
   RecurringTask,
-  ScheduledExecution,
   Semaphore,
 )
 from dj_queue.queue_selectors import queue_matches_selectors
-from dj_queue.queue_state import queue_state_count_fields, queue_state_counts
+from dj_queue.queue_state import (
+  empty_queue_state_summary,
+  queue_state_summaries_by_queue,
+  queue_state_summary,
+)
 
 
 _NOT_PROVIDED = object()
@@ -38,6 +36,35 @@ class BackendChoice:
   database_alias: str
 
 
+@dataclass(frozen=True, slots=True)
+class BackendSnapshot:
+  backend_alias: str
+  queue_database_alias: str
+  process_alive_threshold: int
+  queue_rows: tuple[dict, ...]
+  process_rows: tuple[dict, ...]
+  recurring_rows: tuple[dict, ...]
+  semaphore_rows: tuple[dict, ...]
+  runner_metrics: dict
+
+  def __getitem__(self, key):
+    try:
+      return getattr(self, key)
+    except AttributeError as exc:
+      raise KeyError(key) from exc
+
+  def stats_row(self):
+    return {
+      "backend_alias": self.backend_alias,
+      "queue_database_alias": self.queue_database_alias,
+      "process_alive_threshold": self.process_alive_threshold,
+      "queues": self.queue_rows,
+      "runner_metrics": self.runner_metrics,
+      "recurring": self.recurring_rows,
+      "semaphores": self.semaphore_rows,
+    }
+
+
 def configured_backend_aliases():
   return configured_dj_queue_backend_aliases(getattr(settings, "TASKS", {}))
 
@@ -70,16 +97,16 @@ def backend_snapshot(*, backend_alias, now=None):
   semaphore_rows = semaphore_rows_for_backend(backend_alias=backend_alias)
   runner_metrics = process_counts(backend_process_rows)
 
-  return {
-    "backend_alias": backend_alias,
-    "queue_database_alias": queue_database_alias,
-    "process_alive_threshold": config.process_alive_threshold,
-    "queue_rows": queue_state_rows,
-    "process_rows": backend_process_rows,
-    "recurring_rows": recurring_rows,
-    "semaphore_rows": semaphore_rows,
-    "runner_metrics": runner_metrics,
-  }
+  return BackendSnapshot(
+    backend_alias=backend_alias,
+    queue_database_alias=queue_database_alias,
+    process_alive_threshold=config.process_alive_threshold,
+    queue_rows=tuple(queue_state_rows),
+    process_rows=tuple(backend_process_rows),
+    recurring_rows=tuple(recurring_rows),
+    semaphore_rows=tuple(semaphore_rows),
+    runner_metrics=runner_metrics,
+  )
 
 
 def all_backend_snapshots(*, now=None):
@@ -90,20 +117,7 @@ def all_backend_snapshots(*, now=None):
 
 def stats_payload(*, now=None):
   snapshots = all_backend_snapshots(now=now)
-  return {
-    "backends": [
-      {
-        "backend_alias": snapshot["backend_alias"],
-        "queue_database_alias": snapshot["queue_database_alias"],
-        "process_alive_threshold": snapshot["process_alive_threshold"],
-        "queues": snapshot["queue_rows"],
-        "runner_metrics": snapshot["runner_metrics"],
-        "recurring": snapshot["recurring_rows"],
-        "semaphores": snapshot["semaphore_rows"],
-      }
-      for snapshot in snapshots
-    ]
-  }
+  return {"backends": [snapshot.stats_row() for snapshot in snapshots]}
 
 
 def process_counts(process_rows):
@@ -123,32 +137,8 @@ def process_counts(process_rows):
 
 def queue_rows(*, backend_alias, now, process_cutoff):
   alias = get_database_alias(backend_alias)
-  queue_names = set()
-
-  ready_counts = _counts_by_value(
-    ReadyExecution.objects.using(alias).filter(backend_alias=backend_alias),
-    field_name="queue_name",
-  )
-  claimed_counts = _counts_by_value(
-    ClaimedExecution.objects.using(alias).filter(job__backend_alias=backend_alias),
-    field_name="job__queue_name",
-  )
-  scheduled_counts = _counts_by_value(
-    ScheduledExecution.objects.using(alias).filter(backend_alias=backend_alias),
-    field_name="queue_name",
-  )
-  blocked_counts = _counts_by_value(
-    BlockedExecution.objects.using(alias).filter(backend_alias=backend_alias),
-    field_name="queue_name",
-  )
-  failed_counts = _counts_by_value(
-    FailedExecution.objects.using(alias).filter(job__backend_alias=backend_alias),
-    field_name="job__queue_name",
-  )
-  finished_counts = _counts_by_value(
-    Job.objects.using(alias).filter(backend_alias=backend_alias, finished_at__isnull=False),
-    field_name="queue_name",
-  )
+  state_summaries = queue_state_summaries_by_queue(backend_alias=backend_alias)
+  queue_names = set(state_summaries)
   paused_queues = set(
     Pause.objects.using(alias)
     .filter(backend_alias=backend_alias)
@@ -160,40 +150,12 @@ def queue_rows(*, backend_alias, now, process_cutoff):
     .values_list("queue_name", flat=True)
   )
 
-  oldest_ready = {
-    row["queue_name"]: row["oldest"]
-    for row in ReadyExecution.objects.using(alias)
-    .filter(backend_alias=backend_alias)
-    .values("queue_name")
-    .annotate(oldest=Min(Coalesce("latency_started_at", "created_at")))
-  }
-  oldest_scheduled = {
-    row["queue_name"]: row["oldest"]
-    for row in ScheduledExecution.objects.using(alias)
-    .filter(backend_alias=backend_alias)
-    .values("queue_name")
-    .annotate(oldest=Min("scheduled_at"))
-  }
-  oldest_blocked = {
-    row["queue_name"]: row["oldest"]
-    for row in BlockedExecution.objects.using(alias)
-    .filter(backend_alias=backend_alias)
-    .values("queue_name")
-    .annotate(oldest=Min("expires_at"))
-  }
-
   live_workers = list(
     _live_processes_for_backend(
       alias=alias, backend_alias=backend_alias, kind="Worker", process_cutoff=process_cutoff
     )
   )
 
-  queue_names.update(ready_counts)
-  queue_names.update(claimed_counts)
-  queue_names.update(scheduled_counts)
-  queue_names.update(blocked_counts)
-  queue_names.update(failed_counts)
-  queue_names.update(finished_counts)
   queue_names.update(paused_queues)
   queue_names.update(recurring_queues)
 
@@ -203,16 +165,8 @@ def queue_rows(*, backend_alias, now, process_cutoff):
       queue_name=queue_name,
       now=now,
       process_cutoff=process_cutoff,
-      ready_count=ready_counts.get(queue_name, 0),
-      claimed_count=claimed_counts.get(queue_name, 0),
-      scheduled_count=scheduled_counts.get(queue_name, 0),
-      blocked_count=blocked_counts.get(queue_name, 0),
-      failed_count=failed_counts.get(queue_name, 0),
-      finished_count=finished_counts.get(queue_name, 0),
+      state_summary=state_summaries.get(queue_name) or empty_queue_state_summary(queue_name),
       paused=queue_name in paused_queues,
-      oldest_ready_at=oldest_ready.get(queue_name),
-      oldest_scheduled_at=oldest_scheduled.get(queue_name),
-      oldest_blocked_at=oldest_blocked.get(queue_name),
       live_workers=live_workers,
     )
     for queue_name in sorted(queue_names)
@@ -225,12 +179,7 @@ def queue_snapshot(
   queue_name,
   now,
   process_cutoff,
-  ready_count=None,
-  claimed_count=None,
-  scheduled_count=None,
-  blocked_count=None,
-  failed_count=None,
-  finished_count=None,
+  state_summary=None,
   paused=_NOT_PROVIDED,
   oldest_ready_at=_NOT_PROVIDED,
   oldest_scheduled_at=_NOT_PROVIDED,
@@ -238,33 +187,16 @@ def queue_snapshot(
   live_workers=None,
 ):
   alias = get_database_alias(backend_alias)
-  if ready_count is None:
-    state_counts = queue_state_counts(backend_alias=backend_alias, queue_name=queue_name)
-    ready_count = state_counts["ready"]
-    claimed_count = state_counts["claimed"]
-    scheduled_count = state_counts["scheduled"]
-    blocked_count = state_counts["blocked"]
-    failed_count = state_counts["failed"]
-    finished_count = state_counts["finished"]
+  if state_summary is None:
+    state_summary = queue_state_summary(backend_alias=backend_alias, queue_name=queue_name)
   if paused is _NOT_PROVIDED:
     paused = queue_is_paused(backend_alias=backend_alias, queue_name=queue_name)
   if oldest_ready_at is _NOT_PROVIDED:
-    oldest_ready_at = oldest_ready_at_for_queue(
-      backend_alias=backend_alias,
-      queue_name=queue_name,
-    )
+    oldest_ready_at = state_summary.oldest_ready_at
   if oldest_scheduled_at is _NOT_PROVIDED:
-    oldest_scheduled_at = (
-      ScheduledExecution.objects.using(alias)
-      .filter(backend_alias=backend_alias, queue_name=queue_name)
-      .aggregate(oldest=Min("scheduled_at"))["oldest"]
-    )
+    oldest_scheduled_at = state_summary.oldest_scheduled_at
   if oldest_blocked_at is _NOT_PROVIDED:
-    oldest_blocked_at = (
-      BlockedExecution.objects.using(alias)
-      .filter(backend_alias=backend_alias, queue_name=queue_name)
-      .aggregate(oldest=Min("expires_at"))["oldest"]
-    )
+    oldest_blocked_at = state_summary.oldest_blocked_at
   if live_workers is None:
     live_workers = list(
       _live_processes_for_backend(
@@ -283,16 +215,7 @@ def queue_snapshot(
     oldest_ready_at=oldest_ready_at,
   )
 
-  state_count_fields = queue_state_count_fields(
-    {
-      "ready": ready_count,
-      "claimed": claimed_count,
-      "scheduled": scheduled_count,
-      "blocked": blocked_count,
-      "failed": failed_count,
-      "finished": finished_count,
-    }
-  )
+  state_count_fields = state_summary.count_fields()
 
   return {
     "name": queue_name,
@@ -341,12 +264,7 @@ def queue_latency_seconds(
 
 
 def oldest_ready_at_for_queue(*, backend_alias, queue_name):
-  alias = get_database_alias(backend_alias)
-  return (
-    ReadyExecution.objects.using(alias)
-    .filter(backend_alias=backend_alias, queue_name=queue_name)
-    .aggregate(oldest=Min(Coalesce("latency_started_at", "created_at")))["oldest"]
-  )
+  return queue_state_summary(backend_alias=backend_alias, queue_name=queue_name).oldest_ready_at
 
 
 def process_rows(*, backend_alias, now, process_cutoff, scope):

{dj_queue-0.10.5 → dj_queue-0.10.6}/dj_queue/operations/_helpers.py

@@ -14,12 +14,22 @@ from dj_queue.models import (
   ScheduledExecution,
 )
 
+EXECUTION_STATE_MODELS = (
+  ReadyExecution,
+  ScheduledExecution,
+  ClaimedExecution,
+  BlockedExecution,
+  FailedExecution,
+)
 STATE_RELATIONS = {
-  ReadyExecution: "ready_execution",
-  ScheduledExecution: "scheduled_execution",
-  ClaimedExecution: "claimed_execution",
-  BlockedExecution: "blocked_execution",
-  FailedExecution: "failed_execution",
+  model: relation_name
+  for model, relation_name in (
+    (ReadyExecution, "ready_execution"),
+    (ScheduledExecution, "scheduled_execution"),
+    (ClaimedExecution, "claimed_execution"),
+    (BlockedExecution, "blocked_execution"),
+    (FailedExecution, "failed_execution"),
+  )
 }
 
 
@@ -31,8 +41,22 @@ def _normalize_payload(args, kwargs):
 
 
 def _ensure_no_other_execution_state(alias, job, *, ignored_models=()):
-  if _job_ids_with_other_execution_state(alias, [job.pk], ignored_models=ignored_models):
-    raise EnqueueError(f"job {job.id} already has an execution-state row")
+  _ensure_job_ids_have_no_other_execution_state(
+    alias,
+    [job.pk],
+    ignored_models=ignored_models,
+  )
+
+
+def _ensure_job_ids_have_no_other_execution_state(alias, job_ids, *, ignored_models=()):
+  conflicting_job_ids = _job_ids_with_other_execution_state(
+    alias,
+    job_ids,
+    ignored_models=ignored_models,
+  )
+  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")
 
 
 def _job_ids_with_other_execution_state(alias, job_ids, *, ignored_models=()):
@@ -54,6 +78,34 @@ def _job_ids_with_other_execution_state(alias, job_ids, *, ignored_models=()):
   )
 
 
+def _ensure_state_rows_belong_to_backend(rows, backend_alias):
+  for row in rows:
+    if row.job.backend_alias != backend_alias:
+      raise EnqueueError(f"job {row.job_id} belongs to backend {row.job.backend_alias!r}")
+
+
+def _state_models_except(*ignored_models):
+  ignored = set(ignored_models)
+  return tuple(model for model in EXECUTION_STATE_MODELS if model not in ignored)
+
+
+def _state_absence_checks_sql(models, *, quote, job_id_expression):
+  return " AND ".join(
+    _state_absence_sql(model, quote=quote, job_id_expression=job_id_expression) for model in models
+  )
+
+
+def _state_absence_sql(model, *, quote, job_id_expression):
+  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_expression}"
+    f")"
+  )
+
+
 def _task_option(task, name, default=None):
   if hasattr(task, name):
     return getattr(task, name)
@@ -219,7 +271,7 @@ def _ready_execution_fields(
   created_at=None,
 ):
   fields = {
-    "job": job,
+    "job_id": job.id,
     "backend_alias": _execution_backend_alias(job, backend_alias),
     "queue_name": _execution_queue_name(job, queue_name),
     "priority": _execution_priority(job, priority),
@@ -232,7 +284,7 @@ def _ready_execution_fields(
 
 def _scheduled_execution_fields(job, *, backend_alias, scheduled_at=None, created_at=None):
   fields = {
-    "job": job,
+    "job_id": job.id,
     "backend_alias": _execution_backend_alias(job, backend_alias),
     "queue_name": job.queue_name,
     "priority": job.priority,
@@ -253,7 +305,7 @@ def _blocked_execution_fields(
   priority=None,
 ):
   return {
-    "job": job,
+    "job_id": job.id,
     "backend_alias": _execution_backend_alias(job, backend_alias),
     "queue_name": _execution_queue_name(job, queue_name),
     "priority": _execution_priority(job, priority),

dj_queue-0.10.6/dj_queue/operations/_insert.py

@@ -0,0 +1,36 @@
+from django.db import connections
+
+from dj_queue.db import database_capabilities
+
+
+def create_ignore_conflicts(model, /, *, using, **fields):
+  obj = model(**fields)
+  connection = connections[using]
+  quote = connection.ops.quote_name
+  insert_fields = [
+    field
+    for field in model._meta.concrete_fields
+    if not field.generated and not _is_auto_field(field)
+  ]
+  columns = ", ".join(quote(field.column) for field in insert_fields)
+  placeholders = ", ".join(["%s"] * len(insert_fields))
+  params = [
+    field.get_db_prep_save(field.pre_save(obj, add=True), connection=connection)
+    for field in insert_fields
+  ]
+
+  table = quote(model._meta.db_table)
+  if database_capabilities(using).backend_family in {"mysql", "mariadb"}:
+    sql = f"INSERT IGNORE INTO {table} ({columns}) VALUES ({placeholders})"
+  else:
+    sql = f"INSERT INTO {table} ({columns}) VALUES ({placeholders}) ON CONFLICT DO NOTHING"
+
+  with connection.cursor() as cursor:
+    cursor.execute(sql, params)
+    rowcount = cursor.rowcount
+
+  return rowcount > 0
+
+
+def _is_auto_field(field):
+  return field.get_internal_type() in {"AutoField", "BigAutoField", "SmallAutoField"}