que 0.2.0 → 0.3.0

data/spec/unit/worker_spec.rb

@@ -84,7 +84,7 @@ describe Que::Worker do
       @worker = Que::Worker.new
 
       $q1.pop
-      @worker.stop!
+      @worker.stop
       $q2.push nil
 
       @worker.wait_until_stopped
@@ -105,7 +105,7 @@ describe Que::Worker do
       @worker = Que::Worker.new
       sleep_until { @worker.sleeping? }
 
-      @worker.stop!
+      @worker.stop
       @worker.wait_until_stopped
     ensure
       if @worker
@@ -114,4 +114,23 @@ describe Que::Worker do
       end
     end
   end
+
+  it "should receive and respect a notification to kill its job and stop running immediately" do
+    begin
+      # Worker#stop! can leave the database connection in an unpredictable
+      # state, which would impact the rest of the tests, so we need a special
+      # connection for it.
+      pg = NEW_PG_CONNECTION.call
+      Que.connection = pg
+
+      BlockJob.queue
+
+      @worker = Que::Worker.new
+      $q1.pop
+      @worker.stop!
+      @worker.wait_until_stopped
+    ensure
+      pg.close if pg
+    end
+  end
 end

data/tasks/benchmark.rb

@@ -1,93 +1 @@
-task :benchmark do
-  # The following benchmark is meant to test Que's scalability by having it
-  # bombard Postgres from many, many processes. Note that this benchmark tests
-  # the entire Que stack, not just the locking queries.
-
-  JOB_COUNT          = (ENV['JOB_COUNT'] || 1000).to_i
-  PROCESS_COUNT      = (ENV['PROCESS_COUNT'] || 1).to_i
-  WORKER_COUNT       = (ENV['WORKER_COUNT']  || 4).to_i
-  SYNCHRONOUS_COMMIT = ENV['SYNCHRONOUS_COMMIT'] || 'on'
-
-  require 'que'
-  require 'uri'
-  require 'pg'
-  require 'connection_pool'
-
-  uri = URI.parse ENV["DATABASE_URL"] || "postgres://postgres:@localhost/que-test"
-
-  new_connection = proc do
-    conn = PG::Connection.open :host     => uri.host,
-                               :user     => uri.user,
-                               :password => uri.password,
-                               :port     => uri.port || 5432,
-                               :dbname   => uri.path[1..-1]
-
-    conn.async_exec "SET SESSION synchronous_commit = #{SYNCHRONOUS_COMMIT}"
-    conn
-  end
-
-  Que.connection = pg = new_connection.call
-  Que.drop! rescue nil
-  Que.create!
-
-  # Stock table with jobs and analyze.
-  pg.async_exec <<-SQL
-    INSERT INTO que_jobs (job_class, args, priority)
-    SELECT 'Que::Job', ('[' || i || ',{}]')::json, 1
-    FROM generate_Series(1,#{JOB_COUNT}) AS i;
-    ANALYZE;
-  SQL
-
-  # Fork!
-  $parent_pid = Process.pid
-  def parent?
-    Process.pid == $parent_pid
-  end
-
-  # Synchronize all workers to start at the same time using, what else?
-  # Advisory locks. I am such a one-trick pony.
-  pg.async_exec("SELECT pg_advisory_lock(0)")
-
-  PROCESS_COUNT.times { Process.fork if parent? }
-
-  if parent?
-    # This is the main process, get ready to start monitoring the queues.
-
-    # First hold until all the children are ready.
-    sleep 0.1 until pg.async_exec("select count(*) from pg_locks where locktype = 'advisory' and objid = 0").first['count'].to_i == PROCESS_COUNT + 1
-
-    puts "Benchmarking: #{JOB_COUNT} jobs, #{PROCESS_COUNT} processes with #{WORKER_COUNT} workers each, synchronous_commit = #{SYNCHRONOUS_COMMIT}..."
-    pg.async_exec("select pg_advisory_unlock_all()") # Go!
-    start = Time.now
-
-    loop do
-      sleep 0.01
-      break if pg.async_exec("SELECT 1 AS one FROM que_jobs LIMIT 1").none? # There must be a better way to do this?
-    end
-    time = Time.now - start
-
-    locks = pg.async_exec("SELECT * FROM pg_locks WHERE locktype = 'advisory'").to_a
-    puts "Advisory locks left over! #{locks.inspect}" if locks.any?
-    puts "#{JOB_COUNT} jobs in #{time} seconds = #{(JOB_COUNT / time).round} jobs per second"
-  else
-    # This is a child, get ready to start hitting the queues.
-    pool = ConnectionPool.new :size => WORKER_COUNT, &new_connection
-
-    Que.connection = pool
-
-    pool.with do |conn|
-      # Block here until the advisory lock is released, which is our start pistol.
-      conn.async_exec "SELECT pg_advisory_lock(0); SELECT pg_advisory_unlock_all();"
-    end
-
-    Que.mode = :async
-    Que.worker_count = WORKER_COUNT
-
-    loop do
-      sleep 1
-      break if pool.with { |pg| pg.async_exec("SELECT 1 AS one FROM que_jobs LIMIT 1").none? }
-    end
-  end
-
-  Process.waitall
-end
+# The benchmarking tasks have been merged together and now live at github.com/chanks/queue-shootout.

data/tasks/safe_shutdown.rb

@@ -0,0 +1,63 @@
+# This task is used to test Que's behavior when its process is shut down.
+
+# The situation we're trying to avoid occurs when the process dies while a job
+# is in the middle of a transaction - ideally, the transaction would be rolled
+# back and the job could just be reattempted later, but if we're not careful,
+# the transaction could be committed too early. For specifics, see this post:
+
+# http://coderrr.wordpress.com/2011/05/03/beware-of-threadkill-or-your-activerecord-transactions-are-in-danger-of-being-partially-committed/
+
+# So, this task opens a transaction within a job, makes a write, then prompts
+# you to kill it with one of a few signals. It also checks to see whether the
+# previous shutdown was clean or not.
+
+task :safe_shutdown do
+  require 'sequel'
+  require 'que'
+
+  url = ENV['DATABASE_URL'] || 'postgres://postgres:@localhost/que-test'
+  DB = Sequel.connect(url)
+
+  if DB.table_exists?(:que_jobs)
+    puts "Uh-oh! Previous shutdown wasn't clean!" if DB[:que_jobs].where(:job_id => 0).count > 0
+    DB.drop_table :que_jobs
+  end
+
+  Que.connection = DB
+  Que.create!
+
+  $queue = Queue.new
+
+  class SafeJob < Que::Job
+    def run
+      DB.transaction do
+        DB[:que_jobs].insert(:job_id => 0, :job_class => 'Que::Job')
+        $queue.push nil
+        sleep
+      end
+    end
+  end
+
+  SafeJob.queue
+  Que.mode = :async
+  $queue.pop
+
+  puts "From a different terminal window, run one of the following:"
+  %w(SIGINT SIGTERM SIGKILL).each do |signal|
+    puts "kill -#{signal} #{Process.pid}"
+  end
+
+  # Put exit behavior to test the behavior of here:
+  at_exit do
+    puts "Stopping Que..."
+    Que.stop!
+  end
+
+  stop = false
+  trap('INT'){stop = true}
+
+  loop do
+    sleep 0.01
+    break if stop
+  end
+end

metadata

@@ -1,43 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: que
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Chris Hanks
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-30 00:00:00.000000000 Z
+date: 2013-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
-  version_requirements: !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
-  requirement: !ruby/object:Gem::Requirement
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
-  prerelease: false
-  type: :development
 - !ruby/object:Gem::Dependency
   name: multi_json
-  version_requirements: !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-  requirement: !ruby/object:Gem::Requirement
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-  prerelease: false
-  type: :runtime
 description: A job queue that uses PostgreSQL's advisory locks for speed and reliability.
 email:
 - christopher.m.hanks@gmail.com
@@ -45,8 +45,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
+- ".gitignore"
+- ".rspec"
 - CHANGELOG.md
 - Gemfile
 - LICENSE.txt
@@ -83,30 +83,30 @@ files:
 - spec/unit/work_spec.rb
 - spec/unit/worker_spec.rb
 - tasks/benchmark.rb
-- tasks/benchmark_queues.rb
 - tasks/rspec.rb
+- tasks/safe_shutdown.rb
 homepage: https://github.com/chanks/que
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project:
+rubyforge_project: 
 rubygems_version: 2.1.5
-signing_key:
+signing_key: 
 specification_version: 4
 summary: A PostgreSQL-based Job Queue
 test_files:

data/tasks/benchmark_queues.rb

@@ -1,398 +0,0 @@
-task :benchmark_queues do
-  # The following is a somewhat simplistic benchmark (aren't they all) meant
-  # to compare the speed and concurrency of the locking mechanisms used by Que
-  # (standard and lateral queries), DelayedJob and QueueClassic - it does this
-  # by simply sending the raw queries that each system sends during operation.
-
-  # It is NOT meant to benchmark the overall performance of each system (which
-  # would include the time each spends working in Ruby), but to see which one
-  # supports the highest concurrency under load, assuming that there will be
-  # many workers and that Postgres will be the bottleneck. I'm unsure how
-  # useful it is for this, but it's a start.
-
-  JOB_COUNT          = (ENV['JOB_COUNT'] || 1000).to_i
-  WORKER_COUNT       = (ENV['WORKER_COUNT'] || 10).to_i
-  SYNCHRONOUS_COMMIT = ENV['SYNCHRONOUS_COMMIT'] || 'on'
-
-  require 'uri'
-  require 'pg'
-  require 'connection_pool'
-
-  uri = URI.parse ENV["DATABASE_URL"] || "postgres://postgres:@localhost/que-test"
-
-  new_connection = proc do
-    PG::Connection.open :host     => uri.host,
-                        :user     => uri.user,
-                        :password => uri.password,
-                        :port     => uri.port || 5432,
-                        :dbname   => uri.path[1..-1]
-  end
-
-  pg = new_connection.call
-
-
-
-  # Necessary setup, mostly for QueueClassic. I apologize for this - I hope your editor supports code folding.
-  pg.async_exec <<-SQL
-    SET SESSION client_min_messages = 'WARNING';
-
-    -- Que table.
-    DROP TABLE IF EXISTS que_jobs;
-    CREATE TABLE que_jobs
-    (
-      priority    integer     NOT NULL DEFAULT 1,
-      run_at      timestamptz NOT NULL DEFAULT now(),
-      job_id      bigserial   NOT NULL,
-      job_class   text        NOT NULL,
-      args        json        NOT NULL DEFAULT '[]'::json,
-      error_count integer     NOT NULL DEFAULT 0,
-      last_error  text,
-
-      CONSTRAINT que_jobs_pkey PRIMARY KEY (priority, run_at, job_id)
-    );
-
-    DROP TABLE IF EXISTS que_lateral_jobs;
-    CREATE TABLE que_lateral_jobs
-    (
-      priority    integer     NOT NULL DEFAULT 1,
-      run_at      timestamptz NOT NULL DEFAULT now(),
-      job_id      bigserial   NOT NULL,
-      job_class   text        NOT NULL,
-      args        json        NOT NULL DEFAULT '[]'::json,
-      error_count integer     NOT NULL DEFAULT 0,
-      last_error  text,
-
-      CONSTRAINT que_lateral_jobs_pkey PRIMARY KEY (priority, run_at, job_id)
-    );
-
-    DROP TABLE IF EXISTS delayed_jobs;
-    -- DelayedJob table.
-    CREATE TABLE delayed_jobs
-    (
-      id serial NOT NULL,
-      priority integer NOT NULL DEFAULT 0,
-      attempts integer NOT NULL DEFAULT 0,
-      handler text NOT NULL,
-      last_error text,
-      run_at timestamp without time zone,
-      locked_at timestamp without time zone,
-      failed_at timestamp without time zone,
-      locked_by character varying(255),
-      queue character varying(255),
-      created_at timestamp without time zone,
-      updated_at timestamp without time zone,
-      CONSTRAINT delayed_jobs_pkey PRIMARY KEY (id)
-    );
-    ALTER TABLE delayed_jobs
-      OWNER TO postgres;
-
-    CREATE INDEX delayed_jobs_priority
-      ON delayed_jobs
-      USING btree
-      (priority, run_at);
-
-
-
-    -- QueueClassic table and functions.
-    DROP FUNCTION IF EXISTS lock_head(tname varchar);
-    DROP FUNCTION IF EXISTS lock_head(q_name varchar, top_boundary integer);
-    DROP FUNCTION IF EXISTS queue_classic_notify() cascade;
-    DROP TABLE IF EXISTS queue_classic_jobs;
-
-    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,
-      locked_at timestamptz
-    );
-
-    alter table queue_classic_jobs alter column args type json using (args::json);
-
-    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 INDEX idx_qc_on_name_only_unlocked ON queue_classic_jobs (q_name, id) WHERE locked_at IS NULL;
-
-    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 q_name = '
-        || quote_literal(q_name)
-        || ' 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)
-            || ' 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)'
-        || ' 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;
-
-
-
-
-
-    INSERT INTO que_jobs (job_class, args, priority)
-    SELECT 'Que::Job', ('[' || i || ',{}]')::json, 1
-    FROM generate_Series(1,#{JOB_COUNT}) AS i;
-
-    INSERT INTO que_lateral_jobs (job_class, args, priority)
-    SELECT 'Que::Job', ('[' || i || ',{}]')::json, 1
-    FROM generate_Series(1,#{JOB_COUNT}) AS i;
-
-    INSERT INTO delayed_jobs (handler, run_at, created_at, updated_at)
-    SELECT '--- !ruby/struct:NewsletterJob\ntext: lorem ipsum...\nemails: blah@blah.com\n', now(), now(), now()
-    FROM generate_Series(1,#{JOB_COUNT}) AS i;
-
-    INSERT INTO queue_classic_jobs (q_name, method, args)
-    SELECT 'default', 'Kernel.puts', '["hello world"]'
-    FROM generate_Series(1,#{JOB_COUNT}) AS i;
-
-
-
-
-    -- Necessary tables and functions made, now stock them with jobs and analyze.
-    ANALYZE;
-  SQL
-
-
-  queries = {
-    :que => (
-      <<-SQL
-        WITH RECURSIVE cte AS (
-          SELECT (job).*, pg_try_advisory_lock((job).job_id) AS locked
-          FROM (
-            SELECT job
-            FROM que_jobs AS job
-            WHERE run_at <= now()
-            ORDER BY priority, run_at, job_id
-            LIMIT 1
-          ) AS t1
-          UNION ALL (
-            SELECT (job).*, pg_try_advisory_lock((job).job_id) AS locked
-            FROM (
-              SELECT (
-               SELECT job
-                FROM que_jobs AS job
-                WHERE run_at <= now() AND (priority, run_at, job_id) > (cte.priority, cte.run_at, cte.job_id)
-                ORDER BY priority, run_at, job_id
-                LIMIT 1
-              ) AS job
-              FROM cte
-              WHERE NOT cte.locked
-              LIMIT 1
-            ) AS t1
-          )
-        )
-        SELECT job_id, priority, run_at, args, job_class, error_count
-        FROM cte
-        WHERE locked
-        LIMIT 1
-      SQL
-    ),
-    :que_lateral => (
-      <<-SQL
-        WITH RECURSIVE cte AS (
-          SELECT *, pg_try_advisory_lock(s.job_id) AS locked
-          FROM (
-            SELECT *
-            FROM que_lateral_jobs
-            WHERE run_at <= now()
-            ORDER BY priority, run_at, job_id
-            LIMIT 1
-          ) s
-          UNION ALL (
-            SELECT j.*, pg_try_advisory_lock(j.job_id) AS locked
-            FROM (
-              SELECT *
-              FROM cte
-              WHERE NOT locked
-            ) t,
-            LATERAL (
-              SELECT *
-              FROM que_lateral_jobs
-              WHERE run_at <= now()
-              AND (priority, run_at, job_id) > (t.priority, t.run_at, t.job_id)
-              ORDER BY priority, run_at, job_id
-              LIMIT 1
-            ) j
-          )
-        )
-        SELECT *
-        FROM cte
-        WHERE locked
-        LIMIT 1
-      SQL
-    ),
-    :delayed_job => (
-      # From delayed_job_active_record
-      <<-SQL
-        UPDATE delayed_jobs
-        SET locked_at = now(),
-            locked_by = $1::text
-        WHERE id IN (
-          SELECT id
-          FROM delayed_jobs
-          WHERE (
-            (run_at <= now() AND (locked_at IS NULL OR locked_at < now()) OR locked_by = $1) AND failed_at IS NULL
-          )
-          ORDER BY priority ASC, run_at ASC
-          LIMIT 1
-          FOR UPDATE
-        )
-        RETURNING *
-      SQL
-    )
-  }
-
-  connections = WORKER_COUNT.times.map do
-    conn = new_connection.call
-    conn.async_exec "SET SESSION synchronous_commit = #{SYNCHRONOUS_COMMIT}"
-    queries.each do |name, sql|
-      conn.prepare(name.to_s, sql)
-    end
-    conn
-  end
-
-
-
-  # Track the ids that are worked, to make sure they're all hit.
-  $results = {
-    :delayed_job   => [],
-    :queue_classic => [],
-    :que           => [],
-    :que_lateral   => []
-  }
-
-  def work_job(type, conn)
-    case type
-    when :delayed_job
-      return unless r = conn.exec_prepared("delayed_job", [conn.object_id]).first
-      $results[type] << r['id']
-      conn.async_exec "DELETE FROM delayed_jobs WHERE id = $1", [r['id']]
-
-    when :queue_classic
-      return unless r = conn.async_exec("SELECT * FROM lock_head($1, $2)", ['default', 9]).first
-      $results[type] << r['id']
-      conn.async_exec "DELETE FROM queue_classic_jobs WHERE id = $1", [r['id']]
-
-    when :que
-      begin
-        return unless r = conn.exec_prepared("que").first
-        # Have to double-check that the job is valid, as explained at length in Que::Job.work.
-        return true unless conn.async_exec("SELECT * FROM que_jobs WHERE priority = $1 AND run_at = $2 AND job_id = $3", [r['priority'], r['run_at'], r['job_id']]).first
-        conn.async_exec "DELETE FROM que_jobs WHERE priority = $1 AND run_at = $2 AND job_id = $3", [r['priority'], r['run_at'], r['job_id']]
-        $results[type] << r['job_id']
-      ensure
-        conn.async_exec "SELECT pg_advisory_unlock_all()" if r
-      end
-
-    when :que_lateral
-      begin
-        return unless r = conn.exec_prepared("que_lateral").first
-        return true unless conn.async_exec("SELECT * FROM que_lateral_jobs WHERE priority = $1 AND run_at = $2 AND job_id = $3", [r['priority'], r['run_at'], r['job_id']]).first
-        conn.async_exec "DELETE FROM que_lateral_jobs WHERE priority = $1 AND run_at = $2 AND job_id = $3", [r['priority'], r['run_at'], r['job_id']]
-        $results[type] << r['job_id']
-      ensure
-        conn.async_exec "SELECT pg_advisory_unlock_all()" if r
-      end
-
-    end
-  end
-
-  puts "Benchmarking #{JOB_COUNT} jobs, #{WORKER_COUNT} workers and synchronous_commit = #{SYNCHRONOUS_COMMIT}..."
-
-  {
-    :delayed_job   => :delayed_jobs,
-    :queue_classic => :queue_classic_jobs,
-    :que           => :que_jobs,
-    :que_lateral   => :que_lateral_jobs
-  }.each do |type, table|
-    print "Benchmarking #{type}... "
-    start = Time.now
-
-    threads = connections.map do |conn|
-      Thread.new do
-        loop do
-          begin
-            break unless work_job(type, conn)
-          rescue
-            # DelayedJob deadlocks sometimes.
-          end
-        end
-      end
-    end
-
-    threads.each &:join
-    time = Time.now - start
-    puts "#{JOB_COUNT} jobs in #{time} seconds = #{(JOB_COUNT / time).round} jobs per second"
-
-
-    # These checks are commented out because I can't seem to get DelayedJob to
-    # pass them (Que and QueueClassic don't have the same problem). It seems
-    # to repeat some jobs multiple times on every run, and its run times are
-    # also highly variable.
-
-    # worked = $results[type].map(&:to_i).sort
-    # puts "Jobs worked more than once! #{worked.inspect}" unless worked == worked.uniq
-    # puts "Jobs worked less than once! #{worked.inspect}" unless worked.length == JOB_COUNT
-
-    puts "Jobs left in DB" unless pg.async_exec("SELECT count(*) FROM #{table}").first['count'].to_i == 0
-    puts "Advisory locks left over!" if pg.async_exec("SELECT * FROM pg_locks WHERE locktype = 'advisory'").first
-  end
-end