queue_classic 3.1.0.RC1 → 4.0.0.pre.beta1

data/lib/queue_classic/queue.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'conn_adapter'
 require 'json'
 require 'time'
@@ -5,11 +7,11 @@ require 'time'
 module QC
   # The queue class maps a queue abstraction onto a database table.
   class Queue
-
     attr_reader :name, :top_bound
+
     def initialize(name, top_bound=nil)
       @name = name
-      @top_bound = top_bound || QC::TOP_BOUND
+      @top_bound = top_bound || QC.top_bound
     end
 
     def conn_adapter=(a)
@@ -34,10 +36,20 @@ module QC
     # The args are stored as a collection and then splatted inside the worker.
     # Examples of args include: `'hello world'`, `['hello world']`,
     # `'hello', 'world'`.
+    # This method returns a hash with the id of the enqueued job.
     def enqueue(method, *args)
       QC.log_yield(:measure => 'queue.enqueue') do
-        s = "INSERT INTO #{TABLE_NAME} (q_name, method, args) VALUES ($1, $2, $3)"
-        conn_adapter.execute(s, name, method, JSON.dump(args))
+        s = "INSERT INTO #{QC.table_name} (q_name, method, args) VALUES ($1, $2, $3) RETURNING id"
+        begin
+          retries ||= 0
+          conn_adapter.execute(s, name, method, JSON.dump(args))
+        rescue PG::Error
+          if (retries += 1) < 2
+            retry
+          else
+            raise
+          end
+        end
       end
     end
 
@@ -46,8 +58,9 @@ module QC
     # The time argument must be a Time object or a float timestamp. The method
     # and args argument must be in the form described in the documentation for
     # the #enqueue method.
+    # This method returns a hash with the id of the enqueued job.
     def enqueue_at(timestamp, method, *args)
-      offset = Time.at(timestamp) - Time.now
+      offset = Time.at(timestamp).to_i - Time.now.to_i
       enqueue_in(offset, method, *args)
     end
 
@@ -56,25 +69,55 @@ module QC
     # The seconds argument must be an integer. The method and args argument
     # must be in the form described in the documentation for the #enqueue
     # method.
+    # This method returns a hash with the id of the enqueued job.
     def enqueue_in(seconds, method, *args)
       QC.log_yield(:measure => 'queue.enqueue') do
-        s = "INSERT INTO #{TABLE_NAME} (q_name, method, args, scheduled_at)
-             VALUES ($1, $2, $3, now() + interval '#{seconds.to_i} seconds')"
-        res = conn_adapter.execute(s, name, method, JSON.dump(args))
+        s = "INSERT INTO #{QC.table_name} (q_name, method, args, scheduled_at)
+             VALUES ($1, $2, $3, now() + interval '#{seconds.to_i} seconds')
+             RETURNING id"
+        begin
+          retries ||= 0
+          conn_adapter.execute(s, name, method, JSON.dump(args))
+        rescue PG::Error
+          if (retries += 1) < 2
+            retry
+          else
+            raise
+          end
+        end
       end
     end
 
     def lock
       QC.log_yield(:measure => 'queue.lock') do
-        s = "SELECT * FROM lock_head($1, $2)"
-        if r = conn_adapter.execute(s, name, top_bound)
+        s = <<~SQL
+          WITH selected_job AS (
+            SELECT id
+            FROM queue_classic_jobs
+            WHERE
+              locked_at IS NULL AND
+              q_name = $1 AND
+              scheduled_at <= now()
+            LIMIT 1
+            FOR NO KEY UPDATE SKIP LOCKED
+          )
+          UPDATE queue_classic_jobs
+          SET
+            locked_at = now(),
+            locked_by = pg_backend_pid()
+          FROM selected_job
+          WHERE queue_classic_jobs.id = selected_job.id
+          RETURNING *
+        SQL
+
+        if r = conn_adapter.execute(s, name)
           {}.tap do |job|
             job[:id] = r["id"]
             job[:q_name] = r["q_name"]
             job[:method] = r["method"]
             job[:args] = JSON.parse(r["args"])
             if r["scheduled_at"]
-              job[:scheduled_at] = Time.parse(r["scheduled_at"])
+              job[:scheduled_at] = r["scheduled_at"].kind_of?(Time) ? r["scheduled_at"] : Time.parse(r["scheduled_at"])
               ttl = Integer((Time.now - job[:scheduled_at]) * 1000)
               QC.measure("time-to-lock=#{ttl}ms source=#{name}")
             end
@@ -85,31 +128,46 @@ module QC
 
     def unlock(id)
       QC.log_yield(:measure => 'queue.unlock') do
-        s = "UPDATE #{TABLE_NAME} set locked_at = null where id = $1"
+        s = "UPDATE #{QC.table_name} SET locked_at = NULL WHERE id = $1"
         conn_adapter.execute(s, id)
       end
     end
 
     def delete(id)
       QC.log_yield(:measure => 'queue.delete') do
-        conn_adapter.execute("DELETE FROM #{TABLE_NAME} where id = $1", id)
+        conn_adapter.execute("DELETE FROM #{QC.table_name} WHERE id = $1", id)
       end
     end
 
     def delete_all
       QC.log_yield(:measure => 'queue.delete_all') do
-        s = "DELETE FROM #{TABLE_NAME} WHERE q_name = $1"
+        s = "DELETE FROM #{QC.table_name} WHERE q_name = $1"
         conn_adapter.execute(s, name)
       end
     end
 
+    # Count the number of jobs in a specific queue. This returns all
+    # jobs, including ones that are scheduled in the future.
     def count
-      QC.log_yield(:measure => 'queue.count') do
-        s = "SELECT COUNT(*) FROM #{TABLE_NAME} WHERE q_name = $1"
-        r = conn_adapter.execute(s, name)
+      _count('queue.count', "SELECT COUNT(*) FROM #{QC.table_name} WHERE q_name = $1")
+    end
+
+    # Count the number of jobs in a specific queue, except ones scheduled in the future
+    def count_ready
+      _count('queue.count_scheduled', "SELECT COUNT(*) FROM #{QC.table_name} WHERE q_name = $1 AND scheduled_at <= now()")
+    end
+
+    # Count the number of jobs in a specific queue scheduled in the future
+    def count_scheduled
+      _count('queue.count_scheduled', "SELECT COUNT(*) FROM #{QC.table_name} WHERE q_name = $1 AND scheduled_at > now()")
+    end
+
+    private
+    def _count(metric_name, sql)
+      QC.log_yield(measure: metric_name) do
+        r = conn_adapter.execute(sql, name)
         r["count"].to_i
       end
     end
-
   end
 end

data/lib/queue_classic/railtie.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rails/railtie'
 
 module QC

data/lib/queue_classic/setup.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module QC
   module Setup
     Root = File.expand_path("../..", File.dirname(__FILE__))
@@ -8,51 +10,66 @@ module QC
     DowngradeFrom_3_0_0 = File.join(Root, "/sql/downgrade_from_3_0_0.sql")
     UpgradeTo_3_1_0 = File.join(Root, "/sql/update_to_3_1_0.sql")
     DowngradeFrom_3_1_0 = File.join(Root, "/sql/downgrade_from_3_1_0.sql")
+    UpgradeTo_4_0_0 = File.join(Root, "/sql/update_to_4_0_0.sql")
+    DowngradeFrom_4_0_0 = File.join(Root, "/sql/downgrade_from_4_0_0.sql")
 
     def self.create(c = QC::default_conn_adapter.connection)
-      conn = QC::ConnAdapter.new(c)
+      conn = QC::ConnAdapter.new(connection: c)
       conn.execute(File.read(CreateTable))
       conn.execute(File.read(SqlFunctions))
       conn.disconnect if c.nil? #Don't close a conn we didn't create.
     end
 
     def self.drop(c = QC::default_conn_adapter.connection)
-      conn = QC::ConnAdapter.new(c)
+      conn = QC::ConnAdapter.new(connection: c)
       conn.execute("DROP TABLE IF EXISTS queue_classic_jobs CASCADE")
       conn.execute(File.read(DropSqlFunctions))
       conn.disconnect if c.nil? #Don't close a conn we didn't create.
     end
 
     def self.update(c = QC::default_conn_adapter.connection)
-      conn = QC::ConnAdapter.new(c)
+      conn = QC::ConnAdapter.new(connection: c)
       conn.execute(File.read(UpgradeTo_3_0_0))
       conn.execute(File.read(UpgradeTo_3_1_0))
+      conn.execute(File.read(UpgradeTo_4_0_0))
       conn.execute(File.read(DropSqlFunctions))
       conn.execute(File.read(SqlFunctions))
     end
 
     def self.update_to_3_0_0(c = QC::default_conn_adapter.connection)
-      conn = QC::ConnAdapter.new(c)
+      conn = QC::ConnAdapter.new(connection: c)
       conn.execute(File.read(UpgradeTo_3_0_0))
       conn.execute(File.read(DropSqlFunctions))
       conn.execute(File.read(SqlFunctions))
     end
 
     def self.downgrade_from_3_0_0(c = QC::default_conn_adapter.connection)
-      conn = QC::ConnAdapter.new(c)
+      conn = QC::ConnAdapter.new(connection: c)
       conn.execute(File.read(DowngradeFrom_3_0_0))
     end
 
     def self.update_to_3_1_0(c = QC::default_conn_adapter.connection)
-      conn = QC::ConnAdapter.new(c)
+      conn = QC::ConnAdapter.new(connection: c)
       conn.execute(File.read(UpgradeTo_3_1_0))
       conn.execute(File.read(DropSqlFunctions))
       conn.execute(File.read(SqlFunctions))
     end
 
     def self.downgrade_from_3_1_0(c = QC::default_conn_adapter.connection)
-      conn = QC::ConnAdapter.new(c)
+      conn = QC::ConnAdapter.new(connection: c)
       conn.execute(File.read(DowngradeFrom_3_1_0))
     end
+
+    def self.update_to_4_0_0(c = QC::default_conn_adapter.connection)
+      conn = QC::ConnAdapter.new(connection: c)
+      conn.execute(File.read(UpgradeTo_4_0_0))
+      conn.execute(File.read(DropSqlFunctions))
+      conn.execute(File.read(SqlFunctions))
+    end
+
+    def self.downgrade_from_4_0_0(c = QC::default_conn_adapter.connection)
+      conn = QC::ConnAdapter.new(connection: c)
+      conn.execute(File.read(DowngradeFrom_4_0_0))
+    end
   end
 end

data/lib/queue_classic/tasks.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 task :environment
 
 namespace :jobs do
@@ -6,16 +8,13 @@ namespace :jobs do
 end
 
 namespace :qc do
-  desc "Start a new worker for the (default or $QUEUE) queue"
+  desc "Start a new worker for the (default or $QUEUE / $QUEUES) queue"
   task :work  => :environment do
-    @worker = QC::Worker.new
+    @worker = QC.default_worker_class.new
 
     trap('INT') do
-      $stderr.puts("Received INT. Shutting down.")
-      if !@worker.running
-        $stderr.puts("Worker has stopped running. Exit.")
-        exit(1)
-      end
+      $stderr.puts("Received INT. Shutting down.")      
+      abort("Worker has stopped running. Exit.") unless @worker.running
       @worker.stop
     end
 
@@ -27,7 +26,7 @@ namespace :qc do
     @worker.start
   end
 
-  desc "Returns the number of jobs in the (default or QUEUE) queue"
+  desc "Returns the number of jobs in the (default or $QUEUE / $QUEUES) queue"
   task :count => :environment do
     puts QC.default_queue.count
   end

data/lib/queue_classic/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module QC
+  VERSION = "4.0.0-beta1"
+end

data/lib/queue_classic/worker.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+# -*- coding: utf-8 -*-
 require_relative 'queue'
 require_relative 'conn_adapter'
 
@@ -11,24 +14,24 @@ module QC
     # This method takes a single hash argument. The following keys are read:
     # fork_worker:: Worker forks each job execution.
     # wait_interval:: Time to wait between failed lock attempts
-    # connection:: PGConn object.
+    # connection:: PG::Connection object.
     # q_name:: Name of a single queue to process.
     # q_names:: Names of queues to process. Will process left to right.
     # top_bound:: Offset to the head of the queue. 1 == strict FIFO.
     def initialize(args={})
-      @fork_worker = args[:fork_worker] || QC::FORK_WORKER
-      @wait_interval = args[:wait_interval] || QC::WAIT_TIME
+      @fork_worker = args[:fork_worker] || QC.fork_worker?
+      @wait_interval = args[:wait_interval] || QC.wait_time
 
       if args[:connection]
-        @conn_adapter = ConnAdapter.new(args[:connection])
+        @conn_adapter = ConnAdapter.new(connection: args[:connection])
       else
         @conn_adapter = QC.default_conn_adapter
       end
 
       @queues = setup_queues(@conn_adapter,
-        (args[:q_name] || QC::QUEUE),
-        (args[:q_names] || QC::QUEUES),
-        (args[:top_bound] || QC::TOP_BOUND))
+        (args[:q_name] || QC.queue),
+        (args[:q_names] || QC.queues),
+        (args[:top_bound] || QC.top_bound))
       log(args.merge(:at => "worker_initialized"))
       @running = true
     end
@@ -101,7 +104,7 @@ module QC
     # then it is deleted from the queue.
     # If the job has raised an exception the responsibility of what
     # to do with the job is delegated to Worker#handle_failure.
-    # If the job is not finished and an INT signal is traped,
+    # If the job is not finished and an INT signal is trapped,
     # this method will unlock the job in the queue.
     def process(queue, job)
       start = Time.now
@@ -111,7 +114,10 @@ module QC
           queue.delete(job[:id])
           finished = true
         end
-      rescue => e
+      rescue StandardError, ScriptError, NoMemoryError => e
+        # We really only want to unlock the job for signal and system exit
+        # exceptions. If we encounter a ScriptError or a NoMemoryError any
+        # future run will likely encounter the same error.
         handle_failure(job, e)
         finished = true
       ensure
@@ -133,10 +139,10 @@ module QC
       receiver.send(message, *args)
     end
 
-    # This method will be called when an exception
-    # is raised during the execution of the job.
+    # This method will be called when a StandardError, ScriptError or
+    # NoMemoryError is raised during the execution of the job.
     def handle_failure(job,e)
-      $stderr.puts("count#qc.job-error=1 job=#{job} error=#{e.inspect}")
+      $stderr.puts("count#qc.job-error=1 job=#{job} error=#{e.inspect} at=#{e.backtrace.first}")
     end
 
     # This method should be overriden if

data/lib/queue_classic.rb

@@ -1,40 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "queue_classic/config"
+
 module QC
-  # You can use the APP_NAME to query for
-  # postgres related process information in the
-  # pg_stat_activity table.
-  APP_NAME = ENV["QC_APP_NAME"] || "queue_classic"
-
-  # Number of seconds to block on the listen chanel for new jobs.
-  WAIT_TIME = (ENV["QC_LISTEN_TIME"] || 5).to_i
-
-  # Why do you want to change the table name?
-  # Just deal with the default OK?
-  # If you do want to change this, you will
-  # need to update the PL/pgSQL lock_head() function.
-  # Come on. Don't do it.... Just stick with the default.
-  TABLE_NAME = "queue_classic_jobs"
-
-  # Each row in the table will have a column that
-  # notes the queue. You can point your workers
-  # at different queues but only one at a time.
-  QUEUE = ENV["QUEUE"] || "default"
-  QUEUES = (ENV["QUEUES"] && ENV["QUEUES"].split(",")) || []
-
-  # Set this to 1 for strict FIFO.
-  # There is nothing special about 9....
-  TOP_BOUND = (ENV["QC_TOP_BOUND"] || 9).to_i
-
-  # Set this variable if you wish for
-  # the worker to fork a UNIX process for
-  # each locked job. Remember to re-establish
-  # any database connections. See the worker
-  # for more details.
-  FORK_WORKER = !ENV["QC_FORK_WORKER"].nil?
+  extend QC::Config
+
+  # Assign constants for backwards compatibility.
+  # They should no longer be used. Prefer the corresponding methods.
+  # See +QC::Config+ for more details.
+  DEPRECATED_CONSTANTS = {
+    :APP_NAME => :app_name,
+    :WAIT_TIME => :wait_time,
+    :TABLE_NAME => :table_name,
+    :QUEUE => :queue,
+    :QUEUES => :queues,
+    :TOP_BOUND => :top_bound,
+    :FORK_WORKER => :fork_worker?,
+  }
+
+  def self.const_missing(const_name)
+    if DEPRECATED_CONSTANTS.key? const_name
+      config_method = DEPRECATED_CONSTANTS[const_name]
+      $stderr.puts <<-MSG
+The constant QC::#{const_name} is deprecated and will be removed in the future.
+Please use the method QC.#{config_method} instead.
+      MSG
+      QC.public_send config_method
+    else
+      super
+    end
+  end
 
   # Defer method calls on the QC module to the
   # default queue. This facilitates QC.enqueue()
   def self.method_missing(sym, *args, &block)
-    default_queue.send(sym, *args, &block)
+    if default_queue.respond_to? sym
+      default_queue.public_send(sym, *args, &block)
+    else
+      super
+    end
   end
 
   # Ensure QC.respond_to?(:enqueue) equals true (ruby 1.9 only)
@@ -42,37 +46,21 @@ module QC
     default_queue.respond_to?(method_name)
   end
 
-  def self.default_queue=(queue)
-    @default_queue = queue
-  end
-
-  def self.default_queue
-    @default_queue ||= begin
-      Queue.new(QUEUE)
-    end
-  end
-
   def self.has_connection?
-    !@conn_adapter.nil?
+    !default_conn_adapter.nil?
   end
 
   def self.default_conn_adapter
-    return @conn_adapter if defined?(@conn_adapter) && @conn_adapter
-    if rails_connection_sharing_enabled?
-      @conn_adapter = ConnAdapter.new(ActiveRecord::Base.connection.raw_connection)
-    else
-      @conn_adapter = ConnAdapter.new
-    end
-    @conn_adapter
+    Thread.current[:qc_conn_adapter] ||= ConnAdapter.new(active_record_connection_share: rails_connection_sharing_enabled?)
   end
 
   def self.default_conn_adapter=(conn)
-    @conn_adapter = conn
+    Thread.current[:qc_conn_adapter] = conn
   end
 
   def self.log_yield(data)
+    t0 = Time.now
     begin
-      t0 = Time.now
       yield
     rescue => e
       log({:at => "error", :error => e.inspect}.merge(data))
@@ -106,14 +94,18 @@ module QC
   # This will unlock all jobs any postgres' PID that is not existing anymore
   # to prevent any infinitely locked jobs
   def self.unlock_jobs_of_dead_workers
-    @conn_adapter.execute("UPDATE #{QC::TABLE_NAME} SET locked_at = NULL, locked_by = NULL WHERE locked_by NOT IN (SELECT pid FROM pg_stat_activity);")
+    default_conn_adapter.execute("UPDATE #{QC.table_name} SET locked_at = NULL, locked_by = NULL WHERE locked_by NOT IN (SELECT pid FROM pg_stat_activity);")
   end
 
-  private
-  def self.rails_connection_sharing_enabled?
-    enabled = ENV.fetch('QC_RAILS_DATABASE', 'true') != 'false'
-    return false unless enabled
-    return Object.const_defined?("ActiveRecord") && ActiveRecord::Base.respond_to?("connection")
+  # private class methods
+  class << self
+    private
+
+    def rails_connection_sharing_enabled?
+      enabled = ENV.fetch('QC_RAILS_DATABASE', 'true') != 'false'
+      return false unless enabled
+      return Object.const_defined?("ActiveRecord") && ActiveRecord::Base.respond_to?("connection")
+    end
   end
 end
 

data/queue_classic.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'queue_classic/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "queue_classic"
+  spec.email         = "r@32k.io"
+  spec.version       = QC::VERSION
+  spec.description   = "queue_classic is a queueing library for Ruby apps. (Rails, Sinatra, Etc...) queue_classic features asynchronous job polling, database maintained locks and no ridiculous dependencies. As a matter of fact, queue_classic only requires pg."
+  spec.summary       = "Simple, efficient worker queue for Ruby & PostgreSQL."
+  spec.authors       = ["Ryan Smith (♠ ace hacker)"]
+  spec.homepage      = "http://github.com/QueueClassic/queue_classic"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.require_paths = %w[lib]
+
+  spec.add_dependency "pg", ">= 0.17", "< 2.0"
+  spec.add_development_dependency "activerecord", ">= 5.0.0", "< 6.1"
+end

data/sql/create_table.sql

@@ -1,24 +1,17 @@
-do $$ begin
+DO $$ BEGIN
 
 CREATE TABLE queue_classic_jobs (
   id bigserial PRIMARY KEY,
-  q_name text not null check (length(q_name) > 0),
-  method text not null check (length(method) > 0),
-  args   text not null,
+  q_name text NOT NULL CHECK (length(q_name) > 0),
+  method text NOT NULL CHECK (length(method) > 0),
+  args   jsonb NOT NULL,
   locked_at timestamptz,
   locked_by integer,
-  created_at timestamptz default now(),
-  scheduled_at timestamptz default now()
+  created_at timestamptz DEFAULT now(),
+  scheduled_at timestamptz DEFAULT now()
 );
 
--- If json type is available, use it for the args column.
-perform * from pg_type where typname = 'json';
-if found then
-  alter table queue_classic_jobs alter column args type json using (args::json);
-end if;
-
-end $$ language plpgsql;
+END $$ LANGUAGE plpgsql;
 
 CREATE INDEX idx_qc_on_name_only_unlocked ON queue_classic_jobs (q_name, id) WHERE locked_at IS NULL;
 CREATE INDEX idx_qc_on_scheduled_at_only_unlocked ON queue_classic_jobs (scheduled_at, id) WHERE locked_at IS NULL;
-

data/sql/ddl.sql

@@ -1,84 +1,8 @@
--- We are declaring the return type to be queue_classic_jobs.
--- This is ok since I am assuming that all of the users added queues will
--- have identical columns to queue_classic_jobs.
--- When QC supports queues with columns other than the default, we will have to change this.
-
-CREATE OR REPLACE FUNCTION lock_head(q_name varchar, top_boundary integer)
-RETURNS SETOF queue_classic_jobs AS $$
-DECLARE
-  unlocked bigint;
-  relative_top integer;
-  job_count integer;
-BEGIN
-  -- The purpose is to release contention for the first spot in the table.
-  -- The select count(*) is going to slow down dequeue performance but allow
-  -- for more workers. Would love to see some optimization here...
-
-  EXECUTE 'SELECT count(*) FROM '
-    || '(SELECT * FROM queue_classic_jobs '
-    || ' WHERE locked_at IS NULL'
-    || ' AND q_name = '
-    || quote_literal(q_name)
-    || ' AND scheduled_at <= '
-    || quote_literal(now())
-    || ' LIMIT '
-    || quote_literal(top_boundary)
-    || ') limited'
-  INTO job_count;
-
-  SELECT TRUNC(random() * (top_boundary - 1))
-  INTO relative_top;
-
-  IF job_count < top_boundary THEN
-    relative_top = 0;
-  END IF;
-
-  LOOP
-    BEGIN
-      EXECUTE 'SELECT id FROM queue_classic_jobs '
-        || ' WHERE locked_at IS NULL'
-        || ' AND q_name = '
-        || quote_literal(q_name)
-        || ' AND scheduled_at <= '
-        || quote_literal(now())
-        || ' ORDER BY id ASC'
-        || ' LIMIT 1'
-        || ' OFFSET ' || quote_literal(relative_top)
-        || ' FOR UPDATE NOWAIT'
-      INTO unlocked;
-      EXIT;
-    EXCEPTION
-      WHEN lock_not_available THEN
-        -- do nothing. loop again and hope we get a lock
-    END;
-  END LOOP;
-
-  RETURN QUERY EXECUTE 'UPDATE queue_classic_jobs '
-    || ' SET locked_at = (CURRENT_TIMESTAMP),'
-    || ' locked_by = (select pg_backend_pid())'
-    || ' WHERE id = $1'
-    || ' AND locked_at is NULL'
-    || ' RETURNING *'
-  USING unlocked;
-
-  RETURN;
-END;
-$$ LANGUAGE plpgsql;
-
-CREATE OR REPLACE FUNCTION lock_head(tname varchar)
-RETURNS SETOF queue_classic_jobs AS $$
-BEGIN
-  RETURN QUERY EXECUTE 'SELECT * FROM lock_head($1,10)' USING tname;
-END;
-$$ LANGUAGE plpgsql;
-
 -- queue_classic_notify function and trigger
-create function queue_classic_notify() returns trigger as $$ begin
-  perform pg_notify(new.q_name, '');
-  return null;
-end $$ language plpgsql;
+CREATE FUNCTION queue_classic_notify() RETURNS TRIGGER AS $$ BEGIN
+  perform pg_notify(new.q_name, ''); RETURN NULL;
+END $$ LANGUAGE plpgsql;
 
-create trigger queue_classic_notify
-after insert on queue_classic_jobs
-for each row
-execute procedure queue_classic_notify();
+CREATE TRIGGER queue_classic_notify
+AFTER INSERT ON queue_classic_jobs FOR EACH ROW
+EXECUTE PROCEDURE queue_classic_notify();