Nivel inicial5 min de lectura · Publicado el

Crear modelos en Ruby on Rails

Crear modelos en Ruby on Rails: la clase Article con title, body y visit_count crea con db:migrate la tabla articles, en plural. Article → tabla articlesrubentejera.com Articletitlebodyvisit_countdb:migratearticles
El modelo, en singular (Article), es la plantilla de la ficha: dice qué campos tiene cada registro. bin/rails db:migrate crea la tabla en plural (articles), con una columna por campo.

Para crear un modelo en Ruby on Rails se usa el generador bin/rails generate model, que crea la clase del modelo y la migración de su tabla. Un modelo es la plantilla de una ficha: define qué datos guarda cada registro (título, cuerpo, visitas…) y Rails crea la tabla de la base de datos que los almacena.

Generar el modelo con rails generate model

El nombre del modelo va en singular y con la primera letra en mayúscula. Después pones los atributos que tendrá la tabla, con el formato nombre:tipo:

bin/rails generate model Article title:string body:text visit_count:integer

También vale la forma corta, bin/rails g model. El generador te dice qué ha creado:

      invoke  active_record
      create    db/migrate/20261111194723_create_articles.rb
      create    app/models/article.rb
      invoke    test_unit
      create      test/models/article_test.rb
      create      test/fixtures/articles.yml
Fichero Para qué sirve
app/models/article.rb El modelo
db/migrate/<fecha>_create_articles.rb La migración que crea la tabla
test/models/article_test.rb y test/fixtures/articles.yml El test y los datos de prueba

La migración generada queda así:

class CreateArticles < ActiveRecord::Migration[8.1]
  def change
    create_table :articles do |t|
      t.string :title
      t.text :body
      t.integer :visit_count

      t.timestamps
    end
  end
end

La tabla se llama como el modelo en plural: articles. t.timestamps añade las columnas created_at y updated_at.

Y el modelo, app/models/article.rb, nace casi vacío:

class Article < ApplicationRecord
end

No hace falta más: Active Record lee las columnas de la tabla y crea solo los métodos title, body y visit_count. Lo que añadas aquí después son reglas del negocio: validaciones, asociaciones o callbacks.

Un modelo que pertenece a otro, y un índice único

El generador entiende dos atajos más en los atributos: references, para apuntar a otro modelo, y :uniq, para que un valor no se repita:

bin/rails g model Comment article:references body:text email:string:uniq
class CreateComments < ActiveRecord::Migration[8.1]
  def change
    create_table :comments do |t|
      t.references :article, null: false, foreign_key: true
      t.text :body
      t.string :email

      t.timestamps
    end
    add_index :comments, :email, unique: true
  end
end

Con references, Rails crea la columna article_id, la clave ajena y, en el modelo, el belongs_to :article. Con :index en lugar de :uniq tendrías un índice que sí admite repetidos.

Tipos de columna

Los tipos que funcionan en cualquier base de datos son:

Tipo Para qué
:string Texto corto (un título, un email)
:text Texto largo (el cuerpo de un artículo)
:integer, :bigint Números enteros
:float, :decimal, :numeric Números con decimales (decimal para dinero)
:boolean Verdadero o falso
:date, :time, :datetime Fechas y horas
:binary, :blob Datos binarios
:primary_key Clave primaria

¿Dudas entre string y text? Lo tienes en diferencia entre text y string en Rails.

Si un modelo pertenece a otro, como un comentario a su artículo, la relación se declara con belongs_to y has_many: lo tienes en asociaciones en Ruby on Rails.

Ejecutar y deshacer la migración

Generar el modelo no toca la base de datos. Para crear la tabla:

bin/rails db:migrate
== 20261111194723 CreateArticles: migrating ===================================
-- create_table(:articles)
   -> 0.0020s
== 20261111194723 CreateArticles: migrated (0.0020s) ==========================

Si quieres volver atrás, haz un rollback. Rails sabe que lo contrario de create_table es drop_table:

bin/rails db:rollback
== 20261111194723 CreateArticles: reverting ===================================
-- drop_table(:articles)
   -> 0.0020s
== 20261111194723 CreateArticles: reverted (0.0032s) ==========================

Si te has equivocado en el nombre o en los campos y aún no has migrado, es más limpio deshacer todo lo generado de una vez:

bin/rails destroy model Article
      invoke  active_record
      remove    db/migrate/20261111194723_create_articles.rb
      remove    app/models/article.rb
      invoke    test_unit
      remove      test/models/article_test.rb
      remove      test/fixtures/articles.yml

Si ya la habías migrado, haz primero el rollback: destroy borra los ficheros, pero no toca la base de datos.

Añadir NOT NULL a una columna que ya existe

Para obligar a que una columna tenga siempre valor, crea una migración nueva con change_column_null:

bin/rails generate migration ChangeTitleNullOnArticles
class ChangeTitleNullOnArticles < ActiveRecord::Migration[8.1]
  def change
    change_column_null :articles, :title, false
  end
end

false significa «no admite nulos». Si la tabla ya tiene filas con title vacío, la migración fallará; pásale un cuarto argumento para rellenarlas, por ejemplo change_column_null :articles, :title, false, "Sin título".

Esta restricción protege la base de datos. Para dar un mensaje claro al usuario, combínala con una validación de Active Record. Cómo funcionan las migraciones por dentro, cuáles se pueden deshacer y qué hacer cuando no, está en migraciones en Ruby on Rails.

Compruébalo con un test

El generador ya te dejó test/models/article_test.rb. Úsalo para comprobar dos cosas: que el modelo guarda lo que le das y que la base de datos rechaza un artículo sin título, la restricción del apartado anterior.

require "test_helper"

class ArticleTest < ActiveSupport::TestCase
  test "guarda y recupera sus campos" do
    article = Article.create!(title: "Hola", body: "Un texto largo", visit_count: 0)

    assert_equal "Hola", Article.find(article.id).title
  end

  test "la base de datos rechaza un artículo sin título" do
    assert_raises(ActiveRecord::NotNullViolation) do
      Article.create!(title: nil)
    end
  end
end
bin/rails test test/models/article_test.rb
Running 2 tests in a single process (parallelization threshold is 50)
Run options: --seed 54223

# Running:

..

Finished in 0.021971s, 91.0271 runs/s, 91.0271 assertions/s.
2 runs, 2 assertions, 0 failures, 0 errors, 0 skips

El segundo test documenta una regla que, si no, solo estaría en una migración. Si alguien quita el NOT NULL sin darse cuenta, el test se pone en rojo.

Errores frecuentes

1. Poner el nombre en plural. Rails lo corrige, pero te avisa:

bin/rails g model Products name:string
[WARNING] The model name 'Products' was recognized as a plural, using the singular 'Product' instead. Override with --force-plural or setup custom inflection rules for this noun before running the generator.

Escribirlo en minúscula (product) no es un problema: el generador crea igualmente class Product.

2. Nombres en español con plurales raros. Rails forma el plural con las reglas del inglés. Con Articulo o Usuario no se nota (articulos, usuarios), pero con otros sí:

Profesor -> profesors
Ciudad -> ciudads

Si quieres nombres en español, enséñale el plural en config/initializers/inflections.rb antes de generar el modelo:

ActiveSupport::Inflector.inflections(:en) do |inflect|
  inflect.irregular "profesor", "profesores"
end
Profesor -> profesores

3. Equivocarte al escribir el tipo. El generador se detiene sin crear nada:

bin/rails g model Product name:strng
Could not generate field 'name' with unknown type 'strng'.

4. Usar un nombre que ya existe. Ni un modelo que ya tienes ni una clase de Ruby o de Rails:

bin/rails g model Class name:string
      invoke  active_record
The name 'Class' is either already used in your application or reserved by Ruby on Rails. Please choose an alternative or use --skip-collision-check or --force to skip this check and run this generator again.

5. Usar el modelo sin haber migrado. El modelo existe, pero su tabla todavía no. Según lo que hagas, el mensaje cambia. Con Article.new o Article.create:

Could not find table 'articles' (ActiveRecord::StatementInvalid)

Con una consulta, como Article.first o Article.all, en SQLite:

SQLite3::SQLException: no such table: articles: (ActiveRecord::StatementInvalid)

Lanza bin/rails db:migrate y vuelve a probar.

6. Un :uniq que rompe los tests. Los datos de prueba que genera Rails (test/fixtures/comments.yml) ponen el mismo valor, MyString, en todas las filas. Con un índice único, todos los tests fallan al cargarlos, incluso los que no tienen nada que ver con los comentarios:

ActiveRecord::RecordNotUnique: SQLite3::ConstraintException: UNIQUE constraint failed: comments.email

Cambia los valores repetidos del fichero por otros distintos ([email protected], [email protected]).

Cuándo no generar un modelo

  • Solo quieres una columna más. Si la tabla ya existe, no generes otro modelo: crea una migración con AddColumnaToTabla.
  • No hay nada que guardar. Una calculadora de precios o un objeto que da formato a una fecha no necesitan tabla. Una clase normal de Ruby en app/models (sin heredar de ApplicationRecord) basta, y se prueba igual de fácil.
  • Quieres también las pantallas. Si necesitas el modelo con su controlador, sus vistas y sus rutas, el generador es scaffold; lo tienes en resources en Rails.

Ejercicio de cinco minutos

  1. Genera un modelo Profesor con nombre:string sin tocar las inflexiones y mira cómo se llama la tabla en la migración. Deshazlo con bin/rails destroy model Profesor.
  2. Añade la regla irregular y genéralo otra vez: la tabla debe ser profesores.
  3. Escribe en su test que un profesor sin nombre no se guarda. Para que pase, deshaz la migración con bin/rails db:rollback, añade null: false a la columna y vuelve a migrar.

Fuentes

  • Guía de migraciones de Active Record (generador de modelos, references, :uniq e :index) y API de add_column y change_column_null (Rails 8.1.4.1).
  • API de ActiveSupport::Inflector::Inflections, para irregular.
  • Ejecutado el 11 de noviembre de 2026 con Ruby 3.4.12 y Rails 8.1.4.1 sobre SQLite (imagen oficial ruby:3.4 de Docker): todas las salidas del artículo, incluidos el generador con references y :uniq, destroy model, los plurales con y sin la regla irregular, los errores del generador, el modelo sin tabla, los fixtures con valores repetidos y el test. La captura de la terminal del artículo original (Rails 5.2) se ha sustituido por la salida en texto de Rails 8.1.