In this post, I am going to take a look at Ecto, a data mapping and database query library designed to provide seamless integration between Elixir code and database operations and compare it to Ruby on Rail's ActiveRecord.

Ecto and ActiveRecord are both popular data access libraries in their communities, but they have different design philosophies and approaches to handling database operations.

Design Pattern

Ecto follows the Repository design pattern, where all data mapping and query operations are centralized through a repository.

It is best to take a look at a simple example to illustrate this:

user = Repo.get_by(MyApp.User, name: "Han")
changes = Ecto.Changeset.change(user, name: "Sam")
Repo.update!(changes)

As you can see, in Ecto data operations are orchestrated through the Repo Module which provides a structured and centralized way to interact with the database. This separation of concerns between data access and domain logic contributes to a distinct programming paradigm in Ecto compared to ActiveRecord, which follows the Active Record design pattern, where data access and persistence logic are directly tied to the model classes.

In other words, all operations in Active Record are directly performed on the model class itself. This includes queries, updates, and other database actions. For example, fetching and updating a User record in ActiveRecord would be done as follows:

user = User.find_by(name: "Han")
user.update!(name: "Sam")

Explicitness of Operations

Ecto emphasizes explicitness in database operations, making queries and data manipulation actions clear and easy to reason about in the code.

In contrast, ActiveRecord often relies on "magic" methods and conventions to handle database operations automatically. While this can simplify development in some cases, it may introduce complexity and make it harder to understand the underlying database interactions.

Let's explore another code example that highlights this difference between the two. Here's how you would insert a new user record into the database using Ecto:

# User Schema Definition in Elixir (Ecto):
defmodule User do
  use Ecto.Schema
  import Ecto.Changeset

  schema "users" do
    field :name, :string
    field :age, :string

    timestamps()
  end

  def changeset(user, attrs) do
    user
    |> cast(attrs, [:name, :age])
    |> validate_required([:name, :age])
  end
end

# Creating a new user record using Ecto
changeset = User.changeset(%User{}, %{name: "Alice", age: 30})

case Repo.insert(changeset) do
  {:ok, user} ->
    IO.puts("User inserted: #{inspect(user)}")
  {:error, changeset} ->
    IO.puts("Error inserting user: #{inspect(changeset.errors)}")
end

In this Elixir code snippet, the process of creating a new user record involves explicitly creating a changeset, validating the data, and then inserting the record into the database using Repo.insert(). The code clearly outlines the steps involved in inserting a new user record.

Let's see how you would insert a new user record into the database using ActiveRecord:

# Example of User model defined in ActiveRecord
class User < ApplicationRecord
  validates :name, presence: true
  validates :age, presence: true
end

# Creating a new user record using ActiveRecord
user = User.new(name: "Alice", age: 30)
if user.save
  puts "User inserted: #{user.inspect}"
else
  puts "Error inserting user: #{user.errors.full_messages}"
end

In Ruby, the process of creating and saving a new user record is simplified using ActiveRecord's 'magic' methods. The User.new method initializes a new user object, and user.save handles the insertion into the database, abstracting away some of the explicit steps involved.

The above example also highlights another very important key difference between Ecto and Active Record's design philosophy.

Functional vs Object Oriented Paradigm

Ecto leverages Elixir's functional programming capabilities, with changesets highlighting the functional approach to data manipulation. As you have already seen changesets are built through a series of function calls, ensuring data validity before persistence.

To further demonstrate the functional step-by-step approach of Ecto changesets, we can enhance the changeset/2 function above to include additional steps such as data transformation and custom validations:

# User Schema Definition in Elixir (Ecto)
defmodule User do
  use Ecto.Schema

  schema "users" do
    field :name, :string
    field :age, :integer

    timestamps()
  end

  def changeset(user, attrs) do
    user
    |> cast(attrs, [:name, :age])
    |> validate_required([:name, :age])
    |> transform_age_to_integer
    |> validate_age_range
  end

  defp transform_age_to_integer(changeset) do
    case get_field(changeset, :age) do
      nil -> changeset
      age -> put_change(changeset, :age, String.to_integer(age))
    end
  end

  defp validate_age_range(changeset) do
    case get_field(changeset, :age) do
      nil -> changeset
      age when age < 18 or age > 100 ->
        add_error(changeset, :age, "Age must be between 18 and 100")
      _ -> changeset
    end
  end
end

ActiveRecord, on the other hand, is more object-oriented, treating database records as objects with built-in methods for validating data.

To mirror the functionality demonstrated in the Ecto example above, we can enhance the User model in ActiveRecord to include custom validations for the age range and data transformation for the age attribute.

# User Model Definition in Ruby (ActiveRecord)
class User < ApplicationRecord
  validates :name, presence: true
  validates :age, presence: true
  validate :age_range_validation

  before_validation :transform_age_to_integer

  private

  def transform_age_to_integer
    self.age = age.to_i if age.present?
  end

  def age_range_validation
    if age.present? && (age < 18 || age > 100)
      errors.add(:age, "Age must be between 18 and 100")
    end
  end
end

Querying the Database

Ecto provides a query DSL (Domain-Specific Language) that closely resembles SQL but is integrated into Elixir. This DSL allows developers to write complex queries with advanced filters, joins, and ordering in a way that feels natural within the Elixir ecosystem.

# Ecto Query Example in Elixir (Ecto)
query = from u in User,
        where: u.age > 18,
        select: u.name
Repo.all(query)

# Raw SQL Equivalent to Ecto Query above
SELECT name
FROM users
WHERE age > 18;

In the example above, the from macro is used to construct a query that selects the names of users with an age greater than 18. As you can see, the syntax of Ecto queries closely resembles raw SQL statements, making it intuitive for developers familiar with writing SQL queries.

Here is the same database operation written in Ruby using Active Record:

# ActiveRecord Query Example in Ruby (ActiveRecord)
User.where("age > ?", 18).pluck(:name)

In the Ruby example above, the where method is used to filter users based on age greater than 18, and the pluck method is used to select only the names of the filtered users. ActiveRecord queries in Ruby use a different syntax compared to raw SQL statements, providing a more abstract and object-oriented approach to querying the database.

This was a short post on Ecto, the popular data mapping and database query library from the Elixir community comparing it to Ruby's equivalent Active Record.
In a future post, I am going to dig much deeper into the topic of Ecto.

Thank you for reading.