Cómo usar el ORM de Ruby on Rails

Publicado 01/10/2022 Actualizado 27/11/2025

Por mcherrera

6 min de lectura

El ORM de Ruby on Rails se llama Active Record, y es una de las partes más poderosas del framework. Gracias a él puedes trabajar con bases de datos usando objetos Ruby, sin escribir SQL manual (aunque puedes hacerlo cuando lo necesites).

En este post construiremos un ejemplo simple usando el ORM, donde gestionaremos libros, autores y categorías. Veremos cómo crear el proyecto, configurar la base de datos, generar modelos, migrar tablas y realizar consultas típicas.

¿Qué es Active Record?

Active Record es la capa del MVC encargada de gestionar los datos. Cada tabla de la base de datos se representa como una clase Ruby, y cada fila como un objeto.

Ejemplo:
La tabla users corresponde al modelo:

  
class User < ApplicationRecord
end

Setup

Para comenzar con el setup de Rails, lo primero es preparar el entorno y crear un nuevo proyecto.

1. Abrir una línea de comandos (Terminal)
Presiona la combinación Cmd + Space para abrir el Spotlight, luego escribe “Terminal” y presiona Enter.
2. Navegar a la ubicación deseada
Una vez que tengas la terminal abierta, usa el comando cd para cambiar a la ubicación donde trabajarás tu proyecto. Por ejemplo, si deseas ir a la carpeta Documentos:
1 cd ~/Documents/
3. Crear el proyecto
Usando el comando rails seguido del nombre para el proyecto y le indicamos que lo configure para usar Postgres. Por ejemplo:
1 rails new bookstore -d postgressql
Puedes usar SQLite si quieres, solo cambia la opción -d sqlite3.
4. Crear la base de datos
Con el comando db le podemos decir que proceda a crear la base de datos:
1 rails db:create
Cuando instalas PostgreSQL con Homebrew, se crea automáticamente un rol en Postgres con el mismo nombre que tu usuario de macOS. Por eso, al ejecutar rails db:create sin especificar usuario ni contraseña, Rails usa ese rol por defecto y la base de datos se crea sin problemas.
1. Abrir una línea de comandos o símbolo de sistema (CMD)
Presiona la combinación Win + R para abrir la ventana de “Ejecutar” y escribe “cmd”.
2. Navegar a la ubicación deseada
Con el comando cd cambiamos a la ubicación donde trabajarás tu proyecto. Por ejemplo:
1 cd %UserProfile%\Documents
3. Crear carpeta con el nombre del proyecto y entrar en ella
Usando el comando mkdir se crea la carpeta y luego con cd accedes a la misma:
1 mkdir bookstore && cd bookstore

Comprobamos la creación de la base de datos:

Crear los modelos

En nuestro proyecto bookstore crearemos tres modelos principales:

Book: representa el libro.
Author: representa un autor.
Category: representa una categoría literaria.

rails generate model Author name:string bio:text
rails generate model Category name:string
rails generate model Book title:string price:decimal author:references category:references

Rails generará:

Los modelos dentro de app/models/
Las migraciones dentro de db/migrate/

Modelos

Migraciones

Aplicar las migraciones

Usando el comando rails db ejecutas la migración:

rails db:migrate

Relacionando los modelos con Active Record

Rails ya conoce las relaciones gracias a references, pero las debemos declarar en los modelos.

`app/models/author.rb`

  
class Author < ApplicationRecord
  has_many :books
end

`app/models/category.rb`

  
class Category < ApplicationRecord
  has_many :books
end

`app/models/book.rb`

  
class Book < ApplicationRecord
  belongs_to :author
  belongs_to :category
end

Con esto Active Record genera métodos automáticos como:

author.books
category.books
book.author
book.category

🧪 5. Probando Active Record en la consola (Rails Console)

Podemos interactuar con nuestra base de datos desde:

rails console

Crear registros

  
a = Author.create(name: "Gabriel García Márquez")
c = Category.create(name: "Realismo Mágico")

Book.create(
  title: "Cien años de soledad",
  price: 19.99,
  author: a,
  category: c
)

Consultar registros

  
Book.first
Book.where(price: 10..30)
Author.find_by(name: "Gabriel García Márquez").books

Actualizar

  
book = Book.first
book.update(price: 21.99)

Eliminar

  
Book.last.destroy

🎯 6. Controladores y rutas (rápido)

Si quieres exponer libros en una API o vistas:

rails generate controller Books index show

En config/routes.rb:

resources :books

En app/controllers/books_controller.rb:

  
class BooksController < ApplicationController
  def index
    @books = Book.includes(:author, :category)
  end

  def show
    @book = Book.find(params[:id])
  end
end

Rails ya te da las rutas REST:

/books
/books/:id

🧵 7. Conclusión

Rails hace que trabajar con una base de datos en el proyecto bookstore sea totalmente natural gracias a Active Record. Cada modelo se convierte en una clase Ruby completamente integrada con la base de datos, y las migraciones nos permiten evolucionar la estructura sin dolores de cabeza.

En este pequeño ejemplo ya logramos:

Crear el proyecto bookstore
Configurar la base de datos
Definir modelos y relaciones
Migrar tablas
Hacer consultas con Active Record
Preparar controladores y rutas básicas

Si sigues expandiendo este proyecto puedes agregar usuarios, carritos, compras y mucho más — Rails está hecho para escalar contigo.

Si quieres, puedo generar:

✅ El mismo artículo pero en formato Markdown ✅ Una versión más larga o más resumida ✅ Agregar API completa con controladores y serializers ✅ Agregar autenticación (Devise) ✅ Agregar vistas con Rails Turbo / Hotwire

Solo dime qué quieres añadir.

Esto crea:

un archivo en app/models/user.rb
una tabla users con las columnas indicadas

🔹 Crear registros

  
user = User.create(name: "Marco", email: "marco@example.com", age: 25)

o de forma más controlada:

  
user = User.new(name: "Marco")
user.save

🔹 Consultar datos

Obtener todos los registros

  
User.all

Filtrar registros

  
User.where(age: 25)

Buscar un registro por ID

  
User.find(1)

Ordenar

  
User.order(age: :desc)

🔹 Actualizar un registro

  
user = User.find(1)
user.update(age: 30)

🔹 Eliminar un registro

  
user = User.find(1)
user.destroy

🔹 Consultas más avanzadas

Seleccionar columnas específicas

  
User.select(:name, :email)

Condiciones con operadores

  
User.where("age > ?", 18)

Combinando condiciones

  
User.where(age: 18..30).order(:age)

🔹 Asociaciones (Relaciones)

Rails facilita relaciones como:

1) `has_many` y `belongs_to`

  
class User < ApplicationRecord
  has_many :posts
end

class Post < ApplicationRecord
  belongs_to :user
end

Uso:

  
user = User.first
user.posts   # todos los posts del usuario

2) `has_many :through`

  
class Doctor < ApplicationRecord
  has_many :appointments
  has_many :patients, through: :appointments
end

3) `has_one`, `has_and_belongs_to_many`, etc.

Rails tiene patrones para cubrir todas las relaciones comunes.

🔹 Validaciones

Active Record permite validar datos antes de guardarlos:

  
class User < ApplicationRecord
  validates :email, presence: true, uniqueness: true
end

Si falla:

  
user = User.new
user.save #=> false
user.errors.full_messages

🔹 Callbacks

Ejecutan lógica automática:

  
class User < ApplicationRecord
  before_save :normalize_name

  def normalize_name
    self.name = name.capitalize
  end
end

🔹 ¿Cuándo usar SQL directo?

Cuando necesitas algo muy optimizado:

  
User.find_by_sql("SELECT * FROM users WHERE age > 20")

Pero la mayoría del tiempo Active Record simplifica el trabajo.

Active Record convierte la base de datos en objetos Ruby fáciles de manipular, permitiendo crear, leer, actualizar y eliminar datos sin escribir SQL.

Es uno de los mayores beneficios de Rails: velocidad, organización y productividad.

Rails, ORM, Backend

Esta entrada está licenciada bajo CC BY 4.0 por el autor.