feat: Add Trilogy adapter support with MariaDB 12.0+ (#134)

release-as: 0.7.5

Author: seuros

.github/workflows/ci.yml

@@ -36,6 +36,21 @@ jobs:
           MYSQL_PASSWORD: with_advisory_pass
           MYSQL_DATABASE: with_advisory_lock_test
           MYSQL_ROOT_HOST: '%'
+      mariadb:
+        image: mariadb:12
+        ports:
+          - 3306
+        env:
+          MARIADB_ROOT_PASSWORD: root
+          MARIADB_DATABASE: with_advisory_lock_trilogy_test
+          MARIADB_USER: with_advisory
+          MARIADB_PASSWORD: with_advisory_pass
+          MARIADB_ROOT_HOST: '%'
+        options: >-
+          --health-cmd "healthcheck.sh --su-mysql --connect --innodb_initialized"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
     strategy:
       fail-fast: false
       matrix:
@@ -48,6 +63,11 @@ jobs:
           - 7.2
           - "8.0"
           - "8.1"
+          - "edge"
+        exclude:
+          # TruffleRuby doesn't support Rails edge yet
+          - ruby: 'truffleruby'
+            rails: "edge"
     env:
       ACTIVERECORD_VERSION: ${{ matrix.rails }}
       RAILS_ENV: test
@@ -62,10 +82,14 @@ jobs:
           bundler-cache: true
           rubygems: latest
 
+
       - name: Setup test databases
+        timeout-minutes: 5
         env:
           DATABASE_URL_PG: postgres://with_advisory:with_advisory_pass@localhost:${{ job.services.postgres.ports[5432] }}/with_advisory_lock_test
           DATABASE_URL_MYSQL: mysql2://with_advisory:with_advisory_pass@127.0.0.1:${{ job.services.mysql.ports[3306] }}/with_advisory_lock_test
+          # Trilogy doesn't support TruffleRuby
+          DATABASE_URL_TRILOGY: ${{ matrix.ruby != 'truffleruby' && format('trilogy://with_advisory:with_advisory_pass@127.0.0.1:{0}/with_advisory_lock_trilogy_test', job.services.mariadb.ports[3306]) || '' }}
         run: |
           cd test/dummy
           bundle exec rake db:test:prepare
@@ -74,5 +98,7 @@ jobs:
         env:
           DATABASE_URL_PG: postgres://with_advisory:with_advisory_pass@localhost:${{ job.services.postgres.ports[5432] }}/with_advisory_lock_test
           DATABASE_URL_MYSQL: mysql2://with_advisory:with_advisory_pass@127.0.0.1:${{ job.services.mysql.ports[3306] }}/with_advisory_lock_test
+          # Trilogy doesn't support TruffleRuby
+          DATABASE_URL_TRILOGY: ${{ matrix.ruby != 'truffleruby' && format('trilogy://with_advisory:with_advisory_pass@127.0.0.1:{0}/with_advisory_lock_trilogy_test', job.services.mariadb.ports[3306]) || '' }}
           WITH_ADVISORY_LOCK_PREFIX: ${{ github.run_id }}
         run: bin/rails test

Gemfile

@@ -11,12 +11,17 @@ gem 'benchmark'
 gem 'logger'
 gem 'ostruct'
 
-activerecord_version = ENV.fetch('ACTIVERECORD_VERSION', '7.2')
-
-gem 'activerecord', "~> #{activerecord_version}.0"
+activerecord_version = ENV.fetch('ACTIVERECORD_VERSION', '8.1')
+
+if activerecord_version == 'edge'
+  gem 'activerecord', github: 'rails/rails', branch: 'main'
+  gem 'railties', github: 'rails/rails', branch: 'main'
+else
+  gem 'activerecord', "~> #{activerecord_version}.0"
+  gem 'railties'
+end
 
 gem 'dotenv'
-gem 'railties'
 
 platforms :ruby do
   gem 'mysql2'

docker-compose.yml

@@ -2,18 +2,28 @@ services:
   pg:
     image: postgres:17-alpine
     environment:
-      POSTGRES_USER: ${DB_USER}
-      POSTGRES_PASSWORD: ${DB_PASSWORD}
-      POSTGRES_DB: ${DB_NAME}
+      POSTGRES_USER: test
+      POSTGRES_PASSWORD: test
+      POSTGRES_DB: with_advisory_lock_test
     ports:
       - "5433:5432"
   mysql:
     image: mysql:8
     environment:
-      MYSQL_USER: ${DB_USER}
-      MYSQL_PASSWORD: ${DB_PASSWORD}
-      MYSQL_DATABASE: ${DB_NAME}
+      MYSQL_USER: test
+      MYSQL_PASSWORD: test
+      MYSQL_DATABASE: with_advisory_lock_test
       MYSQL_RANDOM_ROOT_PASSWORD: "yes"
       MYSQL_ROOT_HOST: '%'
     ports:
       - "3366:3306"
+  mariadb:
+    image: mariadb:12
+    environment:
+      MARIADB_USER: test
+      MARIADB_PASSWORD: test
+      MARIADB_DATABASE: with_advisory_lock_test_trilogy
+      MARIADB_RANDOM_ROOT_PASSWORD: "yes"
+      MARIADB_ROOT_HOST: '%'
+    ports:
+      - "3368:3306"

lib/with_advisory_lock/mysql_advisory.rb

@@ -16,12 +16,15 @@ def try_advisory_lock(lock_keys, lock_name:, shared:, transaction:, timeout_seco
       # MySQL's GET_LOCK already provides native timeout support, making the blocking
       # parameter redundant. MySQL doesn't have separate try/blocking functions like PostgreSQL.
 
-      # MySQL GET_LOCK supports native timeout:
-      # - timeout_seconds = nil: wait indefinitely (-1)
+      # MySQL/MariaDB GET_LOCK supports native timeout:
+      # - timeout_seconds = nil: wait indefinitely
       # - timeout_seconds = 0: try once, no wait (0)
       # - timeout_seconds > 0: wait up to timeout_seconds
+      #
+      # Note: MySQL accepts -1 for infinite wait, but MariaDB does not.
+      # Using a large value (1 year) for cross-compatibility.
       mysql_timeout = case timeout_seconds
-                      when nil then -1
+                      when nil then 31_536_000 # 1 year in seconds
                       when 0 then 0
                       else timeout_seconds.to_i
                       end

lib/with_advisory_lock/postgresql_advisory.rb

@@ -19,10 +19,20 @@ def try_advisory_lock(lock_keys, lock_name:, shared:, transaction:, timeout_seco
                    advisory_try_lock_function(transaction, shared)
                  end
       execute_advisory(function, lock_keys, lock_name, blocking: blocking)
+    rescue ActiveRecord::Deadlocked
+      # Rails 8.2+ raises ActiveRecord::Deadlocked directly for PostgreSQL deadlocks
+      # When using blocking locks, treat deadlocks as lock acquisition failure
+      return false if blocking
+
+      raise
     rescue ActiveRecord::StatementInvalid => e
       # PostgreSQL deadlock detection raises PG::TRDeadlockDetected (SQLSTATE 40P01)
-      # When using blocking locks, treat deadlocks as lock acquisition failure
-      if blocking && (e.cause.is_a?(PG::TRDeadlockDetected) || e.message.include?('deadlock detected'))
+      # When using blocking locks, treat deadlocks as lock acquisition failure.
+      # Rails 8.2+ may also retry after deadlock and get "current transaction is aborted"
+      # when the transaction was rolled back by PostgreSQL's deadlock detection.
+      if blocking && (e.cause.is_a?(PG::TRDeadlockDetected) ||
+                      e.message.include?('deadlock detected') ||
+                      e.message =~ ERROR_MESSAGE_REGEX)
         false
       else
         raise
@@ -117,13 +127,23 @@ def advisory_unlock_function(shared)
     end
 
     def execute_advisory(function, lock_keys, lock_name, blocking: false)
+      sql = prepare_sql(function, lock_keys, lock_name)
       if blocking
-        # Blocking locks return void - if the query executes successfully, the lock was acquired
-        query_value(prepare_sql(function, lock_keys, lock_name))
+        # Blocking locks return void - if the query executes successfully, the lock was acquired.
+        # Rails 8.2+ uses lazy transaction materialization. We must use materialize_transactions: true
+        # to ensure the transaction is started on the database before acquiring the lock,
+        # otherwise the lock won't actually block other connections.
+        if respond_to?(:internal_exec_query, true)
+          # Rails < 8.2
+          query_value(sql)
+        else
+          # Rails 8.2+ - use query_all with materialize_transactions: true
+          send(:query_all, sql, 'AdvisoryLock', materialize_transactions: true)
+        end
         true
       else
         # Non-blocking try locks return boolean
-        result = query_value(prepare_sql(function, lock_keys, lock_name))
+        result = query_value(sql)
         LOCK_RESULT_VALUES.include?(result)
       end
     end

test/dummy/app/models/trilogy_label.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class TrilogyLabel < TrilogyRecord
+  self.table_name = 'trilogy_labels'
+end

test/dummy/app/models/trilogy_record.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class TrilogyRecord < ActiveRecord::Base
+  self.abstract_class = true
+  establish_connection :trilogy
+end

test/dummy/app/models/trilogy_tag.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class TrilogyTag < TrilogyRecord
+  self.table_name = 'trilogy_tags'
+
+  after_save do
+    TrilogyTagAudit.create(tag_name: name)
+    TrilogyLabel.create(name: name)
+  end
+end

test/dummy/app/models/trilogy_tag_audit.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class TrilogyTagAudit < TrilogyRecord
+  self.table_name = 'trilogy_tag_audits'
+end

test/dummy/config/application.rb

@@ -14,6 +14,17 @@ module TestSystemApp
   class Application < Rails::Application
     config.load_defaults [Rails::VERSION::MAJOR, Rails::VERSION::MINOR].join('.')
     config.eager_load = true
+
+    # Ignore trilogy models when DATABASE_URL_TRILOGY is not set (e.g., TruffleRuby)
+    unless ENV['DATABASE_URL_TRILOGY'] && !ENV['DATABASE_URL_TRILOGY'].empty?
+      config.autoload_lib(ignore: %w[])
+      initializer 'ignore_trilogy_models', before: :set_autoload_paths do |app|
+        trilogy_models = %w[trilogy_record trilogy_tag trilogy_tag_audit trilogy_label]
+        trilogy_models.each do |model|
+          Rails.autoloaders.main.ignore(Rails.root.join('app', 'models', "#{model}.rb"))
+        end
+      end
+    end
     config.serve_static_files = false
     config.public_file_server.enabled = false
     config.public_file_server.headers = { 'Cache-Control' => 'public, max-age=3600' }