pg-boss 10.0.0-beta2 → 10.0.0-beta21

package/src/plans.js

@@ -1,24 +1,22 @@
-const assert = require('assert')
+const DEFAULT_SCHEMA = 'pgboss'
+const MIGRATE_RACE_MESSAGE = 'division by zero'
+const CREATE_RACE_MESSAGE = 'already exists'
 
-const states = {
+const JOB_STATES = Object.freeze({
   created: 'created',
   retry: 'retry',
   active: 'active',
   completed: 'completed',
   cancelled: 'cancelled',
   failed: 'failed'
-}
+})
 
-const DEFAULT_SCHEMA = 'pgboss'
-const MIGRATE_RACE_MESSAGE = 'division by zero'
-const CREATE_RACE_MESSAGE = 'already exists'
-
-const QUEUE_POLICY = {
+const QUEUE_POLICIES = Object.freeze({
   standard: 'standard',
   short: 'short',
   singleton: 'singleton',
   stately: 'stately'
-}
+})
 
 module.exports = {
   create,
@@ -30,6 +28,7 @@ module.exports = {
   completeJobs,
   cancelJobs,
   resumeJobs,
+  deleteJobs,
   failJobsById,
   failJobsByTimeout,
   insertJob,
@@ -44,57 +43,49 @@ module.exports = {
   archive,
   drop,
   countStates,
-  createQueue,
   updateQueue,
-  partitionCreateJobName,
-  dropJobTablePartition,
-  deleteQueueRecords,
+  createQueue,
+  deleteQueue,
+  getQueues,
   getQueueByName,
   getQueueSize,
   purgeQueue,
   clearStorage,
-  getMaintenanceTime,
-  setMaintenanceTime,
-  getMonitorTime,
-  setMonitorTime,
-  getCronTime,
-  setCronTime,
+  trySetMaintenanceTime,
+  trySetMonitorTime,
+  trySetCronTime,
   locked,
-  advisoryLock,
   assertMigration,
   getArchivedJobById,
   getJobById,
-  QUEUE_POLICY,
-  states: { ...states },
+  QUEUE_POLICIES,
+  JOB_STATES,
   MIGRATE_RACE_MESSAGE,
   CREATE_RACE_MESSAGE,
   DEFAULT_SCHEMA
 }
 
+const assert = require('assert')
+
 function create (schema, version) {
   const commands = [
     createSchema(schema),
     createEnumJobState(schema),
 
+    createTableVersion(schema),
+    createTableQueue(schema),
+    createTableSchedule(schema),
+    createTableSubscription(schema),
+
     createTableJob(schema),
-    createIndexJobName(schema),
-    createIndexJobFetch(schema),
-    createIndexJobPolicyStately(schema),
-    createIndexJobPolicyShort(schema),
-    createIndexJobPolicySingleton(schema),
-    createIndexJobThrottleOn(schema),
-    createIndexJobThrottleKey(schema),
 
     createTableArchive(schema),
     createPrimaryKeyArchive(schema),
     createColumnArchiveArchivedOn(schema),
     createIndexArchiveArchivedOn(schema),
-    createIndexArchiveName(schema),
 
-    createTableVersion(schema),
-    createTableQueue(schema),
-    createTableSchedule(schema),
-    createTableSubscription(schema),
+    createQueueFunction(schema),
+    deleteQueueFunction(schema),
 
     insertVersion(schema, version)
   ]
@@ -108,6 +99,21 @@ function createSchema (schema) {
   `
 }
 
+function createEnumJobState (schema) {
+  // ENUM definition order is important
+  // base type is numeric and first values are less than last values
+  return `
+    CREATE TYPE ${schema}.job_state AS ENUM (
+      '${JOB_STATES.created}',
+      '${JOB_STATES.retry}',
+      '${JOB_STATES.active}',
+      '${JOB_STATES.completed}',
+      '${JOB_STATES.cancelled}',
+      '${JOB_STATES.failed}'
+    )
+  `
+}
+
 function createTableVersion (schema) {
   return `
     CREATE TABLE ${schema}.version (
@@ -119,17 +125,48 @@ function createTableVersion (schema) {
   `
 }
 
-function createEnumJobState (schema) {
-  // ENUM definition order is important
-  // base type is numeric and first values are less than last values
+function createTableQueue (schema) {
   return `
-    CREATE TYPE ${schema}.job_state AS ENUM (
-      '${states.created}',
-      '${states.retry}',
-      '${states.active}',
-      '${states.completed}',
-      '${states.cancelled}',
-      '${states.failed}'
+    CREATE TABLE ${schema}.queue (
+      name text,
+      policy text,
+      retry_limit int,
+      retry_delay int,
+      retry_backoff bool,
+      expire_seconds int,
+      retention_minutes int,
+      dead_letter text REFERENCES ${schema}.queue (name),
+      partition_name text,
+      created_on timestamp with time zone not null default now(),
+      updated_on timestamp with time zone not null default now(),
+      PRIMARY KEY (name) 
+    )
+  `
+}
+
+function createTableSchedule (schema) {
+  return `
+    CREATE TABLE ${schema}.schedule (
+      name text REFERENCES ${schema}.queue ON DELETE CASCADE,
+      cron text not null,
+      timezone text,
+      data jsonb,
+      options jsonb,
+      created_on timestamp with time zone not null default now(),
+      updated_on timestamp with time zone not null default now(),
+      PRIMARY KEY (name)
+    )
+  `
+}
+
+function createTableSubscription (schema) {
+  return `
+    CREATE TABLE ${schema}.subscription (
+      event text not null,
+      name text not null REFERENCES ${schema}.queue ON DELETE CASCADE,
+      created_on timestamp with time zone not null default now(),
+      updated_on timestamp with time zone not null default now(),
+      PRIMARY KEY(event, name)
     )
   `
 }
@@ -141,146 +178,238 @@ function createTableJob (schema) {
       name text not null,
       priority integer not null default(0),
       data jsonb,
-      state ${schema}.job_state not null default('${states.created}'),
-      retryLimit integer not null default(0),
-      retryCount integer not null default(0),
-      retryDelay integer not null default(0),
-      retryBackoff boolean not null default false,
-      startAfter timestamp with time zone not null default now(),
-      startedOn timestamp with time zone,
-      singletonKey text,
-      singletonOn timestamp without time zone,
-      expireIn interval not null default interval '15 minutes',
-      createdOn timestamp with time zone not null default now(),
-      completedOn timestamp with time zone,
-      keepUntil timestamp with time zone NOT NULL default now() + interval '14 days',
+      state ${schema}.job_state not null default('${JOB_STATES.created}'),
+      retry_limit integer not null default(0),
+      retry_count integer not null default(0),
+      retry_delay integer not null default(0),
+      retry_backoff boolean not null default false,
+      start_after timestamp with time zone not null default now(),
+      started_on timestamp with time zone,
+      singleton_key text,
+      singleton_on timestamp without time zone,
+      expire_in interval not null default interval '15 minutes',
+      created_on timestamp with time zone not null default now(),
+      completed_on timestamp with time zone,
+      keep_until timestamp with time zone NOT NULL default now() + interval '14 days',
       output jsonb,
-      deadletter text,
-      policy text,
-      CONSTRAINT job_pkey PRIMARY KEY (name, id)
+      dead_letter text,
+      policy text      
     ) PARTITION BY LIST (name)
   `
 }
 
-function partitionCreateJobName (schema, name) {
+const baseJobColumns = 'id, name, data, EXTRACT(epoch FROM expire_in) as "expireInSeconds"'
+const allJobColumns = `${baseJobColumns},
+  policy,
+  state,
+  priority,
+  retry_limit as "retryLimit",
+  retry_count as "retryCount",
+  retry_delay as "retryDelay",
+  retry_backoff as "retryBackoff",
+  start_after as "startAfter",  
+  started_on as "startedOn",
+  singleton_key as "singletonKey",
+  singleton_on as "singletonOn",
+  expire_in as "expireIn",
+  created_on as "createdOn",
+  completed_on as "completedOn",
+  keep_until as "keepUntil",
+  dead_letter as "deadLetter",
+  output
+`
+
+function createQueueFunction (schema) {
   return `
-    CREATE TABLE ${schema}.job_${name} (LIKE ${schema}.job INCLUDING DEFAULTS INCLUDING CONSTRAINTS);
-    ALTER TABLE ${schema}.job_${name} ADD CONSTRAINT job_check_${name} CHECK (name='${name}');
-    ALTER TABLE ${schema}.job ATTACH PARTITION ${schema}.job_${name} FOR VALUES IN ('${name}');
+    CREATE FUNCTION ${schema}.create_queue(queue_name text, options json)
+    RETURNS VOID AS
+    $$
+    DECLARE
+      table_name varchar := 'j' || encode(sha224(queue_name::bytea), 'hex');
+    BEGIN
+
+      INSERT INTO ${schema}.queue (
+        name,
+        policy,
+        retry_limit,
+        retry_delay,
+        retry_backoff,
+        expire_seconds,
+        retention_minutes,
+        dead_letter,
+        partition_name
+      )
+      VALUES (
+        queue_name,
+        options->>'policy',
+        (options->>'retryLimit')::int,
+        (options->>'retryDelay')::int,
+        (options->>'retryBackoff')::bool,
+        (options->>'expireInSeconds')::int,
+        (options->>'retentionMinutes')::int,
+        options->>'deadLetter',
+        table_name
+      );
+
+      EXECUTE format('CREATE TABLE ${schema}.%I (LIKE ${schema}.job INCLUDING DEFAULTS)', table_name);
+      
+      EXECUTE format('${formatPartitionCommand(createPrimaryKeyJob(schema))}', table_name);
+      EXECUTE format('${formatPartitionCommand(createQueueForeignKeyJob(schema))}', table_name);
+      EXECUTE format('${formatPartitionCommand(createQueueForeignKeyJobDeadLetter(schema))}', table_name);
+      EXECUTE format('${formatPartitionCommand(createIndexJobPolicyShort(schema))}', table_name);
+      EXECUTE format('${formatPartitionCommand(createIndexJobPolicySingleton(schema))}', table_name);
+      EXECUTE format('${formatPartitionCommand(createIndexJobPolicyStately(schema))}', table_name);
+      EXECUTE format('${formatPartitionCommand(createIndexJobThrottle(schema))}', table_name);
+      EXECUTE format('${formatPartitionCommand(createIndexJobFetch(schema))}', table_name);
+
+      EXECUTE format('ALTER TABLE ${schema}.%I ADD CONSTRAINT cjc CHECK (name=%L)', table_name, queue_name);
+      EXECUTE format('ALTER TABLE ${schema}.job ATTACH PARTITION ${schema}.%I FOR VALUES IN (%L)', table_name, queue_name);
+    END;
+    $$
+    LANGUAGE plpgsql;
   `
 }
 
-function dropJobTablePartition (schema, name) {
-  return `DROP TABLE IF EXISTS ${schema}.job_${name}`
+function formatPartitionCommand (command) {
+  return command.replace('.job', '.%1$I').replace('job_i', '%1$s_i').replaceAll('\'', '\'\'')
 }
 
-function createPrimaryKeyArchive (schema) {
-  return `ALTER TABLE ${schema}.archive ADD CONSTRAINT archive_pkey PRIMARY KEY (name, id)`
+function deleteQueueFunction (schema) {
+  return `
+    CREATE FUNCTION ${schema}.delete_queue(queue_name text)
+    RETURNS VOID AS
+    $$
+    DECLARE
+      table_name varchar;
+    BEGIN  
+      WITH deleted as (
+        DELETE FROM ${schema}.queue
+        WHERE name = queue_name
+        RETURNING partition_name
+      )
+      SELECT partition_name from deleted INTO table_name;
+
+      EXECUTE format('DROP TABLE IF EXISTS ${schema}.%I', table_name);
+    END;
+    $$
+    LANGUAGE plpgsql;
+  `
 }
 
-function createIndexJobPolicyShort (schema) {
-  return `CREATE UNIQUE INDEX job_policy_short ON ${schema}.job (name) WHERE state = '${states.created}' AND policy = '${QUEUE_POLICY.short}'`
+function createQueue (schema) {
+  return `SELECT ${schema}.create_queue($1, $2)`
 }
 
-function createIndexJobPolicySingleton (schema) {
-  return `CREATE UNIQUE INDEX job_policy_singleton ON ${schema}.job (name) WHERE state = '${states.active}' AND policy = '${QUEUE_POLICY.singleton}'`
+function deleteQueue (schema) {
+  return `SELECT ${schema}.delete_queue($1)`
 }
 
-function createIndexJobPolicyStately (schema) {
-  return `CREATE UNIQUE INDEX job_policy_stately ON ${schema}.job (name, state) WHERE state <= '${states.active}' AND policy = '${QUEUE_POLICY.stately}'`
+function createPrimaryKeyJob (schema) {
+  return `ALTER TABLE ${schema}.job ADD PRIMARY KEY (name, id)`
 }
 
-function createIndexJobThrottleOn (schema) {
-  return `CREATE UNIQUE INDEX job_throttle_on ON ${schema}.job (name, singletonOn, COALESCE(singletonKey, '')) WHERE state <= '${states.completed}' AND singletonOn IS NOT NULL`
+function createQueueForeignKeyJob (schema) {
+  return `ALTER TABLE ${schema}.job ADD CONSTRAINT q_fkey FOREIGN KEY (name) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED`
 }
 
-function createIndexJobThrottleKey (schema) {
-  return `CREATE UNIQUE INDEX job_throttle_key ON ${schema}.job (name, singletonKey) WHERE state <= '${states.completed}' AND singletonOn IS NULL`
+function createQueueForeignKeyJobDeadLetter (schema) {
+  return `ALTER TABLE ${schema}.job ADD CONSTRAINT dlq_fkey FOREIGN KEY (dead_letter) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED`
 }
 
-function createIndexJobName (schema) {
-  return `CREATE INDEX job_name ON ${schema}.job (name)`
+function createPrimaryKeyArchive (schema) {
+  return `ALTER TABLE ${schema}.archive ADD PRIMARY KEY (name, id)`
 }
 
-function createIndexJobFetch (schema) {
-  return `CREATE INDEX job_fetch ON ${schema}.job (name, startAfter) INCLUDE (priority, createdOn, id) WHERE state < '${states.active}'`
+function createIndexJobPolicyShort (schema) {
+  return `CREATE UNIQUE INDEX job_i1 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state = '${JOB_STATES.created}' AND policy = '${QUEUE_POLICIES.short}';`
 }
 
-function createTableArchive (schema) {
-  return `CREATE TABLE ${schema}.archive (LIKE ${schema}.job)`
+function createIndexJobPolicySingleton (schema) {
+  return `CREATE UNIQUE INDEX job_i2 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state = '${JOB_STATES.active}' AND policy = '${QUEUE_POLICIES.singleton}'`
 }
 
-function createColumnArchiveArchivedOn (schema) {
-  return `ALTER TABLE ${schema}.archive ADD archivedOn timestamptz NOT NULL DEFAULT now()`
+function createIndexJobPolicyStately (schema) {
+  return `CREATE UNIQUE INDEX job_i3 ON ${schema}.job (name, state, COALESCE(singleton_key, '')) WHERE state <= '${JOB_STATES.active}' AND policy = '${QUEUE_POLICIES.stately}'`
 }
 
-function createIndexArchiveArchivedOn (schema) {
-  return `CREATE INDEX archive_archivedon_idx ON ${schema}.archive(archivedon)`
+function createIndexJobThrottle (schema) {
+  return `CREATE UNIQUE INDEX job_i4 ON ${schema}.job (name, singleton_on, COALESCE(singleton_key, '')) WHERE state <> '${JOB_STATES.cancelled}' AND singleton_on IS NOT NULL`
 }
 
-function createIndexArchiveName (schema) {
-  return `CREATE INDEX archive_name_idx ON ${schema}.archive(name)`
+function createIndexJobFetch (schema) {
+  return `CREATE INDEX job_i5 ON ${schema}.job (name, start_after) INCLUDE (priority, created_on, id) WHERE state < '${JOB_STATES.active}'`
 }
 
-function getMaintenanceTime (schema) {
-  return `SELECT maintained_on, EXTRACT( EPOCH FROM (now() - maintained_on) ) seconds_ago FROM ${schema}.version`
+function createTableArchive (schema) {
+  return `CREATE TABLE ${schema}.archive (LIKE ${schema}.job)`
 }
 
-function setMaintenanceTime (schema) {
-  return `UPDATE ${schema}.version SET maintained_on = now()`
+function createColumnArchiveArchivedOn (schema) {
+  return `ALTER TABLE ${schema}.archive ADD archived_on timestamptz NOT NULL DEFAULT now()`
 }
 
-function getMonitorTime (schema) {
-  return `SELECT monitored_on, EXTRACT( EPOCH FROM (now() - monitored_on) ) seconds_ago FROM ${schema}.version`
+function createIndexArchiveArchivedOn (schema) {
+  return `CREATE INDEX archive_i1 ON ${schema}.archive(archived_on)`
 }
 
-function setMonitorTime (schema) {
-  return `UPDATE ${schema}.version SET monitored_on = now()`
+function trySetMaintenanceTime (schema) {
+  return trySetTimestamp(schema, 'maintained_on')
 }
 
-function setCronTime (schema, time) {
-  time = time || 'now()'
-  return `UPDATE ${schema}.version SET cron_on = ${time}`
+function trySetMonitorTime (schema) {
+  return trySetTimestamp(schema, 'monitored_on')
 }
 
-function getCronTime (schema) {
-  return `SELECT cron_on, EXTRACT( EPOCH FROM (now() - cron_on) ) seconds_ago FROM ${schema}.version`
+function trySetCronTime (schema) {
+  return trySetTimestamp(schema, 'cron_on')
 }
 
-function createQueue (schema) {
+function trySetTimestamp (schema, column) {
   return `
-    INSERT INTO ${schema}.queue (name, policy, retry_limit, retry_delay, retry_backoff, expire_seconds, retention_minutes, dead_letter)
-    VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+    UPDATE ${schema}.version SET ${column} = now()
+    WHERE EXTRACT( EPOCH FROM (now() - COALESCE(${column}, now() - interval '1 week') ) ) > $1
+    RETURNING true
   `
 }
 
 function updateQueue (schema) {
   return `
     UPDATE ${schema}.queue SET
-      retry_limit = COALESCE($2, retry_limit),
-      retry_delay = COALESCE($3, retry_delay),
-      retry_backoff = COALESCE($4, retry_backoff),
-      expire_seconds = COALESCE($5, expire_seconds),
-      retention_minutes = COALESCE($6, retention_minutes),
-      dead_letter = COALESCE($7, dead_letter)
+      policy = COALESCE($2, policy),
+      retry_limit = COALESCE($3, retry_limit),
+      retry_delay = COALESCE($4, retry_delay),
+      retry_backoff = COALESCE($5, retry_backoff),
+      expire_seconds = COALESCE($6, expire_seconds),
+      retention_minutes = COALESCE($7, retention_minutes),
+      dead_letter = COALESCE($8, dead_letter),
+      updated_on = now()
     WHERE name = $1
   `
 }
 
-function getQueueByName (schema) {
-  return `SELECT * FROM ${schema}.queue WHERE name = $1`
+function getQueues (schema) {
+  return `
+    SELECT 
+      name,
+      policy,
+      retry_limit as "retryLimit",
+      retry_delay as "retryDelay",
+      retry_backoff as "retryBackoff",
+      expire_seconds as "expireInSeconds",
+      retention_minutes as "retentionMinutes",
+      dead_letter as "deadLetter",
+      created_on as "createdOn",
+      updated_on as "updatedOn"
+    FROM ${schema}.queue
+   `
 }
 
-function deleteQueueRecords (schema) {
-  return `WITH dq AS (
-      DELETE FROM ${schema}.queue WHERE name = $1
-    )
-    DELETE FROM ${schema}.job WHERE name = $1
-  `
+function getQueueByName (schema) {
+  return `${getQueues(schema)} WHERE name = $1`
 }
 
 function purgeQueue (schema) {
-  return `DELETE from ${schema}.job WHERE name = $1 and state < '${states.active}'`
+  return `DELETE from ${schema}.job WHERE name = $1 and state < '${JOB_STATES.active}'`
 }
 
 function clearStorage (schema) {
@@ -288,57 +417,13 @@ function clearStorage (schema) {
 }
 
 function getQueueSize (schema, options = {}) {
-  options.before = options.before || states.active
-  assert(options.before in states, `${options.before} is not a valid state`)
+  options.before = options.before || JOB_STATES.active
+  assert(options.before in JOB_STATES, `${options.before} is not a valid state`)
   return `SELECT count(*) as count FROM ${schema}.job WHERE name = $1 AND state < '${options.before}'`
 }
 
-function createTableQueue (schema) {
-  return `
-    CREATE TABLE ${schema}.queue (
-      name text primary key,
-      policy text,
-      retry_limit int,
-      retry_delay int,
-      retry_backoff bool,
-      expire_seconds int,
-      retention_minutes int,
-      dead_letter text,
-      created_on timestamp with time zone not null default now()
-    )
-  `
-}
-
-function createTableSchedule (schema) {
-  return `
-    CREATE TABLE ${schema}.schedule (
-      name text primary key,
-      cron text not null,
-      timezone text,
-      data jsonb,
-      options jsonb,
-      created_on timestamp with time zone not null default now(),
-      updated_on timestamp with time zone not null default now()
-    )
-  `
-}
-
-function createTableSubscription (schema) {
-  return `
-    CREATE TABLE ${schema}.subscription (
-      event text not null,
-      name text not null,
-      created_on timestamp with time zone not null default now(),
-      updated_on timestamp with time zone not null default now(),
-      PRIMARY KEY(event, name)
-    )
-  `
-}
-
 function getSchedules (schema) {
-  return `
-    SELECT * FROM ${schema}.schedule
-  `
+  return `SELECT * FROM ${schema}.schedule`
 }
 
 function schedule (schema) {
@@ -412,20 +497,19 @@ function fetchNextJob (schema) {
       SELECT id
       FROM ${schema}.job
       WHERE name = $1
-        AND state < '${states.active}'
-        AND startAfter < now()
-      ORDER BY ${priority && 'priority desc, '} createdOn, id
+        AND state < '${JOB_STATES.active}'
+        AND start_after < now()
+      ORDER BY ${priority && 'priority desc, '} created_on, id
       LIMIT $2
       FOR UPDATE SKIP LOCKED
     )
     UPDATE ${schema}.job j SET
-      state = '${states.active}',
-      startedOn = now(),
-      retryCount = CASE WHEN startedOn IS NOT NULL THEN retryCount + 1 ELSE retryCount END
+      state = '${JOB_STATES.active}',
+      started_on = now(),
+      retry_count = CASE WHEN started_on IS NOT NULL THEN retry_count + 1 ELSE retry_count END
     FROM next
     WHERE name = $1 AND j.id = next.id
-    RETURNING ${includeMetadata ? 'j.*' : 'j.id, name, data'}, 
-      EXTRACT(epoch FROM expireIn) as expire_in_seconds
+    RETURNING j.${includeMetadata ? allJobColumns : baseJobColumns}      
   `
 }
 
@@ -433,12 +517,12 @@ function completeJobs (schema) {
   return `
     WITH results AS (
       UPDATE ${schema}.job
-      SET completedOn = now(),
-        state = '${states.completed}',
+      SET completed_on = now(),
+        state = '${JOB_STATES.completed}',
         output = $3::jsonb
       WHERE name = $1
         AND id IN (SELECT UNNEST($2::uuid[]))
-        AND state = '${states.active}'
+        AND state = '${JOB_STATES.active}'
       RETURNING *
     )
     SELECT COUNT(*) FROM results
@@ -446,14 +530,14 @@ function completeJobs (schema) {
 }
 
 function failJobsById (schema) {
-  const where = `name = $1 AND id IN (SELECT UNNEST($2::uuid[])) AND state < '${states.completed}'`
+  const where = `name = $1 AND id IN (SELECT UNNEST($2::uuid[])) AND state < '${JOB_STATES.completed}'`
   const output = '$3::jsonb'
 
   return failJobs(schema, where, output)
 }
 
 function failJobsByTimeout (schema) {
-  const where = `state = '${states.active}' AND (startedOn + expireIn) < now()`
+  const where = `state = '${JOB_STATES.active}' AND (started_on + expire_in) < now()`
   const output = '\'{ "value": { "message": "job failed by timeout in active state" } }\'::jsonb'
   return failJobs(schema, where, output)
 }
@@ -463,36 +547,36 @@ function failJobs (schema, where, output) {
     WITH results AS (
       UPDATE ${schema}.job SET
         state = CASE
-          WHEN retryCount < retryLimit THEN '${states.retry}'::${schema}.job_state
-          ELSE '${states.failed}'::${schema}.job_state
+          WHEN retry_count < retry_limit THEN '${JOB_STATES.retry}'::${schema}.job_state
+          ELSE '${JOB_STATES.failed}'::${schema}.job_state
           END,
-        completedOn = CASE
-          WHEN retryCount < retryLimit THEN NULL
+        completed_on = CASE
+          WHEN retry_count < retry_limit THEN NULL
           ELSE now()
           END,
-        startAfter = CASE
-          WHEN retryCount = retryLimit THEN startAfter
-          WHEN NOT retryBackoff THEN now() + retryDelay * interval '1'
+        start_after = CASE
+          WHEN retry_count = retry_limit THEN start_after
+          WHEN NOT retry_backoff THEN now() + retry_delay * interval '1'
           ELSE now() + (
-                retryDelay * 2 ^ LEAST(16, retryCount + 1) / 2 +
-                retryDelay * 2 ^ LEAST(16, retryCount + 1) / 2 * random()
+                retry_delay * 2 ^ LEAST(16, retry_count + 1) / 2 +
+                retry_delay * 2 ^ LEAST(16, retry_count + 1) / 2 * random()
             ) * interval '1'
           END,
         output = ${output}
       WHERE ${where}
       RETURNING *
     ), dlq_jobs as (
-      INSERT INTO ${schema}.job (name, data, output, retryLimit, keepUntil)
+      INSERT INTO ${schema}.job (name, data, output, retry_limit, keep_until)
       SELECT
-        deadletter,
+        dead_letter,
         data,
         output,
-        retryLimit,
-        keepUntil + (keepUntil - startAfter)
+        retry_limit,
+        keep_until + (keep_until - start_after)
       FROM results
-      WHERE state = '${states.failed}'
-        AND deadletter IS NOT NULL
-        AND NOT name = deadletter
+      WHERE state = '${JOB_STATES.failed}'
+        AND dead_letter IS NOT NULL
+        AND NOT name = dead_letter
     )
     SELECT COUNT(*) FROM results
   `
@@ -502,11 +586,11 @@ function cancelJobs (schema) {
   return `
     with results as (
       UPDATE ${schema}.job
-      SET completedOn = now(),
-        state = '${states.cancelled}'
+      SET completed_on = now(),
+        state = '${JOB_STATES.cancelled}'
       WHERE name = $1
         AND id IN (SELECT UNNEST($2::uuid[]))
-        AND state < '${states.completed}'
+        AND state < '${JOB_STATES.completed}'
       RETURNING 1
     )
     SELECT COUNT(*) from results
@@ -517,10 +601,23 @@ function resumeJobs (schema) {
   return `
     with results as (
       UPDATE ${schema}.job
-      SET completedOn = NULL,
-        state = '${states.created}'
+      SET completed_on = NULL,
+        state = '${JOB_STATES.created}'
       WHERE name = $1
         AND id IN (SELECT UNNEST($2::uuid[]))
+        AND state = '${JOB_STATES.cancelled}'
+      RETURNING 1
+    )
+    SELECT COUNT(*) from results
+  `
+}
+
+function deleteJobs (schema) {
+  return `
+    with results as (
+      DELETE FROM ${schema}.job
+      WHERE name = $1
+        AND id IN (SELECT UNNEST($2::uuid[]))        
       RETURNING 1
     )
     SELECT COUNT(*) from results
@@ -534,15 +631,15 @@ function insertJob (schema) {
       name,
       data,
       priority,
-      startAfter,
-      singletonKey,
-      singletonOn,
-      deadletter,
-      expireIn,
-      keepUntil,
-      retryLimit,
-      retryDelay,
-      retryBackoff,
+      start_after,
+      singleton_key,
+      singleton_on,
+      dead_letter,
+      expire_in,
+      keep_until,
+      retry_limit,
+      retry_delay,
+      retry_backoff,
       policy
     )
     SELECT
@@ -550,27 +647,27 @@ function insertJob (schema) {
       j.name,
       data,
       priority,
-      startAfter,
-      singletonKey,
-      singletonOn,
-      COALESCE(deadLetter, q.dead_letter) as deadletter,
+      start_after,
+      singleton_key,
+      singleton_on,
+      COALESCE(j.dead_letter, q.dead_letter) as dead_letter,
       CASE
-        WHEN expireIn IS NOT NULL THEN CAST(expireIn as interval)
+        WHEN expire_in IS NOT NULL THEN CAST(expire_in as interval)
         WHEN q.expire_seconds IS NOT NULL THEN q.expire_seconds * interval '1s'
-        WHEN expireInDefault IS NOT NULL THEN CAST(expireInDefault as interval)
+        WHEN expire_in_default IS NOT NULL THEN CAST(expire_in_default as interval)
         ELSE interval '15 minutes'
-        END as expireIn,
+        END as expire_in,
       CASE
-        WHEN right(keepUntil, 1) = 'Z' THEN CAST(keepUntil as timestamp with time zone)
-        ELSE startAfter + CAST(COALESCE(keepUntil, (q.retention_minutes * 60)::text, keepUntilDefault, '14 days') as interval)
-        END as keepUntil,
-      COALESCE(retryLimit, q.retry_limit, retryLimitDefault, 2) as retryLimit,
+        WHEN right(keep_until, 1) = 'Z' THEN CAST(keep_until as timestamp with time zone)
+        ELSE start_after + CAST(COALESCE(keep_until, (q.retention_minutes * 60)::text, keep_until_default, '14 days') as interval)
+        END as keep_until,
+      COALESCE(j.retry_limit, q.retry_limit, retry_limit_default, 2) as retry_limit,
       CASE
-        WHEN COALESCE(retryBackoff, q.retry_backoff, retryBackoffDefault, false)
-        THEN GREATEST(COALESCE(retryDelay, q.retry_delay, retryDelayDefault), 1)
-        ELSE COALESCE(retryDelay, q.retry_delay, retryDelayDefault, 0)
-        END as retryDelay,
-      COALESCE(retryBackoff, q.retry_backoff, retryBackoffDefault, false) as retryBackoff,
+        WHEN COALESCE(j.retry_backoff, q.retry_backoff, retry_backoff_default, false)
+        THEN GREATEST(COALESCE(j.retry_delay, q.retry_delay, retry_delay_default), 1)
+        ELSE COALESCE(j.retry_delay, q.retry_delay, retry_delay_default, 0)
+        END as retry_delay,
+      COALESCE(j.retry_backoff, q.retry_backoff, retry_backoff_default, false) as retry_backoff,
       q.policy
     FROM
       ( SELECT
@@ -581,24 +678,24 @@ function insertJob (schema) {
           CASE
             WHEN right($5, 1) = 'Z' THEN CAST($5 as timestamp with time zone)
             ELSE now() + CAST(COALESCE($5,'0') as interval)
-            END as startAfter,
-          $6 as singletonKey,
+            END as start_after,
+          $6 as singleton_key,
           CASE
             WHEN $7::integer IS NOT NULL THEN 'epoch'::timestamp + '1 second'::interval * ($7 * floor((date_part('epoch', now()) + $8) / $7))
             ELSE NULL
-            END as singletonOn,
-          $9 as deadletter,
-          $10 as expireIn,
-          $11 as expireInDefault,
-          $12 as keepUntil,
-          $13 as keepUntilDefault,
-          $14::int as retryLimit,
-          $15::int as retryLimitDefault,
-          $16::int as retryDelay,
-          $17::int as retryDelayDefault,
-          $18::bool as retryBackoff,
-          $19::bool as retryBackoffDefault
-      ) j LEFT JOIN ${schema}.queue q ON j.name = q.name
+            END as singleton_on,
+          $9 as dead_letter,
+          $10 as expire_in,
+          $11 as expire_in_default,
+          $12 as keep_until,
+          $13 as keep_until_default,
+          $14::int as retry_limit,
+          $15::int as retry_limit_default,
+          $16::int as retry_delay,
+          $17::int as retry_delay_default,
+          $18::bool as retry_backoff,
+          $19::bool as retry_backoff_default
+      ) j JOIN ${schema}.queue q ON j.name = q.name
     ON CONFLICT DO NOTHING
     RETURNING id
   `
@@ -608,68 +705,76 @@ function insertJobs (schema) {
   return `
     WITH defaults as (
       SELECT 
-        $2 as expireIn,
-        $3 as keepUntil,
-        $4::int as retryLimit,
-        $5::int as retryDelay,
-        $6::bool as retryBackoff
+        $2 as expire_in,
+        $3 as keep_until,
+        $4::int as retry_limit,
+        $5::int as retry_delay,
+        $6::bool as retry_backoff
     )
     INSERT INTO ${schema}.job (
       id,
       name,
       data,
       priority,
-      startAfter,
-      singletonKey,
-      deadletter,
-      expireIn,
-      keepUntil,
-      retryLimit,
-      retryDelay,
-      retryBackoff,
+      start_after,
+      singleton_key,
+      dead_letter,
+      expire_in,
+      keep_until,
+      retry_limit,
+      retry_delay,
+      retry_backoff,
       policy
     )
     SELECT
       COALESCE(id, gen_random_uuid()) as id,
       j.name,
       data,
-      COALESCE(priority, 0),
-      COALESCE("startAfter", now()),
-      "singletonKey",
-      COALESCE("deadLetter", q.dead_letter),
+      COALESCE(priority, 0) as priority,
+      j.start_after,
+      "singletonKey" as singleton_key,
+      COALESCE("deadLetter", q.dead_letter) as dead_letter,
       CASE
         WHEN "expireInSeconds" IS NOT NULL THEN "expireInSeconds" *  interval '1s'
         WHEN q.expire_seconds IS NOT NULL THEN q.expire_seconds * interval '1s'
-        WHEN defaults.expireIn IS NOT NULL THEN CAST(defaults.expireIn as interval)
+        WHEN defaults.expire_in IS NOT NULL THEN CAST(defaults.expire_in as interval)
         ELSE interval '15 minutes'
-        END as expireIn,
+        END as expire_in,
       CASE
         WHEN "keepUntil" IS NOT NULL THEN "keepUntil"
-        ELSE COALESCE("startAfter", now()) + CAST(COALESCE((q.retention_minutes * 60)::text, defaults.keepUntil, '14 days') as interval)
-        END as keepUntil,
-      COALESCE("retryLimit", q.retry_limit, defaults.retryLimit, 2),
+        ELSE COALESCE(j.start_after, now()) + CAST(COALESCE((q.retention_minutes * 60)::text, defaults.keep_until, '14 days') as interval)
+        END as keep_until,
+      COALESCE("retryLimit", q.retry_limit, defaults.retry_limit, 2),
       CASE
-        WHEN COALESCE("retryBackoff", q.retry_backoff, defaults.retryBackoff, false)
-          THEN GREATEST(COALESCE("retryDelay", q.retry_delay, defaults.retryDelay), 1)
-        ELSE COALESCE("retryDelay", q.retry_delay, defaults.retryDelay, 0)
-        END as retryDelay,      
-      COALESCE("retryBackoff", q.retry_backoff, defaults.retryBackoff, false) as retryBackoff,
+        WHEN COALESCE("retryBackoff", q.retry_backoff, defaults.retry_backoff, false)
+          THEN GREATEST(COALESCE("retryDelay", q.retry_delay, defaults.retry_delay), 1)
+        ELSE COALESCE("retryDelay", q.retry_delay, defaults.retry_delay, 0)
+        END as retry_delay,      
+      COALESCE("retryBackoff", q.retry_backoff, defaults.retry_backoff, false) as retry_backoff,
       q.policy
-    FROM json_to_recordset($1) as j (
-      id uuid,
-      name text,
-      priority integer,
-      data jsonb,
-      "startAfter" timestamp with time zone,
-      "retryLimit" integer,
-      "retryDelay" integer,
-      "retryBackoff" boolean,
-      "singletonKey" text,
-      "expireInSeconds" integer,
-      "keepUntil" timestamp with time zone,
-      "deadLetter" text
-    )
-    LEFT JOIN ${schema}.queue q ON j.name = q.name,
+    FROM (
+      SELECT *,
+        CASE
+          WHEN right("startAfter", 1) = 'Z' THEN CAST("startAfter" as timestamp with time zone)
+          ELSE now() + CAST(COALESCE("startAfter",'0') as interval)
+          END as start_after
+      FROM json_to_recordset($1) as x (
+        id uuid,
+        name text,
+        priority integer,
+        data jsonb,
+        "startAfter" text,
+        "retryLimit" integer,
+        "retryDelay" integer,
+        "retryBackoff" boolean,
+        "singletonKey" text,
+        "singletonOn" text,
+        "expireInSeconds" integer,
+        "keepUntil" timestamp with time zone,
+        "deadLetter" text
+      ) 
+    ) j
+    JOIN ${schema}.queue q ON j.name = q.name,
       defaults
     ON CONFLICT DO NOTHING
   `
@@ -678,25 +783,25 @@ function insertJobs (schema) {
 function drop (schema, interval) {
   return `
     DELETE FROM ${schema}.archive
-    WHERE archivedOn < (now() - interval '${interval}')
+    WHERE archived_on < (now() - interval '${interval}')
   `
 }
 
 function archive (schema, completedInterval, failedInterval = completedInterval) {
+  const columns = 'id, name, priority, data, state, retry_limit, retry_count, retry_delay, retry_backoff, start_after, started_on, singleton_key, singleton_on, expire_in, created_on, completed_on, keep_until, dead_letter, policy, output'
+
   return `
     WITH archived_rows AS (
       DELETE FROM ${schema}.job
-      WHERE (state <> '${states.failed}' AND completedOn < (now() - interval '${completedInterval}'))
-        OR (state = '${states.failed}' AND completedOn < (now() - interval '${failedInterval}'))
-        OR (state < '${states.active}' AND keepUntil < now())
+      WHERE (state <> '${JOB_STATES.failed}' AND completed_on < (now() - interval '${completedInterval}'))
+        OR (state = '${JOB_STATES.failed}' AND completed_on < (now() - interval '${failedInterval}'))
+        OR (state < '${JOB_STATES.active}' AND keep_until < now())
       RETURNING *
     )
-    INSERT INTO ${schema}.archive (
-      id, name, priority, data, state, retryLimit, retryCount, retryDelay, retryBackoff, startAfter, startedOn, singletonKey, singletonOn, expireIn, createdOn, completedOn, keepUntil, deadletter, policy, output
-    )
-    SELECT
-      id, name, priority, data, state, retryLimit, retryCount, retryDelay, retryBackoff, startAfter, startedOn, singletonKey, singletonOn, expireIn, createdOn, completedOn, keepUntil, deadletter, policy, output
+    INSERT INTO ${schema}.archive (${columns})
+    SELECT ${columns}
     FROM archived_rows
+    ON CONFLICT DO NOTHING
   `
 }
 
@@ -716,6 +821,7 @@ function locked (schema, query) {
   return `
     BEGIN;
     SET LOCAL lock_timeout = '30s';
+    SET LOCAL idle_in_transaction_session_timeout = '30s';
     ${advisoryLock(schema)};
     ${query};
     COMMIT;
@@ -724,7 +830,7 @@ function locked (schema, query) {
 
 function advisoryLock (schema, key) {
   return `SELECT pg_advisory_xact_lock(
-      ('x' || md5(current_database() || '.pgboss.${schema}${key || ''}'))::bit(64)::bigint
+      ('x' || encode(sha224((current_database() || '.pgboss.${schema}${key || ''}')::bytea), 'hex'))::bit(64)::bigint
   )`
 }
 
@@ -734,13 +840,13 @@ function assertMigration (schema, version) {
 }
 
 function getJobById (schema) {
-  return getJobByTableAndId(schema, 'job')
+  return getJobByTableQueueId(schema, 'job')
 }
 
 function getArchivedJobById (schema) {
-  return getJobByTableAndId(schema, 'archive')
+  return getJobByTableQueueId(schema, 'archive')
 }
 
-function getJobByTableAndId (schema, table) {
-  return `SELECT * FROM ${schema}.${table} WHERE name = $1 AND id = $2`
+function getJobByTableQueueId (schema, table) {
+  return `SELECT ${allJobColumns} FROM ${schema}.${table} WHERE name = $1 AND id = $2`
 }