workhorse 2.0.0.rc0 → 2.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 69859406636c3463da70d9e274f023e5b0838720e428f77b8f0babad2e15baf9
-  data.tar.gz: 6af9c55d5f9066be6801898d3786311d3a0f5c33723baf3a5e4d464c107ace85
+  metadata.gz: 84d0f28bfeb67292f3de373115ada4ef7c2cff27b29e847af29326733ba89841
+  data.tar.gz: f69f1d82c2c9c15f47f87d8f8390c31e655596636383b9cadefc8c240d8f43b6
 SHA512:
-  metadata.gz: b674430cc63891334e49f4ce52b1cc407dea1fdd5575beab8792b82c4f12729596bfb16829ebd859bfefc2881a701e75ff85d8bca8e1e479a081b50e1bc7d0e0
-  data.tar.gz: 3db6d62ef9a9dbd950dcb40ac6399a6d28ab166bc75a8b592153de315672423f76b2a6518e58d219de789edf1cc2faa81368f568c637585e5d2a05247b626e14
+  metadata.gz: 00c490f9e4aa2b57066b8b974e38286509cb156cb27f79dc7d7a355c9797338eaa8dcf33a5dc9c07e2f3bbe37878d0be5e82b7f098da9e45194ad0fe5b064d6f
+  data.tar.gz: e0116907c47ae31d9fa5a5626e331a503286667966aa974255e8d9f816c363fe3a9e55406e5f79c9a3da7e82abe4b0648b505de3e279992a58e1864d847edaef

data/.github/workflows/ruby.yml

@@ -40,10 +40,146 @@ jobs:
       - name: Run rake tests
         uses: nick-fields/retry@v2
         with:
-          timeout_seconds: 120
+          # Not much above what one run takes on a loaded runner.
+          timeout_seconds: 300
           retry_on: any
           max_attempts: 3
           command: bundle exec rake test TESTOPTS='--verbose'
+          # A timed-out attempt can leave the suite and its daemon workers
+          # running - the workers call setsid, so killing the attempt does not
+          # reach them - and the next attempt then runs against them. KILL, as
+          # a worker traps TERM. Clear their pidfiles as well.
+          on_retry_command: |
+            pkill -KILL -f "^Workhorse .*: $GITHUB_WORKSPACE" || true
+            pkill -KILL -f "[r]ake_test_loader" || true
+            sleep 1
+            rm -f tmp/pids/*
+
+  test-oracle:
+    runs-on: ubuntu-latest
+
+    # Oracle gets a job of its own rather than a matrix entry: it needs a
+    # service container and the Instant Client, and it is run against a single
+    # Ruby version, as what is being covered is the database dialect rather
+    # than the interpreter.
+    services:
+      oracle:
+        image: gvenzl/oracle-free:23-slim
+        env:
+          ORACLE_PASSWORD: oracle
+          APP_USER: workhorse
+          APP_USER_PASSWORD: workhorse
+        ports:
+          - 1521:1521
+        options: >-
+          --health-cmd healthcheck.sh
+          --health-interval 20s
+          --health-timeout 10s
+          --health-retries 30
+
+    env:
+      DB_ADAPTER: oracle_enhanced
+      DB_NAME: FREEPDB1
+      DB_USERNAME: workhorse
+      DB_PASSWORD: workhorse
+      DB_HOST: localhost
+      DB_PORT: 1521
+      LD_LIBRARY_PATH: /opt/oracle/instantclient
+
+    steps:
+      - uses: actions/checkout@v2
+
+      # ruby-oci8 compiles against the Instant Client, so both the runtime
+      # library and the SDK headers are needed; basiclite alone does not carry
+      # oci.h.
+      - name: Install Oracle Instant Client
+        run: |
+          sudo apt-get update
+          # The package was renamed in Ubuntu 24.04, which `ubuntu-latest` now
+          # is; keep working on both.
+          sudo apt-get install -y unzip
+          sudo apt-get install -y libaio1 || sudo apt-get install -y libaio1t64
+          # The rename came with a soname change to libaio.so.1t64, while the
+          # Oracle client still links against libaio.so.1. Without this the
+          # client library cannot be linked, and ruby-oci8's version probe
+          # fails with a TypeError that says nothing about the cause.
+          if ! ldconfig -p | grep -qE 'libaio\.so\.1$|libaio\.so\.1 '; then
+            t64=$(ls /usr/lib/*/libaio.so.1t64 2>/dev/null | head -1)
+            if [ -n "$t64" ]; then sudo ln -sfn "$t64" "$(dirname "$t64")/libaio.so.1"; fi
+          fi
+          sudo mkdir -p /opt/oracle
+          cd /tmp
+          # Pinned to 21.13 rather than taking the current release: ruby-oci8
+          # 2.2 fails its `OCI_MAJOR_VERSION` probe against an Instant Client
+          # 23 header, after finding the library and the SDK correctly. A 21
+          # client talks to the 23 server used below.
+          base=https://download.oracle.com/otn_software/linux/instantclient/2113000
+          curl -sSLO $base/instantclient-basiclite-linux.x64-21.13.0.0.0dbru.zip
+          curl -sSLO $base/instantclient-sdk-linux.x64-21.13.0.0.0dbru.zip
+          sudo unzip -oq 'instantclient-basiclite-linux.x64-*.zip' -d /opt/oracle
+          sudo unzip -oq 'instantclient-sdk-linux.x64-*.zip' -d /opt/oracle
+          # The archives unpack into a versioned directory, whose name changes
+          # with every release; the fixed symlink is what LD_LIBRARY_PATH and
+          # the ruby-oci8 build both point at.
+          sudo ln -sfn "$(find /opt/oracle -maxdepth 1 -type d -name 'instantclient_*' | head -1)" /opt/oracle/instantclient
+          # The basiclite package ships only the versioned libraries, and
+          # linking a conftest against -lclntsh needs the unversioned name.
+          cd /opt/oracle/instantclient
+          for lib in libclntsh libocci; do
+            versioned=$(ls $lib.so.* 2>/dev/null | head -1)
+            if [ -n "$versioned" ]; then sudo ln -sfn "$versioned" "$lib.so"; fi
+          done
+          echo /opt/oracle/instantclient | sudo tee /etc/ld.so.conf.d/oracle-instantclient.conf
+          sudo ldconfig
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.2.1'
+
+      - name: Install bundle including the oracle group
+        run: |
+          bundle config set --local with oracle
+          bundle install --jobs 4 --retry 3
+
+      # extconf.rb only says to consult mkmf.log, which is otherwise lost with
+      # the runner.
+      - name: Show the native extension build log
+        if: failure()
+        run: find / -name mkmf.log -path '*ruby-oci8*' -exec cat {} +
+
+      # The global lock is DBMS_LOCK on Oracle, and execute permission on that
+      # package is not granted to a new schema by default. SYS owns the
+      # package, and only it can grant it, so this connects as SYSDBA.
+      - name: Grant DBMS_LOCK to the test schema
+        run: |
+          bundle exec ruby -e '
+            require "active_record"
+            require "active_record/connection_adapters/oracle_enhanced_adapter"
+            ActiveRecord::Base.establish_connection(
+              adapter: "oracle_enhanced", database: "FREEPDB1",
+              username: "sys", password: "oracle", privilege: "SYSDBA",
+              host: "localhost", port: 1521
+            )
+            ActiveRecord::Base.connection.execute("GRANT EXECUTE ON DBMS_LOCK TO workhorse")
+          '
+
+      - name: Run rake tests
+        uses: nick-fields/retry@v2
+        with:
+          timeout_seconds: 600
+          retry_on: any
+          max_attempts: 3
+          command: bundle exec rake test TESTOPTS='--verbose'
+          # A timed-out attempt can leave the suite and its daemon workers
+          # running - the workers call setsid, so killing the attempt does not
+          # reach them - and the next attempt then runs against them. KILL, as
+          # a worker traps TERM. Clear their pidfiles as well.
+          on_retry_command: |
+            pkill -KILL -f "^Workhorse .*: $GITHUB_WORKSPACE" || true
+            pkill -KILL -f "[r]ake_test_loader" || true
+            sleep 1
+            rm -f tmp/pids/*
 
   linters:
     runs-on: ubuntu-latest

data/CHANGELOG.md

@@ -1,5 +1,53 @@
 # Workhorse Changelog
 
+## 2.0.0.rc1 - 2026-09-30
+
+Sitrox reference: #154443.
+
+### Added
+
+* Oracle 12c or later is supported again, and is now covered by CI against
+  `activerecord-oracle_enhanced-adapter` rather than only by hand. The global
+  lock uses `DBMS_LOCK`, and the generated migrations leave out the index
+  prefix lengths Oracle rejects while naming every index within the 30
+  characters it allows before 12.2. See
+  [Database support](README.md#database-support).
+
+  2.0.0.rc0 dropped Oracle; anyone who took that release up and needs it can
+  move straight to this one. Grant the schema execute permission on
+  `DBMS_LOCK`, as described under Database support.
+
+### Fixed
+
+* On Oracle, jobs are picked up in priority order. 1.x limited the rows it
+  selected by filtering on `ROWNUM`, which Oracle numbers before sorting, so
+  both the job taken from each queue and the jobs a poll picked up were an
+  arbitrary subset regardless of `priority`. Limiting now uses
+  `FETCH FIRST … ROWS ONLY`, which applies after the sort and is why 12c is
+  now the minimum.
+
+* A poll that finds the global lock taken now waits for it with a polling
+  interval below half a second. The lock timeout follows the interval, and
+  MySQL and Oracle take it as whole seconds, so they rounded it down to not
+  waiting at all - only MariaDB honours a fraction. Each such poll gave up
+  at once and counted towards `Workhorse.max_global_lock_fails`, so several
+  workers contending for the lock could trigger its alarm about a crashed
+  worker. The timeout is now rounded up to whole seconds.
+
+* A soft restart (`USR1`) no longer wedges a worker whose `tmp/pids` does not
+  exist yet, as on a fresh checkout or deployment. The worker touched its
+  shutdown file there after it had stopped accepting jobs, so failing on it
+  left a worker that took no jobs and never exited. The directory is now
+  created when missing, and a shutdown file that still cannot be written no
+  longer holds up the shutdown. The heartbeat and the memory-limit shutdown,
+  which write to the same directory, create it as well.
+
+* `Workhorse.clean_stuck_jobs` works on Oracle. It is built on splitting
+  `locked_by` into host, PID and random component, which was written with
+  MySQL's `substring_index` and so raised on Oracle for as long as the option
+  has existed — visible only to an installation that turned it on, as it is
+  off by default.
+
 ## 2.0.0.rc0 - 2026-09-29
 
 Sitrox reference: #154443.

data/Gemfile

@@ -11,5 +11,20 @@ gem 'minitest'
 gem 'mysql2'
 gem 'pry'
 gem 'rake'
-gem 'rubocop', '~> 1.60'
+
+# Pinned to a patch range rather than given a floor: Gemfile.lock is not
+# checked in, so CI resolves the newest version matching this line while a
+# checkout keeps whatever it installed. With a floor, every rubocop release
+# that adds a cop turns the build red for a reason nobody can reproduce
+# locally.
+gem 'rubocop', '~> 1.91.0'
 gem 'trilogy'
+
+# Only needed to run the suite against Oracle, which additionally requires the
+# Oracle Instant Client to be installed - building ruby-oci8 fails without it.
+# The group is optional, so a plain `bundle install` skips it; enable it with
+# `bundle config set --local with oracle`.
+group :oracle, optional: true do
+  gem 'activerecord-oracle_enhanced-adapter', '~> 7.1'
+  gem 'ruby-oci8'
+end

data/README.md

@@ -35,8 +35,8 @@ What it does not do:
 
 * Ruby `>= 3.0` (may work with earlier versions but is untested)
 * Rails `>= 7.0`
-* MySQL or MariaDB with InnoDB. No other database is supported, see
-  [Database support](#database-support).
+* One of the supported databases (see [Database support](#database-support)):
+  MySQL / MariaDB with InnoDB, or Oracle. **PostgreSQL is not supported.**
 * If you are planning on using the daemons handler:
   * An operating system and file system that supports file locking.
   * MRI Ruby (aka "CRuby") as jRuby does not support `fork`. See the
@@ -70,24 +70,35 @@ What it does not do:
 
 ### Database support
 
-**MySQL and MariaDB are the only supported databases.** Workhorse serialises
-job pickup with `GET_LOCK`, a MySQL advisory lock, which is emitted on every
-poll; a database that does not provide it fails on the first poll. InnoDB is
-required, as MyISAM supports neither transactions nor row-level locking. Both
-the `mysql2` and the `trilogy` adapter are covered by CI.
+Workhorse serialises job pickup using a database-level lock, which is
+necessarily written against a specific database's dialect. Two families are
+implemented:
 
-Oracle was supported until 2.0.0 and is not any more — see the changelog entry
-for that release. PostgreSQL has never been supported, despite the
-requirements once listing it; supporting it would mean an advisory-lock
-dialect of its own (`pg_advisory_lock`) and is not currently planned.
+| Database          | Supported | Lock used            | Covered by CI |
+|-------------------|-----------|----------------------|---------------|
+| MySQL / MariaDB   | Yes       | `GET_LOCK`           | Yes, against both the `mysql2` and the `trilogy` adapter |
+| Oracle 12c+       | Yes       | `DBMS_LOCK`          | Yes, against `activerecord-oracle_enhanced-adapter` |
+| PostgreSQL        | **No**    | —                    | — |
+| Everything else   | **No**    | —                    | — |
 
-## Upgrading from 1.x
+There is no PostgreSQL implementation: workers emit `GET_LOCK` on every poll,
+which PostgreSQL does not provide, so a worker fails on its first poll.
+Supporting it would mean an advisory-lock dialect of its own
+(`pg_advisory_lock`) and is not currently planned. Note that InnoDB is required
+on MySQL / MariaDB, as MyISAM supports neither transactions nor row-level
+locking.
+
+Oracle 12c is the minimum, as job selection limits its rows with
+`FETCH FIRST … ROWS ONLY`. When using Oracle, make sure your schema has access
+to the package `DBMS_LOCK`:
 
-Workhorse 2.0 drops support for Oracle, see
-[Database support](#database-support). An Oracle installation has no upgrade
-path and should stay on 1.x.
+```
+GRANT execute ON DBMS_LOCK TO <schema-name>;
+```
 
-Otherwise nothing breaks without migrating: [scheduling](#scheduling) is inert
+## Upgrading from 1.x
+
+Nothing breaks without migrating: [scheduling](#scheduling) is inert
 until a schedule is declared, [notifications](#notifications) are off until a
 notifier is selected, and the new job columns are only written when used. To
 take the new features up, add this migration:
@@ -130,6 +141,10 @@ class UpgradeWorkhorseToV2 < ActiveRecord::Migration[7.1]
 end
 ```
 
+On Oracle, drop every `length:` option above — it indexes the whole column and
+rejects a prefix length. The generated migrations do this for you; this one is
+written out by hand.
+
 Two behaviour changes worth knowing about, both described in the changelog: a
 forked daemon worker no longer runs `at_exit` handlers registered by the
 process that started it, and `Workhorse::Jobs::CleanupSucceededJobs` now also

data/VERSION

@@ -1 +1 @@
-2.0.0.rc0
+2.0.0.rc1

data/lib/generators/workhorse/templates/create_table_jobs.rb

@@ -29,10 +29,25 @@ class CreateTableJobs < ActiveRecord::Migration[7.1]
       t.timestamps null: false
     end
 
-    add_index :jobs, :queue, length: 191
-    add_index :jobs, %i[state perform_at], length: { state: 191 }, name: 'idx_jobs_state_perform_at'
-    add_index :jobs, %i[state priority created_at], length: { state: 191 }, name: 'idx_jobs_state_prio_created'
-    add_index :jobs, %i[state expires_at], length: { state: 191 }, name: 'idx_jobs_state_expires_at'
+    # The index names are given explicitly because the ones Rails would derive
+    # exceed the 30 characters Oracle allows before 12.2.
+    if oracle?
+      add_index :jobs, :queue
+      add_index :jobs, %i[state perform_at], name: 'idx_jobs_state_perform_at'
+      add_index :jobs, %i[state priority created_at], name: 'idx_jobs_state_prio_created'
+      add_index :jobs, %i[state expires_at], name: 'idx_jobs_state_expires_at'
+    else
+      add_index :jobs, :queue, length: 191
+      add_index :jobs, %i[state perform_at], length: { state: 191 }, name: 'idx_jobs_state_perform_at'
+      add_index :jobs, %i[state priority created_at], length: { state: 191 }, name: 'idx_jobs_state_prio_created'
+      add_index :jobs, %i[state expires_at], length: { state: 191 }, name: 'idx_jobs_state_expires_at'
+    end
     add_index :jobs, :perform_at
   end
+
+  private
+
+  def oracle?
+    ActiveRecord::Base.connection.adapter_name == 'OracleEnhanced'
+  end
 end

data/lib/generators/workhorse/templates/create_table_workhorse_schedules.rb

@@ -23,7 +23,20 @@ class CreateTableWorkhorseSchedules < ActiveRecord::Migration[7.1]
       t.timestamps null: false
     end
 
-    add_index :workhorse_schedules, :key, unique: true, length: 191, name: 'idx_wh_schedules_key'
+    # The index names are given explicitly because the ones Rails would derive
+    # exceed the 30 characters Oracle allows before 12.2.
+    if oracle?
+      add_index :workhorse_schedules, :key, unique: true, name: 'idx_wh_schedules_key'
+    else
+      add_index :workhorse_schedules, :key, unique: true, length: 191, name: 'idx_wh_schedules_key'
+    end
+
     add_index :workhorse_schedules, %i[enabled next_at], name: 'idx_wh_schedules_due'
   end
+
+  private
+
+  def oracle?
+    ActiveRecord::Base.connection.adapter_name == 'OracleEnhanced'
+  end
 end

data/lib/workhorse/daemon/shell_handler.rb

@@ -146,7 +146,10 @@ module Workhorse
 
     def self.acquire_lock(lockfile_path, flags)
       if Workhorse.lock_shell_commands
-        lockfile = File.open(lockfile_path, 'a') # rubocop:disable Style/FileOpen
+        # Not the block form: the lockfile is returned to the caller, which
+        # holds the flock for as long as the command runs.
+        # rubocop:disable-next Style/FileOpen
+        lockfile = File.open(lockfile_path, 'a')
         result = lockfile.flock(flags)
 
         if result == false

data/lib/workhorse/daemon.rb

@@ -311,9 +311,13 @@ module Workhorse
         $0 = process_name(worker)
         # Close inherited lockfile fd to prevent holding the flock after parent exits
         @lockfile&.close
-        # Reopen pipes to prevent #107576
+        # Reopen pipes to prevent #107576. Not the block form: the descriptor
+        # has to outlive this call, as stdout and stderr keep pointing at it
+        # for the lifetime of the worker.
+        # rubocop:disable Style/FileOpen
         $stdin.reopen File.open(File::NULL, 'r')
         null_out = File.open(File::NULL, 'w')
+        # rubocop:enable Style/FileOpen
         $stdout.reopen null_out
         $stderr.reopen null_out
 

data/lib/workhorse/db_job.rb

@@ -101,10 +101,25 @@ module Workhorse
     # Returns a relation with split locked_by field for easier querying.
     # Extracts host, PID, and random string components from locked_by.
     #
+    # `locked_by` is "<host>.<pid>.<random>", and the host may itself contain
+    # dots, so both dialects below work backwards from the last two.
+    #
     # @return [ActiveRecord::Relation] Relation with additional computed columns
     # @private
     def self.with_split_locked_by
-      select(<<~SQL)
+      return select(oracle? ? split_locked_by_sql_oracle : split_locked_by_sql_mysql)
+    end
+
+    # @return [Boolean] Whether the connection speaks Oracle
+    # @private
+    def self.oracle?
+      return connection.adapter_name == 'OracleEnhanced'
+    end
+
+    # @return [String]
+    # @private
+    def self.split_locked_by_sql_mysql
+      return <<~SQL
         #{table_name}.*,
 
         -- random string
@@ -127,6 +142,30 @@ module Workhorse
       SQL
     end
 
+    # Oracle has no `substring_index`. `instr` with a negative position counts
+    # occurrences from the right, which gives the two delimiters directly.
+    #
+    # @return [String]
+    # @private
+    def self.split_locked_by_sql_oracle
+      return <<~SQL
+        #{table_name}.*,
+
+        -- random string
+        substr(locked_by, instr(locked_by, '.', -1, 1) + 1) as locked_by_rnd,
+
+        -- pid
+        substr(
+          locked_by,
+          instr(locked_by, '.', -1, 2) + 1,
+          instr(locked_by, '.', -1, 1) - instr(locked_by, '.', -1, 2) - 1
+        ) as locked_by_pid,
+
+        -- get host
+        substr(locked_by, 1, instr(locked_by, '.', -1, 2) - 1) as locked_by_host
+      SQL
+    end
+
     # Resets job to state "waiting" and clears all meta fields
     # set by workhorse in course of processing this job.
     #

data/lib/workhorse/performer.rb

@@ -165,9 +165,8 @@ module Workhorse
     def deserialized_job
       # The source is safe as long as jobs are always enqueued using
       # Workhorse::Enqueuer so it is ok to use Marshal.load.
-      # rubocop: disable Security/MarshalLoad
+      # rubocop: disable-next Security/MarshalLoad
       Marshal.load(@db_job.handler)
-      # rubocop: enable Security/MarshalLoad
     end
   end
 end

data/lib/workhorse/poller.rb

@@ -1,6 +1,7 @@
 module Workhorse
   # Database poller that discovers and locks jobs for execution.
   # Handles job querying, global locking, and job distribution to workers.
+  # Supports both MySQL and Oracle databases with database-specific optimizations.
   #
   # @example Basic usage (typically used internally)
   #   poller = Workhorse::Poller.new(worker, proc { true })
@@ -17,6 +18,9 @@ module Workhorse
     # responsive to shutdown, to instant repolling and to notifications.
     SLEEP_SLICE = 0.1
 
+    ORACLE_LOCK_MODE   = 6           # X_MODE (exclusive)
+    ORACLE_LOCK_HANDLE = 478_564_848 # Randomly chosen number
+
     # @return [Workhorse::Worker] The worker this poller serves
     attr_reader :worker
 
@@ -31,6 +35,7 @@ module Workhorse
       @worker = worker
       @running = false
       @table = Workhorse::DbJob.arel_table
+      @is_oracle = ActiveRecord::Base.connection.adapter_name == 'OracleEnhanced'
       @instant_repoll = Concurrent::AtomicBoolean.new(false)
       @global_lock_fails = 0
       @max_global_lock_fails_reached = false
@@ -303,6 +308,7 @@ module Workhorse
     end
 
     # Executes a block with a global database lock.
+    # Supports both MySQL GET_LOCK and Oracle DBMS_LOCK.
     #
     # @param name [Symbol] Lock name identifier
     # @param timeout [Integer] Lock timeout in seconds
@@ -312,11 +318,25 @@ module Workhorse
     # @return [void]
     # @private
     def with_global_lock(name: :workhorse, timeout: 2, count_failures: true, &_block)
-      begin # rubocop:disable Style/RedundantBegin
-        result = Workhorse::DbJob.connection.select_all(
-          "SELECT GET_LOCK(CONCAT(DATABASE(), '_#{name}'), #{timeout})"
-        ).first.values.last
-        success = result == 1
+      # Whole seconds, rounded up: MySQL and Oracle both take the timeout as an
+      # integer and round a fraction of a second down to not waiting at all -
+      # only MariaDB honours one. A poll finding the lock taken would then give
+      # up at once, and count towards max_global_lock_fails for mere contention.
+      timeout = timeout.ceil
+
+      begin
+        if @is_oracle
+          result = Workhorse::DbJob.connection.select_all(
+            "SELECT DBMS_LOCK.REQUEST(#{ORACLE_LOCK_HANDLE}, #{ORACLE_LOCK_MODE}, #{timeout}) FROM DUAL"
+          ).first.values.last
+
+          success = result == 0
+        else
+          result = Workhorse::DbJob.connection.select_all(
+            "SELECT GET_LOCK(CONCAT(DATABASE(), '_#{name}'), #{timeout})"
+          ).first.values.last
+          success = result == 1
+        end
 
         if success
           @global_lock_fails = 0
@@ -362,7 +382,11 @@ module Workhorse
         yield
       ensure
         if success
-          Workhorse::DbJob.connection.execute("SELECT RELEASE_LOCK(CONCAT(DATABASE(), '_#{name}'))")
+          if @is_oracle
+            Workhorse::DbJob.connection.execute("SELECT DBMS_LOCK.RELEASE(#{ORACLE_LOCK_HANDLE}) FROM DUAL")
+          else
+            Workhorse::DbJob.connection.execute("SELECT RELEASE_LOCK(CONCAT(DATABASE(), '_#{name}'))")
+          end
         end
       end
     end
@@ -572,7 +596,7 @@ module Workhorse
         # any presumptions on the order.
         record_number = queue.nil? ? limit : 1
 
-        union_parts << select.take(record_number)
+        union_parts << limited_sql(select, record_number)
       end
 
       return [] if union_parts.empty?
@@ -583,10 +607,13 @@ module Workhorse
       # contained within.
       # Additionally, each of the subselects and the final union select is given
       # an alias to comply with MySQL requirements.
+      # These aliases are added directly instead of using Arel `as`, because it
+      # uses the keyword 'AS' in SQL generated for Oracle, which is invalid for
+      # table aliases.
       union_query_sql = '('
-      union_query_sql += "SELECT * FROM (#{union_parts.shift.to_sql}) union_0"
+      union_query_sql += "SELECT * FROM (#{union_parts.shift}) union_0"
       union_parts.each_with_index do |part, idx|
-        union_query_sql += " UNION SELECT * FROM (#{part.to_sql}) union_#{idx + 1}"
+        union_query_sql += " UNION SELECT * FROM (#{part}) union_#{idx + 1}"
       end
       union_query_sql += ') subselect'
 
@@ -599,10 +626,7 @@ module Workhorse
       select = table.project(Arel.star).where(table[:id].in(select.project(:id)))
       select = order(select)
 
-      # Limit number of records
-      select = select.take(limit)
-
-      return Workhorse::DbJob.find_by_sql(select.to_sql).to_a
+      return Workhorse::DbJob.find_by_sql(limited_sql(select, limit)).to_a
     end
 
     # Returns a fresh Arel select manager containing the id of all waiting jobs.
@@ -652,6 +676,21 @@ module Workhorse
       select.order(Arel.sql('priority').asc).order(Arel.sql('created_at').asc)
     end
 
+    # Returns the SQL of a select, limited to the given number of records.
+    #
+    # On Oracle this is `FETCH FIRST`, which applies after `ORDER BY`. Filtering
+    # on `ROWNUM` instead - the only option before 12c - numbers the rows
+    # before they are sorted, so it returned an arbitrary subset and ignored
+    # the priority order altogether.
+    #
+    # @param select [Arel::SelectManager] the select manager to limit
+    # @param number [Integer] the maximum number of records to return
+    # @return [String] the resultant SQL
+    def limited_sql(select, number)
+      return "#{select.to_sql} FETCH FIRST #{Integer(number)} ROWS ONLY" if @is_oracle
+      return select.take(number).to_sql
+    end
+
     # Returns an Array of queue names for which a job may be posted
     #
     # This is done in multiple steps. First, all queues with jobs that are in
@@ -696,9 +735,10 @@ module Workhorse
       queues = select.project(:queue)
 
       # Note that `select_values` is used here on purpose: `execute` does not
-      # return a result set on every adapter, while `select_values` is
+      # return a result set on every adapter (the Oracle enhanced adapter, for
+      # instance, returns `true` for queries), while `select_values` is
       # implemented in terms of `exec_query` and thus behaves the same on the
-      # mysql2 and trilogy adapters.
+      # mysql2, trilogy and Oracle enhanced adapters.
       return Workhorse::DbJob.connection.select_values(queues.distinct.to_sql)
     end
   end