Diferencia entre text y string en Ruby on Rails
La diferencia es, sobre todo, cuánto texto cabe y cómo lo guarda la base de datos. En MySQL, es la diferencia entre VARCHAR y TEXT. Piensa en un campo de un formulario en papel: el «Nombre» es una línea corta; «Observaciones», un recuadro grande. :string es la línea; :text, el recuadro.
En una migración
class CreateArticulos < ActiveRecord::Migration[8.1]
def change
create_table :articulos do |t|
t.string :titulo # texto corto
t.text :cuerpo # texto largo
t.timestamps
end
end
end
Más sobre migraciones en Migraciones en Ruby on Rails.
Lo que ves en MySQL
Con esa migración aplicada en MySQL 9.7, DESCRIBE enseña los dos tipos reales:
+------------+--------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+------------+--------------+------+-----+---------+----------------+
| id | bigint | NO | PRI | NULL | auto_increment |
| titulo | varchar(255) | YES | | NULL | |
| cuerpo | text | YES | | NULL | |
| created_at | datetime(6) | NO | | NULL | |
| updated_at | datetime(6) | NO | | NULL | |
+------------+--------------+------+-----+---------+----------------+
¿Cómo se mira eso desde la terminal? Lo tienes en conexión a MySQL desde consola.
¿Y en Ruby? Los dos son un String
La diferencia solo existe en la base de datos. En tu código, los dos atributos son objetos String de Ruby, con los mismos métodos:
articulo = Articulo.new(titulo: "Hola", cuerpo: "Texto largo")
articulo.titulo.class # => String
articulo.cuerpo.class # => String
Así que si buscabas cómo trabajar con cadenas en Ruby (upcase, split, include?…), da igual cuál de los dos tipos tenga la columna.
Qué crea cada uno según la base de datos: VARCHAR o TEXT
| Base de datos | :string |
:text |
|---|---|---|
| MySQL / MariaDB | VARCHAR(255): hasta 255 caracteres |
TEXT: hasta 65.535 bytes (unos 64 KB) |
| PostgreSQL | character varying sin límite |
text sin límite práctico |
| SQLite | varchar, sin límite real |
text |
Un detalle de MySQL: en VARCHAR(255) el límite se cuenta en caracteres, pero en TEXT se cuenta en bytes. Con utf8mb4, la codificación que usa Rails por defecto, una letra como la «ñ» ocupa dos bytes, así que en un TEXT caben unas 32.000 «ñ», no 65.535.
En PostgreSQL, character varying sin límite y text se comportan casi igual. Aun así, conviene elegir bien: el tipo comunica la intención y decide el campo que generan los formularios de Rails.
Cambiar el límite
Con limit: fijas el máximo de un :string:
t.string :codigo_postal, limit: 5
En MySQL, limit: en un :text elige el tamaño del tipo:
limit: en un :text (MySQL) |
Tipo que crea | Capacidad |
|---|---|---|
| hasta 255 | TINYTEXT |
255 bytes |
| sin límite o hasta 65.535 | TEXT |
64 KB |
| hasta 16.777.215 | MEDIUMTEXT |
16 MB |
| hasta 4.294.967.295 | LONGTEXT |
4 GB |
En MySQL también puedes indicarlo con size:, por ejemplo t.text :cuerpo, size: :medium. Con esta migración:
add_column :articulos, :codigo_postal, :string, limit: 5
add_column :articulos, :resumen, :text, limit: 255
add_column :articulos, :libro, :text, size: :medium
add_column :articulos, :enciclopedia, :text, limit: 4_294_967_295
MySQL crea estos tipos:
| codigo_postal | varchar(5) | YES | | NULL | |
| resumen | tinytext | YES | | NULL | |
| libro | mediumtext | YES | | NULL | |
| enciclopedia | longtext | YES | | NULL | |
Cuándo usar cada uno
:string
- Una sola línea
- Nombres, emails, títulos, códigos, URLs cortas
- Formulario:
text_field
:text
- Varias líneas o longitud imprevisible
- Descripciones, comentarios, contenido de artículos
- Formulario:
textarea
Compruébalo con un test
La validación de la nota anterior es una regla, y una regla merece un test. Con el modelo así:
class Articulo < ApplicationRecord
validates :titulo, length: { maximum: 255 }
end
Este test comprueba el límite justo y el primer valor que se pasa:
require "test_helper"
class ArticuloTest < ActiveSupport::TestCase
test "un título de 255 caracteres es válido" do
assert Articulo.new(titulo: "a" * 255).valid?
end
test "un título de 256 caracteres da un error claro, no un fallo de MySQL" do
articulo = Articulo.new(titulo: "a" * 256)
refute articulo.valid?
assert_includes articulo.errors[:titulo], "is too long (maximum is 255 characters)"
end
end
bin/rails test test/models/articulo_test.rb
2 runs, 4 assertions, 0 failures, 0 errors, 0 skips
Si alguien quita o cambia la validación, este test avisa antes de que el usuario vea el error de MySQL.
Errores frecuentes
1. Guardar más de 255 caracteres en un :string en MySQL. Sin validación, MySQL rechaza el valor y Rails lanza una excepción:
Articulo.create!(titulo: "a" * 256)
ActiveRecord::ValueTooLong: Mysql2::Error: Data too long for column 'titulo' at row 1
Con "a" * 255 se guarda sin problema. Lo mismo pasa con un :text que supera sus 65.535 bytes. En SQLite, en cambio, un :string de 1.000 caracteres se guarda sin rechistar, así que el error puede no aparecer en desarrollo y sí en producción, si allí usas MySQL.
2. Poner un índice a una columna :text en MySQL. Para buscar rápido por una columna se le añade un índice, pero en MySQL un TEXT no se puede indexar entero:
add_index :articulos, :cuerpo
Mysql2::Error: BLOB/TEXT column 'cuerpo' used in key specification without a key length
O le dices cuántos caracteres del principio indexar (add_index :articulos, :cuerpo, length: 100), o, si es un dato corto que vas a buscar, como un email, la columna debería ser :string.
3. Cambiar de :string a :text cuando ya hay datos. Se hace con una migración nueva y change_column, que Rails no sabe deshacer solo. Cómo escribirla para que tenga marcha atrás está en migraciones en Ruby on Rails.
Cuándo no usar cada uno
- No uses
:textpara datos cortos que vayas a buscar, ordenar o hacer únicos (emails, códigos, slugs): en MySQL complica los índices y no comunica la intención. - No uses
:stringpara lo que escribe el usuario sin límite claro (comentarios, descripciones): en MySQL, a partir de 256 caracteres el valor se rechaza con una excepción (porque Rails activa el modo estricto de MySQL,STRICT_ALL_TABLES, en cada conexión). - No subas a
MEDIUMTEXToLONGTEXTpor si acaso. Si el contenido es un fichero (un PDF, una imagen), no va en la tabla: va como adjunto, con Active Storage.
Ejercicio de cinco minutos
- Crea un modelo con
nombre:stringybiografia:text, y escribe un test que espere un error de validación con un nombre de 256 caracteres. Comprueba que falla. - Haz que pase con
validates :nombre, length: { maximum: 255 }. - Si tienes MySQL a mano, quita la validación y prueba a guardar el mismo nombre desde la consola de Rails: lee el error que da la base de datos.
Fuentes
Comprobado el 7 de noviembre de 2026 en Rails 8.1.4.1 (última versión publicada) y revisado el 11 de noviembre de 2026:
- Tipos nativos en el código fuente de los adaptadores: MySQL (
varcharconlimit: 255), PostgreSQL y SQLite. - Tamaños de
TEXTsegúnlimit:en mysql/schema_statements.rb. - Campo de formulario por tipo en el generador de Rails.
- Guía de migraciones de Rails y, en el manual de MySQL 9.7, los requisitos de almacenamiento de las cadenas (
VARCHARen caracteres,TEXTen bytes, hasta 4 bytes por carácter enutf8mb4) y los índices de prefijo en columnasTEXT.
Ejecutado el 11 de noviembre de 2026 con Ruby 3.4.12, Rails 8.1.4.1 y la gema mysql2 0.5.7 contra MySQL 9.7.4 (imágenes oficiales ruby:3.4 y mysql:lts de Docker): la migración, los tipos que crean limit: y size:, la clase String de los dos atributos, ValueTooLong con 256 caracteres y con un TEXT de 80.000 bytes, el error del índice y el índice con length: 100, y el test. Lo de SQLite, con Rails 8.1.4.1 y SQLite (sqlite3 2.10.2). PostgreSQL y MariaDB no se han ejecutado: sus tipos se han comprobado en el código fuente de Rails.