sequel-activerecord_connection

The extension synchronizes the transaction state between Sequel and ActiveRecord. This allows you to nest transactions from both libraries seamlessly.

Key behaviors:

• DB.in_transaction? will return true if an ActiveRecord transaction is currently open.
• Sequel's transaction API (including isolation levels and savepoints) is fully supported.
• Transaction hooks like after_commit are managed to ensure they execute correctly relative to the outer transaction state.

ActiveRecord::Base.transaction do
  DB.in_transaction? #=> true
end

# Using Sequel's API within an ActiveRecord transaction
DB.transaction(isolation: :serializable) do
  DB.after_commit { ... }
  DB.transaction(savepoint: true) do
    DB.after_commit(savepoint: true) { ... }
  end
end

By default, Sequel interpolates values directly into SQL strings, whereas ActiveRecord uses bound variables (e.g., $1, $2). To make Sequel logs look like ActiveRecord logs (which helps with log grouping and sensitive data protection), load the :sql_log_normalizer extension alongside :activerecord_connection.

# For PostgreSQL
Sequel.postgres(extensions: [:activerecord_connection, :sql_log_normalizer])

# Resulting log format:
# SELECT accounts.* FROM accounts WHERE accounts.email = ? LIMIT ?

Add the gem to your project using bundle. If you are using ActiveRecord 7.1 or older, you must also include the after_commit_everywhere gem to ensure proper transaction hook behavior.

$ bundle add sequel-activerecord_connection

# Required if using ActiveRecord 7.1 or older
$ bundle add after_commit_everywhere

When using the sequel-activerecord_connection extension with SQLite, the library automatically configures the underlying SQLite3::Database connection to enable extended_result_codes (if supported) and initializes a prepared statements cache via Utils.add_prepared_statements_cache. Additionally, if the Sequel database is configured with a :utc timezone and responds to current_timestamp_utc, the extension will enable current_timestamp_utc on the database object.

# The extension applies these configurations automatically when extended onto a Sequel::Database instance
# using the ActiveRecord connection reuse pattern.

The PostgreSQL adapter for sequel-activerecord_connection includes logic to detect connection failures and reraise them as Sequel::DatabaseDisconnectError.

It identifies disconnects using two methods:

1. Exception Class Matching: It checks if the raised error is included in DISCONNECT_ERROR_CLASSES (inherited from Sequel::Postgres::Adapter).
2. Message Parsing: If a PG::Error is raised, it checks the connection status and parses the error message against DISCONNECT_ERROR_REGEX to determine if the connection is no longer valid.

To enable ActiveRecord connection reuse in Sequel, register the extension using Database#register_extension. This is typically done during the Sequel database initialization.

Note: The extension attempts to load an adapter-specific module (e.g., Sequel::ActiveRecordConnection::Mysql2) to handle specific database requirements. If the adapter-specific module is not found, it assumes the standard Sequel adapter already works with ActiveRecord.

DB.register_extension(:activerecord_connection)

By default, the extension reads connection configuration from ActiveRecord::Base. If your application uses multiple databases or specific connection settings defined on a different model, you can assign that model to the Sequel database object using DB.activerecord_model = ModelName.

class MyModel < ActiveRecord::Base
  connects_to database: { writing: :animals, reading: :animals_replica }
end

DB.activerecord_model = MyModel

The extension handles transaction callbacks differently depending on your ActiveRecord version:

• ActiveRecord >= 7.2: Uses the built-in current_transaction API to register callbacks.
• ActiveRecord < 7.2: Requires the after_commit_everywhere gem (version ~> 1.1) to be present in your Gemfile to support transaction hooks.

When starting a transaction via Sequel while using this extension, isolation levels are mapped from Sequel's symbols to ActiveRecord-compatible symbols using the TRANSACTION_ISOLATION_MAP:

When using the sequel-activerecord_connection with a PostgreSQL database, certain transaction options are currently unsupported and will raise a Sequel::Error.

Specifically, you cannot use the following keys in the transaction options hash:

• :deferrable
• :read_only
• :synchronous