postjob 0.2.2 → 0.3.0

data/lib/postjob/migrations/008a_childjobs.sql

@@ -0,0 +1,82 @@
+CREATE OR REPLACE FUNCTION {SCHEMA_NAME}.childjobs(v_parent_id BIGINT)
+  RETURNS SETOF {SCHEMA_NAME}.postjobs AS $$
+BEGIN
+  RETURN QUERY
+    SELECT {TABLE_NAME}.* FROM {TABLE_NAME}
+    WHERE parent_id=v_parent_id
+    ORDER BY id;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE FUNCTION {SCHEMA_NAME}.next_unresolved_childjob(v_parent_id BIGINT)
+  RETURNS SETOF {SCHEMA_NAME}.postjobs AS $$
+BEGIN
+  RETURN QUERY
+    SELECT {TABLE_NAME}.* FROM {TABLE_NAME}
+    WHERE status NOT IN ('ok', 'failed') AND parent_id=v_parent_id
+    ORDER BY next_run_at;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE FUNCTION {SCHEMA_NAME}.find_or_create_childjob(
+  v_queue VARCHAR,
+  v_workflow VARCHAR,
+  v_workflow_method VARCHAR,
+  v_workflow_version VARCHAR,
+  v_args JSONB,
+  v_parent_id BIGINT,
+  v_tags JSONB,
+  v_max_attempts INTEGER,
+  v_timeout DOUBLE PRECISION)
+  RETURNS SETOF {SCHEMA_NAME}.postjobs AS $$
+DECLARE
+  child_id BIGINT;
+  parent {SCHEMA_NAME}.postjobs;
+BEGIN
+  IF v_parent_id IS NULL THEN
+    RAISE 'Invalid parent job id NULL';
+  END IF;
+
+  IF v_parent_id IS NOT NULL THEN
+    SELECT INTO parent * FROM {TABLE_NAME} WHERE id=v_parent_id;
+    IF parent.id IS NULL THEN
+      RAISE 'No such job: %', v_parent_id;
+    END IF;
+  END IF;
+
+  -- check for existing child record
+
+  -- IF v_parent_id IS NOT NULL THEN
+    SELECT id INTO child_id FROM {TABLE_NAME}
+    WHERE parent_id=v_parent_id
+      AND workflow=v_workflow
+      AND workflow_method=v_workflow_method
+      AND args=v_args
+      ;
+
+    IF child_id IS NOT NULL THEN
+      -- note that RETURN QUERY does not return the function here. It 'only'
+      -- adds the specified query to the result set.
+      RETURN QUERY
+        SELECT * FROM {TABLE_NAME} WHERE id=child_id
+      ;
+    ELSE
+      IF v_tags IS NOT NULL THEN
+        RAISE WARNING 'Ignoring tags %', v_tags;
+      END IF;
+
+      RETURN QUERY
+        SELECT * FROM enqueue(
+          COALESCE(v_queue, parent.queue),  -- queue VARCHAR,
+          v_workflow,                       -- workflow VARCHAR,
+          v_workflow_method,                -- workflow_method VARCHAR,
+          NULL,                             -- workflow_version VARCHAR,
+          v_args,                           -- args JSONB,
+          v_parent_id,                      -- parent_id BIGINT,
+          parent.tags,                      -- tags JSONB,
+          v_max_attempts,                   -- max_attempts INTEGER,
+          v_timeout);
+    END IF;
+  -- END IF;
+END;
+$$ LANGUAGE plpgsql;

data/lib/postjob/migrations/009_tokens.sql

@@ -0,0 +1,25 @@
+CREATE EXTENSION IF NOT EXISTS pgcrypto;
+
+CREATE OR REPLACE FUNCTION {SCHEMA_NAME}.find_or_create_token(job_id BIGINT) RETURNS VARCHAR AS $$
+DECLARE
+  v_token UUID;
+BEGIN
+  SELECT token INTO v_token FROM postjob.tokens WHERE postjob_id=job_id;
+
+  if v_token IS NULL THEN
+    SELECT gen_random_uuid() INTO v_token;
+    INSERT INTO postjob.tokens(postjob_id, token) VALUES(job_id, v_token);
+  END IF;
+  RETURN v_token::varchar;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE FUNCTION {SCHEMA_NAME}.postjobs_by_token(v_token UUID)
+  RETURNS SETOF {SCHEMA_NAME}.postjobs AS $$
+BEGIN
+  RETURN QUERY
+    SELECT {TABLE_NAME}.* FROM {TABLE_NAME}
+    INNER JOIN {SCHEMA_NAME}.tokens ON {SCHEMA_NAME}.tokens.postjob_id={TABLE_NAME}.id
+    WHERE {SCHEMA_NAME}.tokens.token=v_token;
+END;
+$$ LANGUAGE plpgsql;

data/lib/postjob/migrations.rb

@@ -1,97 +1,50 @@
+# rubocop:disable Security/Eval
+
 module Postjob
   module Migrations
     extend self
 
     SQL = ::Simple::SQL
-    SCHEMA_NAME = Postjob::Queue::SCHEMA_NAME
+    SCHEMA_NAME = ::Postjob::Queue::SCHEMA_NAME
+    CHANNEL     = ::Postjob::Queue::Notifications::CHANNEL
+
+    # Note that the SCHEMA_NAME should not be the default name, since unmigrate!
+    # below drops that schema, and we don't want to drop the default schema.
+    expect! SCHEMA_NAME != "public"
+
+    TABLE_NAME = "#{SCHEMA_NAME}.postjobs"
 
     def unmigrate!
-      if SCHEMA_NAME != "public"
-        SQL.exec <<~SQL
-          DROP SCHEMA IF EXISTS #{SCHEMA_NAME} CASCADE;
-        SQL
-      end
+      SQL.exec "DROP SCHEMA IF EXISTS #{SCHEMA_NAME} CASCADE"
     end
 
-    PG_TYPES = <<~SQL
-      SELECT pg_namespace.nspname AS schema, pg_type.typname AS name
-      FROM pg_type
-      LEFT JOIN pg_namespace on pg_namespace.oid=pg_type.typnamespace
-    SQL
-
     def migrate!
-      SQL.exec <<~SQL
-        CREATE SCHEMA IF NOT EXISTS #{SCHEMA_NAME};
-      SQL
+      SQL.exec "CREATE SCHEMA IF NOT EXISTS #{SCHEMA_NAME}"
 
-      unless SQL.ask("SELECT 1 FROM (#{PG_TYPES}) sq WHERE (schema,name) = ($1, $2)", SCHEMA_NAME, "statuses")
-        SQL.exec <<~SQL
-          CREATE TYPE #{SCHEMA_NAME}.statuses AS ENUM (
-            'ready',    -- process can run
-            'sleep',    -- process has external dependencies to wait for.
-            'failed',   -- process failed, with nonrecoverable error
-            'err',      -- process errored (with recoverable error)
-            'timeout',  -- process timed out
-            'ok'        -- process succeeded
-          );
-        SQL
+      Dir.glob(__FILE__.gsub(/\.rb$/, "/**/*.{sql,rb}")).sort.each do |file|
+        run_migration file
       end
+    end
 
-      SQL.exec <<~SQL
-        CREATE TABLE IF NOT EXISTS #{SCHEMA_NAME}.postjobs (
-          -- id values, readonly once created
-          id          BIGSERIAL PRIMARY KEY,                                        -- process id
-          parent_id   BIGINT REFERENCES #{SCHEMA_NAME}.postjobs ON DELETE CASCADE,  -- parent process id
-          full_id     VARCHAR,                                                      -- full process id
-          root_id     BIGINT,                                                       -- root process id
-
-          created_at  timestamp NOT NULL DEFAULT (now() at time zone 'utc'),        -- creation timestamp
-          updated_at  timestamp NOT NULL DEFAULT (now() at time zone 'utc'),        -- update timestamp
-
-          queue VARCHAR,                                                            -- queue name. (readonly)
-          workflow VARCHAR NOT NULL,                                                -- e.g. "MyJobModule" (readonly)
-          workflow_method VARCHAR NOT NULL DEFAULT 'run',                           -- e.g. "run" (readonly)
-          workflow_version VARCHAR NOT NULL DEFAULT '',                             -- e.g. "1.0"
-          args JSONB,                                                               -- args
-
-          -- process state ----------------------------------------------------
-
-          status #{SCHEMA_NAME}.statuses DEFAULT 'ready',
-          next_run_at timestamp DEFAULT (now() at time zone 'utc'),                 -- when possible to run next?
-          timing_out_at timestamp,                                                  -- job times out after this timestamp
-          failed_attempts INTEGER NOT NULL DEFAULT 0,                               -- failed how often?
-          max_attempts INTEGER NOT NULL DEFAULT 1,                                  -- maximum attempts before failing
-
-          -- process result ---------------------------------------------------
-
-          results JSONB,
-          error VARCHAR,
-          error_message VARCHAR,
-          error_backtrace JSONB,
+    private
 
-          -- custom fields
-          workflow_status VARCHAR,
-          tags JSONB
-        );
+    def run_migration(file)
+      Postjob.logger.info "Postjob: migrating #{file}"
 
-        -- [TODO] check indices
-        CREATE INDEX IF NOT EXISTS postjobs_tags_idx
-          ON #{SCHEMA_NAME}.postjobs USING GIN (tags jsonb_path_ops);
-        CREATE INDEX IF NOT EXISTS postjobs_parent_id_idx
-          ON #{SCHEMA_NAME}.postjobs(parent_id);
-      SQL
+      case file
+      when /\.rb$/  then run_migration_ruby(file)
+      when /\.sql$/ then run_migration_sql(file)
+      end
+    end
 
-      SQL.exec <<~SQL
-        CREATE TABLE IF NOT EXISTS #{SCHEMA_NAME}.tokens (
-          id          BIGSERIAL PRIMARY KEY,
-          postjob_id  BIGINT REFERENCES #{SCHEMA_NAME}.postjobs ON DELETE CASCADE,
-          token       UUID NOT NULL,
-          created_at  timestamp NOT NULL DEFAULT (now() at time zone 'utc')
-        );
+    def run_migration_ruby(file)
+      eval File.read(file)
+    end
 
-        CREATE INDEX IF NOT EXISTS tokens_postjob_id_idx ON #{SCHEMA_NAME}.tokens(postjob_id);
-        CREATE INDEX IF NOT EXISTS tokens_token_idx ON #{SCHEMA_NAME}.tokens(token);
-      SQL
+    def run_migration_sql(file)
+      sql = File.read(file)
+      sql.gsub!(/\{([^\}]+)\}/) { |_| const_get($1) }
+      SQL.exec sql
     end
   end
 end

data/lib/postjob/queue/encoder.rb

@@ -17,7 +17,7 @@ module Postjob::Queue::Encoder
   extend self
 
   def encode(data)
-    return if data.nil?
+    return nil if data.nil?
 
     verify_encodable!(data)
     JSON.generate(data)

data/lib/postjob/queue/notifications.rb

@@ -3,14 +3,9 @@
 module Postjob::Queue::Notifications
   extend self
 
-  SQL        = ::Postjob::Queue::SQL
-  TABLE_NAME = ::Postjob::Queue::TABLE_NAME
-  CHANNEL    = "postjob_notifications"
-
-  def notify_listeners
-    SQL.ask "NOTIFY #{CHANNEL}"
-  end
-
+  SQL         = ::Postjob::Queue::SQL
+  CHANNEL     = "postjob_notifications"
+  SCHEMA_NAME = ::Postjob::Queue::SCHEMA_NAME
   MAX_WAIT_TIME = 120
 
   def wait_for_new_job
@@ -23,8 +18,8 @@ module Postjob::Queue::Notifications
     wait_time = time_to_next_job
     return if wait_time && wait_time <= 0
 
-    wait_time ||= MAX_WAIT_TIME
-    Postjob.logger.debug "postjob: waiting for notification for up to #{wait_time.inspect} seconds"
+    wait_time = MAX_WAIT_TIME if !wait_time || wait_time > MAX_WAIT_TIME
+    Postjob.logger.debug "postjob: waiting for notification for up to #{wait_time} seconds"
     Simple::SQL.wait_for_notify(wait_time)
 
     # flush notifications. It is possible that a huge number of notifications
@@ -49,16 +44,6 @@ module Postjob::Queue::Notifications
   # returns the maximum number of seconds to wait until the
   # next runnable or timeoutable job comes up.
   def time_to_next_job
-    Simple::SQL.ask <<~SQL, Postjob::Registry.workflows_with_versions
-      SELECT EXTRACT(EPOCH FROM (MIN(next_event_at) - (now() at time zone 'utc'))) FROM (
-          SELECT MIN(timing_out_at) AS next_event_at
-          FROM #{TABLE_NAME}
-          WHERE status IN ('ready', 'sleep', 'err')
-        UNION
-          SELECT MIN(next_run_at) AS next_event_at
-          FROM #{TABLE_NAME}
-          WHERE status = 'ready' AND (workflow || workflow_version = ANY ($1))
-      ) sq
-    SQL
+    Simple::SQL.ask "SELECT * FROM #{SCHEMA_NAME}.time_to_next_job($1)", ::Postjob::Registry.workflows_with_versions
   end
 end

data/lib/postjob/queue/search.rb

@@ -6,14 +6,14 @@ end
 module Postjob::Queue::Search
   extend self
 
-  def one(id, filter: {}, into: Hash)
+  def one(id, filter: {}, into: nil)
     query = query(page: 0, per: 1, filter: filter, id: id)
-    Simple::SQL.ask(query, into: into)
+    Simple::SQL.record(query, into: into)
   end
 
-  def all(page: 0, per: 100, filter: {}, into: Hash)
+  def all(page: 0, per: 100, filter: {}, into: nil)
     query = query(page: page, per: per, filter: filter)
-    Simple::SQL.all(query, into: into)
+    Simple::SQL.records(query, into: into)
   end
 
   private

data/lib/postjob/queue.rb

@@ -1,8 +1,4 @@
-# rubocop:disable Layout/IndentationWidth
-# rubocop:disable Style/UnneededInterpolation
-# rubocop:disable Metrics/ModuleLength
-# rubocop:disable Metrics/LineLength
-# rubocop:disable Lint/EndAlignment
+# rubocop:disable Layout/AlignParameters
 # rubocop:disable Metrics/MethodLength
 # rubocop:disable Metrics/ParameterLists
 
@@ -25,12 +21,6 @@ require_relative "queue/search"
 module Postjob::Queue
   Job = ::Postjob::Job
 
-  DEFAULT_OPTIONS = {
-    version: "",
-    queue: "q",
-    max_attempts: 5
-  }
-
   # enqueues a new job with the given arguments
   #
   # Parameters:
@@ -55,197 +45,71 @@ module Postjob::Queue
 
     workflow, workflow_method = parse_workflow(workflow)
 
-    options.update(DEFAULT_OPTIONS) { |_k, v1, v2| v1 || v2 }
-
-    SQL.transaction do
-      queue, version, parent_id, tags, timeout, max_attempts =
-        options.values_at :queue, :version, :parent_id, :tags, :timeout, :max_attempts
-
-      args = Encoder.encode(args) if args
-      tags = Encoder.encode(tags) if tags
-
-      id = SQL.ask <<~SQL, queue, workflow, workflow_method, version, args, parent_id, tags, max_attempts
-        INSERT INTO #{TABLE_NAME}(queue, workflow, workflow_method, workflow_version, args, parent_id, tags, max_attempts)
-        VALUES($1, $2, $3, $4, $5, $6, $7, $8)
-        RETURNING id
-      SQL
-
-      if timeout
-        SQL.ask <<~SQL, id, timeout
-          UPDATE #{TABLE_NAME}
-          SET timing_out_at = (now() at time zone 'utc') + $2 * interval '1 second'
-          WHERE id=$1
-        SQL
-      end
-
-      root_id, parent_full_id = if parent_id
-        SQL.ask "SELECT root_id, full_id FROM #{TABLE_NAME} WHERE id=$1", parent_id
-      end
-
-      root_id ||= id
-      full_id = parent_full_id ? "#{parent_full_id}.#{id}" : "#{id}"
-
-      SQL.ask "UPDATE #{TABLE_NAME} SET full_id=$2, root_id=$3 WHERE id=$1",
-              id, full_id, root_id
-
-      Notifications.notify_listeners
-
-      SQL.ask "SELECT * FROM #{TABLE_NAME} WHERE id=$1", id, into: Job
-    end
+    # The use of a `SELECT * FROM function()` here is due to
+    #
+    # a) a limitation in Simple::SQL which would not be able to unpack a
+    #    "SELECT function()" usefully when the return value is a record;
+    # b) and/or my inability to write better SQL functions;
+    SQL.record "SELECT * FROM #{SCHEMA_NAME}.enqueue($1, $2, $3, $4, $5, $6, $7, $8, $9)",
+                  options[:queue],
+                  workflow,
+                  workflow_method,
+                  options[:version],
+                  Encoder.encode(args),
+                  options[:parent_id],
+                  Encoder.encode(options[:tags]),
+                  options[:max_attempts],
+                  options[:timeout],
+                  into: Job
   end
 
   def set_job_result(job, value, version:)
-    update_job(job, version: version)
-    results = Encoder.encode([value]) unless value.nil?
-
-    SQL.ask <<~SQL, job.id, results
-      UPDATE #{TABLE_NAME}
-      SET results=$2, status='ok', next_run_at=NULL, error=NULL, error_message=NULL, error_backtrace=NULL
-      WHERE id=$1
-    SQL
-
-    wakeup(job.parent_id)
+    value = Encoder.encode([value]) unless value.nil?
+    SQL.ask "SELECT #{SCHEMA_NAME}.set_job_result($1, $2, $3)", job.id, value, version
   end
 
   def set_job_pending(job, version:)
-    update_job(job, version: version)
-    SQL.ask <<~SQL, job.id
-      UPDATE #{TABLE_NAME}
-      SET status='sleep', next_run_at=NULL
-      WHERE id=$1
-    SQL
+    SQL.ask "SELECT #{SCHEMA_NAME}.set_job_pending($1, $2)", job.id, version
   end
 
-  private
-
-  def remaining_attempts(job)
-    SQL.ask <<~SQL, job.id
-      SELECT max_attempts - failed_attempts
-      FROM #{TABLE_NAME}
-      WHERE id=$1
-    SQL
-  end
-
-  def next_status_and_next_run_of_failed_job(job, status)
-    # If this is a recoverable error and if we have another run possible we'll
-    # set next_run_at, and the status to "sleep", otherwise next_run_at will be
-    # NULL and the status would be "failed"
-    #
-    # To check if we have another run we check (max_attempts - failed_attempts).
-    #
-    # This is only necessary with a status of :err. Note that we need to
-    # subtract 1, since this check runs *after* the current run was done,
-    # but before it was written to the database.
-    if status == :err && remaining_attempts(job) > 1
-      [ "err", next_run_at_fragment ]
-    elsif status == :timeout
-      [ "timeout", "NULL" ]
-    else
-      [ "failed", "NULL" ]
-    end
-  end
-
-  public
-
   def set_job_error(job, error, error_message, error_backtrace = nil, status:, version:)
-    update_job(job, version: version)
-
-    new_status, next_run_at = next_status_and_next_run_of_failed_job job, status
-
-    unless error_backtrace.nil?
-      error_backtrace = error_backtrace.map { |path| make_relative_path(path) }
-      error_backtrace = Encoder.encode(error_backtrace)
-    end
-
-    SQL.ask <<~SQL, job.id, new_status, error, error_message, error_backtrace
-      UPDATE #{TABLE_NAME}
-      SET
-        status=$2, error=$3, error_message=$4, error_backtrace=$5,
-        failed_attempts=failed_attempts+1, next_run_at=#{next_run_at}
-      WHERE id=$1
-    SQL
-
-    wakeup(job.parent_id)
-  end
-
-  private
-
-  def make_relative_path(path)
-    @here ||= "#{Dir.getwd}/"
-    path.start_with?(@here) ? path[@here.length..-1] : path
-  end
-
-  def update_job(job, version:)
-    return unless version
-
-    SQL.ask <<~SQL, job.id, version
-      UPDATE #{TABLE_NAME}
-      SET workflow_version=$2, updated_at=(now() at time zone 'utc')
-      WHERE id=$1
-    SQL
-  end
-
-  #
-  # The timeout until a job can be run next is calculated by running the
-  # +next_run_at_fragment+ sql in the database.
-  #
-  def next_run_at_fragment
-    # The basetime to use with the NEXT_RUN_AT_FRAGMENT below.
-    next_run_at_basetime = Postjob.fast_mode ? 0.01 : 10
-    "(now() at time zone 'utc') + #{next_run_at_basetime} * pow(1.5, failed_attempts) * interval '1 second'"
-  end
-
-  def wakeup(id)
-    return unless id
+    expect! status => [ :failed, :err, :timeout ]
 
-    SQL.ask <<~SQL, id
-      UPDATE #{TABLE_NAME}
-      SET status='ready', next_run_at=(now() at time zone 'utc'), updated_at=(now() at time zone 'utc')
-      WHERE id=$1 AND status='sleep'
-    SQL
-
-    Notifications.notify_listeners
+    SQL.ask "SELECT #{SCHEMA_NAME}.set_job_error($1, $2, $3, $4, $5, $6, $7)",
+      job.id, error, error_message, Encoder.encode(error_backtrace), status, version, Postjob.fast_mode
   end
 
-  public
-
   def childjobs(parent)
     expect! parent => Job
-
-    SQL.all <<~SQL, parent.id, into: Job
-      SELECT * FROM #{TABLE_NAME}
-      WHERE parent_id=$1
-      ORDER BY id
-      SQL
+    SQL.records "SELECT * FROM #{SCHEMA_NAME}.childjobs($1)", parent.id, into: Job
   end
 
   def next_unresolved_childjob(parent)
     expect! parent => Job
-
-    SQL.ask <<~SQL, parent.id, into: Job
-      SELECT * FROM #{TABLE_NAME}
-      WHERE parent_id=$1 AND status NOT IN ('ok', 'failed')
-      ORDER BY next_run_at
-      LIMIT 1
-      SQL
+    SQL.records "SELECT * FROM #{SCHEMA_NAME}.next_unresolved_childjob($1)", parent.id, into: Job
   end
 
-  def find_or_create_childjob(parent, workflow, args, timeout:, max_attempts:)
+  def find_or_create_childjob(parent, workflow, args, timeout:, max_attempts:, queue: nil)
     expect! parent => Job, workflow => String, args => Array
 
     workflow, workflow_method = parse_workflow(workflow)
 
-    job = SQL.ask <<~SQL, parent.id, workflow, workflow_method, Encoder.encode(args), into: Job
-      SELECT * FROM #{TABLE_NAME}
-      WHERE parent_id=$1
-        AND workflow=$2
-        AND workflow_method=$3
-        AND args=$4
-      SQL
-
-    return job if job
-
-    enqueue_job("#{workflow}.#{workflow_method}", *args, queue: parent.queue, parent_id: parent.id, timeout: timeout, max_attempts: max_attempts, tags: parent.tags)
+    # The use of a `SELECT * FROM function()` here is due to
+    #
+    # a) a limitation in Simple::SQL which would not be able to unpack a
+    #    "SELECT function()" usefully when the return value is a record;
+    # b) and/or my inability to write better SQL functions;
+    return SQL.record "SELECT * FROM #{SCHEMA_NAME}.find_or_create_childjob($1, $2, $3, $4, $5, $6, $7, $8, $9)",
+                  queue,
+                  workflow,
+                  workflow_method,
+                  nil,                      # version
+                  Encoder.encode(args),
+                  parent.id,
+                  nil,                      # tags will be read from parent
+                  max_attempts,
+                  timeout,
+                  into: Job
   end
 
   def set_workflow_status(job, status)
@@ -275,42 +139,16 @@ module Postjob::Queue
 
   public
 
-  def checkout_runnable
-    sql = <<~SQL
-      SELECT
-        *,
-        timing_out_at <= (now() at time zone 'utc') AS timed_out
-      FROM #{TABLE_NAME}
-      WHERE
-        (next_run_at <= (now() at time zone 'utc') AND status IN ('ready', 'err') AND workflow || workflow_version = ANY ($1))
-        OR
-        (timing_out_at <= (now() at time zone 'utc') AND status IN ('ready', 'err', 'sleep'))
-      ORDER BY (LEAST(next_run_at, timing_out_at))
-      FOR UPDATE SKIP LOCKED
-      LIMIT 1
-    SQL
-
-    SQL.transaction do
-      job = SQL.ask sql, Postjob::Registry.workflows_with_versions, into: Job
-      yield job if job
-      job
-    end
+  def checkout(workflows_with_versions)
+    SQL.record "SELECT * FROM #{SCHEMA_NAME}.checkout($1, $2)",
+      workflows_with_versions, Postjob.fast_mode, into: Job
   end
 
   def find_or_create_token(job)
-    token = SQL.ask "SELECT token FROM postjob.tokens WHERE postjob_id=$1", job.id
-    return token if token
-
-    token = SecureRandom.uuid
-    SQL.ask "INSERT INTO postjob.tokens(postjob_id, token) VALUES($1, $2)", job.id, token
-    token
+    SQL.ask "SELECT #{SCHEMA_NAME}.find_or_create_token($1)", job.id
   end
 
   def find_job_by_token(token)
-    SQL.ask <<~SQL, token, into: Job
-      SELECT postjob.postjobs.* FROM postjob.postjobs
-      INNER JOIN postjob.tokens ON postjob.tokens.postjob_id=postjob.postjobs.id
-      WHERE postjob.tokens.token=$1
-    SQL
+    SQL.record "SELECT * FROM #{SCHEMA_NAME}.postjobs_by_token($1)", token, into: Job
   end
 end