¿Qué es CRUD (crear, leer, actualizar, eliminar)?

CRUD es la abreviatura de crear, leer, actualizar y eliminar: las cuatro operaciones básicas que todo almacén de datos persistente debe soportar. Acuñado en Managing the Data-base Environment de James Martin (1983), sigue siendo el acrónimo más durable del trabajo de backend porque nombra el piso: haga lo que haga tu sistema además, los registros deben nacer, encontrarse, cambiar y desaparecer.

Puntos clave

CRUD en cuatro lenguajes

-- CRUD como SQL: el mapeo original
INSERT INTO tasks (title) VALUES ('Write the launch post');   -- C
SELECT * FROM tasks WHERE done = false;                       -- R
UPDATE tasks SET done = true WHERE id = 42;                   -- U
DELETE FROM tasks WHERE id = 42;                              -- D

Y el mismo ciclo tal como lo expresa un SDK — la forma que el código de aplicación escribe en realidad:

// JavaScript / Node.js — Back4app JS SDK
// The full CRUD cycle on one object
const task = new Parse.Object('Task');
task.set('title', 'Write the launch post');            // C — create
await task.save();

const fetched = await new Parse.Query('Task')
  .equalTo('done', false).first();                     // R — read

fetched.set('done', true);                             // U — update
await fetched.save();

await fetched.destroy();                               // D — delete

// Flutter / Dart — Back4app Flutter SDK
// The full CRUD cycle on one object
final task = ParseObject('Task')..set('title', 'Write the launch post');
await task.save();                                     // C — create

final query = QueryBuilder<ParseObject>(ParseObject('Task'))
  ..whereEqualTo('done', false);
final fetched = (await query.query()).results!.first;  // R — read

fetched.set('done', true);
await fetched.save();                                  // U — update

await fetched.delete();                                // D — delete

// iOS / Swift — Back4app Swift SDK
// The full CRUD cycle on one object
var task = Task()
task.title = "Write the launch post"
let saved = try await task.save()                      // C — create

let fetched = try await Task.query("done" == false)
  .first()                                             // R — read

var updated = fetched
updated.done = true
_ = try await updated.save()                           // U — update

try await updated.delete()                             // D — delete

// Android / Kotlin — Back4app Android SDK
// The full CRUD cycle on one object
val task = ParseObject("Task").apply {
  put("title", "Write the launch post")
}
task.save()                                            // C — create

val fetched = ParseQuery.getQuery<ParseObject>("Task")
  .whereEqualTo("done", false).first                   // R — read

fetched.put("done", true)
fetched.save()                                         // U — update

fetched.delete()                                       // D — delete

Una tabla para mapearlos todos

El mapeo de seis columnas que ninguna referencia individual ensambla:

Dos notas al pie de la spec de HTTP que vale la pena saber de verdad: GET es seguro (no cambia estado), PUT y DELETE son idempotentes (se repiten sin daño), POST no es ninguna de las dos — por eso la lógica de reintentos los trata distinto, y por eso PUT significa “reemplazar todo” mientras PATCH significa “modificar una parte”.

Dónde ocurre CRUD

El diagrama es también el recordatorio de seguridad: cada verbo cruza la capa de API, que es donde pertenecen los permisos y la validación — una superficie CRUD sin control de acceso por operación es una base de datos pública con pasos extra.

CRUD vs. REST

La conclusión práctica: una API REST es con frecuencia una API CRUD vestida de HTTP — pero “aprobar factura” pertenece a tu API y no es un verbo CRUD, y CRUD existe feliz sin HTTP a la vista. Los términos cooperan; no compiten.

Casos de uso comunes

• La app CRUD propiamente dicha. Paneles de administración, CMSs, CRMs, inventario, reservas — la mayoría del software de negocio, con honra.
• Prototipos y MVPs. Los cuatro verbos sobre un puñado de clases son la primera versión de la mayoría de los productos.
• APIs autogeneradas. Entra el esquema, sale la superficie CRUD — el default moderno que convierte los cuatro verbos en configuración en vez de código, cubierto a fondo en la entrada de APIs autogeneradas.
• Tooling de administración y soporte. Grillas visuales sobre la misma superficie CRUD, permisos incluidos.
• El sustrato bajo todo lo demás. Los sistemas con event sourcing o pesados en workflows igual exponen CRUD en alguna parte — configuraciones, perfiles, datos de referencia.

¿Debería toda acción ser CRUD? Matriz de decisión

La última fila es el olor de diseño que vale memorizar: cuando los nombres de endpoints derivan hacia updateStatus, el dominio está pidiendo verbos propios.

Limitaciones y trade-offs

• Actualizar destruye la historia. La mutación en el lugar es el acto que define a CRUD y su pérdida definitoria — cualquier cosa que necesite “cómo se veía esto el martes” quiere journaling o eventos.
• Eliminar es una política, no un verbo. Soft vs. hard delete intercambia auditabilidad contra el borrado de los regímenes de privacidad y la complejidad de las consultas; decide por clase, a propósito.
• La concurrencia no tiene precio puesto. Dos updates, gana el último escritor, el cambio del primero se pierde en silencio — campos de versión y saves condicionales son el antídoto estándar.
• List es el quinto verbo. El filtrado, el ordenamiento y la paginación cargan la mayor parte del tráfico real de lectura y la mayoría de los bugs de rendimiento — la razón de que existan CRUDL y BREAD.
• Las APIs CRUD pueden volverse anémicas. Una superficie que solo es filas-que-entran-filas-que-salen empuja la lógica de negocio a los clientes; mantén los workflows del lado del servidor, junto a los datos.

Operaciones CRUD en Back4app

Back4app es una plataforma open-source de Backend as a Service (BaaS) que combina base de datos gestionada, APIs REST y GraphQL generadas automáticamente, autenticación, almacenamiento de archivos y funciones serverless con Cloud Code. Su relación con este artículo es la sustracción: define una clase y toda la matriz CRUD de arriba existe de una vez — endpoints REST según la columna HTTP, mutations de GraphQL y los idiomas de SDK de las pestañas de código, con permisos a nivel de clase custodiando cada verbo y triggers beforeSave sosteniendo la validación. Los cuatro verbos dejan de ser tu código y se convierten en tu vocabulario.