Comparing Active Record and Sequel in Ruby and Ruby on Rails

Database management is a crucial aspect of Ruby development. In this guide, we’ll explore two prominent ORM frameworks: Active Record and Sequel. We’ll examine their usage in both pure Ruby applications and Ruby on Rails projects, shedding light on their strengths and considerations for integration. 

Active Record

Ruby Usage

In Ruby, Active Record operates as a standalone component, independent of the Rails framework. It embodies the Active REcord pattern within Ruby, facilitating seamless interaction with databases using Ruby’s syntax. This standalone nature empowers Active Record to be utilized across diverse Ruby applications, enabling essential database operations like querying, creating, updating, and deleting records.

To use it, add activerecord gem into your Gemfile:

gem 'activerecord'

Establish connection to your DB:

require 'active_record'

ActiveRecord::Base.establish_connection(
  adapter: 'postgresql',
  host: 'host_name',
  database: 'db_name',
  username: 'username',
  password: 'password'
)

Now, define your User model using Active Record:

class User < ActiveRecord::Base
end

You can use this User model to interact with your users table:

# Create a new user
user = User.new(name: 'John', email: 'john@example.com')
user.save

# Find a user by name
user = User.find_by(name: 'John')



# Update a user's attributes
user.update(name: 'John Doe')

# Delete a user
user.destroy

Rails Usage

In Ruby on Rails, Active Record seamlessly integrates into the framework as its primary Object-Relational Mapping (ORM) layer. It acts as a vital bridge between the application and the database, abstracting the complexities of database interactions. Beyond this foundational role, Active Record enriches Rails applications with essential features including validations, associations, callbacks, and query interfaces. These functionalities greatly simplify database management within Rails, enhancing efficiency and developer productivity.

It follows a similar process to that in pure Ruby. You establish the database connection by defining it in the configuration file located at config/database.yml:

default: &default
  adapter: postgresql
  encoding: unicode
  pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
  host: host_name
  username: username
  password: password
  database: db_name

development:
  <<: *default

test:
  <<: *default

production:
  <<: *default

Then, simply define the User model as demonstrated in the Ruby example. Once defined, you can utilize this model within your controller as illustrated:

class UsersController < ApplicationController
  def create
    @user = User.new(user_params)
    if @user.save
      redirect_to @user, notice: 'User was successfully created.'
    else
      render :new
    end
  end

  private

  def user_params
    params.require(:user).permit(:name, :email)
  end
end

Sequel

Ruby Usage

When using Sequel in a standalone Ruby application (i.e., outside of Rails), you have complete autonomy over database interaction. Typically, you must explicitly establish the database connection within your Ruby code using Dequel’s API. Within this context, you have the freedom to define models and compose queries using Sequel’s DSL directly in your Ruby code, devoid of any conventions imposed by a web framework like Rails. 

Sequel grants you precise control over database interactions, empowering you to craft intricate queries and manage database-specific features directly within your Ruby application. Since you’re not leveraging Rails’ MVC architecture, you’re accountable for handling tasks such as request/response cycles, routing, and rendering views.
As previously mentioned, you’ll need to include the sequel gem into your Gemfile

gem 'sequel'

Then, establish DB connection and model:

require 'sequel'

# Establish a connection to database
DB = Sequel.connect adapter: "postgres",
                    host: ENV.delete("DATABASE_HOST") || "localhost",
                    database: ENV.delete("DATABASE_NAME"),
                    user: ENV.delete("DATABASE_USER"),
                    password: ENV.delete("DATABASE_PASSWORD"),
                    port: ENV.delete("DATABASE_PORT"),
                    max_connections: ENV.delete("DB_MAX_CONNECTIONS"),
                    sslmode: "disable"

# Define the User model
class User < Sequel::Model(DB[:users])
end

Now you can perform various operations using Sequel:

# Create a new user
user = User.create(name: 'John', email: 'john@example.com')

# Find a user by ID
user = User.find(id: 1)

# Update a user's attributes
user.update(name: 'John Doe')

# Find users whose name contains 'John'
johns = User.where(Sequel.like(:name, '%John%'))

# Iterate over the found users
johns.each do |john|
  puts "Name: #{john.name}, Email: #{john.email}"
end

# Delete a user
user.destroy

Rails

In a Ruby on Rails application, Sequel can serve as an alternative to Active Record, the framework’s default ORM. However, incorporating Sequel into a Rails application is less prevalent and more intricate compared to utilizing Active Record, which seamlessly integrates into Rails.

If you opt for Sequel in a Rails context, you’ll still need to establish a database connection. However, Rails’ configuration mechanisms might clash with Sequel’s settings, necessitating careful management of their integration to ensure compatibility with Rails’ conventions and architecture.

While employing Sequel in a Rails application provides the advantages of its robust DSL flexibility, it may entail additional effort to configure and maintain compared to using Active Record, which is preconfigured within Rails  you can also use Sequel as an alternative to ActiveRecord, Rails’ built-in ORM. However,  and tailored for the framework’s usage. 

Usage of Sequel in Rails is pretty much the same as it was in Active Record. First of all you need to add specific gem into your Gemfile:

To utilize Sequel in Rails, you’ll need to add the specific gem to your Gemfile as follows:

gem 'sequel-rails'

Next, configure the connection in config/database.yml:

development:
  adapter: postgresql
  encoding: unicode
  database: db_name
  username: username
  password: password
  host: host_name

Then, create the User model:

class User < Sequel::Model
  # specify table name explicitly if it's different from the default (pluralized class name)
  # set_dataset :users

  # you can define associations here as well
  # one_to_many :posts
end

Now you can use it as follows:

# Create a new user
user = User.create(name: 'John', email: 'john@example.com')

# Find a user by ID
user = User.find(id: 1)
# Update a user's attributes
user.update(name: 'John Doe')

# Find users whose name contains 'John'
johns = User.where(Sequel.like(:name, '%John%'))

# Iterate over the found users
johns.each do |john|
  puts "Name: #{john.name}, Email: #{john.email}"
end

# Delete a user
user.destroy

Comparing Active Record and Sequel: Main Characteristics

As we conclude our exploration of Active Record and Sequel, let’s summarize the main characteristics of these two popular ORM tools. 

In the following chart, you’ll find a side-by-side comparison of their performance, flexibility, ease of use, supported databases, extensibility, and community support.

While both ORM tools offer valuable features and advantages. By understanding these attributes, developers can make informed decisions about which ORM best suits their project needs.

Active Record vs. Sequel: Making the Right Choice for Your Project

Choosing between Active Record and Sequel depends on various factors such as project requirements, developer preference, and familiarity with each ORM. 

While Active Record offers simplicity and ease of use, Sequel provides more flexibility and control over database interactions.

By weighing the pros and cons, developers can confidently select the ORM that aligns best with their project goals. Whether it’s leveraging the conventions of Active Record or harnessing the explicitness of Sequel, both tools empower developers to build robust Ruby and Ruby on Rails applications efficiently.