GoodJob.Job (good_job v1.0.0)

@type t() :: %GoodJob.Job{
  __meta__: term(),
  active_job_id: term(),
  batch_callback_id: term(),
  batch_id: term(),
  concurrency_key: term(),
  cron_at: term(),
  cron_key: term(),
  error: term(),
  error_event: term(),
  executions_count: term(),
  finished_at: term(),
  id: term(),
  inserted_at: term(),
  is_discrete: term(),
  job_class: term(),
  labels: term(),
  lock_type: term(),
  locked_at: term(),
  locked_by_id: term(),
  performed_at: term(),
  priority: term(),
  queue_name: term(),
  retried_good_job_id: term(),
  scheduled_at: term(),
  serialized_params: term(),
  updated_at: term()
}

Functions

advisory_locked(query \\ MODULE)

advisory_unlocked(query \\ MODULE)

build_for_enqueue(attrs)

Builds a job for enqueueing.

calculate_state(job)

See GoodJob.Job.State.calculate/1.

changeset(job, attrs)

Creates a changeset for a job.

created_after(query \\ MODULE, datetime)

created_before(query \\ MODULE, datetime)

delete(job)

Deletes a job from the database.

delete_many(ids)

@spec delete_many([Ecto.UUID.t() | String.t()]) ::
  {:ok, non_neg_integer()} | {:error, term()}

Deletes multiple jobs in two queries (fetch by id, then delete all matching rows).

Emits the same PubSub and telemetry events per job as delete/1. ids may be a list of t:Ecto.UUID strings (as returned from the database or UI).

dequeueing_ordered(query \\ MODULE)

discarded(query \\ MODULE)

@spec discarded(Ecto.Query.t() | module()) :: Ecto.Query.t()

enqueue(attrs, opts \\ [])

Enqueues a job.

This inserts the row only; it does not run GoodJob.Concurrency checks. Use GoodJob.enqueue/3 when you need per-key enqueue limits enforced before insert.

Options

:listen_notify - When false, skips pg_notify (PubSub and telemetry still run). Used by GoodJob.Bulk to send a single notification after a batch insert.

exclude_paused(query \\ MODULE)

find_by_active_job_id(active_job_id)

find_by_id(id)

finished(query \\ MODULE)

finished_before(query \\ MODULE, datetime)

in_batch(query \\ MODULE, batch_id)

in_queue(query \\ MODULE, queue_name)

joins_advisory_locks(query \\ MODULE)

locked(query \\ MODULE)

only_scheduled(query \\ MODULE)

order_by_created_asc(query \\ MODULE)

order_by_created_desc(query \\ MODULE)

order_by_finished_desc(query \\ MODULE)

order_by_scheduled_asc(query \\ MODULE)

order_for_candidate_lookup(query \\ MODULE, parsed_queues \\ %{})

queue_ordered(query \\ MODULE, queues)

queued(query \\ MODULE)

retry(job)

Retries a discarded job by clearing its finished_at and error fields.

retry_many(ids)

@spec retry_many([Ecto.UUID.t() | String.t()]) ::
  {:ok, non_neg_integer()} | {:error, term()}

Retries multiple jobs in one UPDATE, matching retry/1 field changes.

Emits the same PubSub and telemetry events per job as retry/1 (using structs loaded before the update).

running(query \\ MODULE)

scheduled(query \\ MODULE)

scheduled_before(query \\ MODULE, datetime)

succeeded(query \\ MODULE)

@spec succeeded(Ecto.Query.t() | module()) :: Ecto.Query.t()