O que é CRUD (Create, Read, Update, Delete)?

CRUD é uma sigla para criar, ler, atualizar e excluir — as quatro operações básicas que todo armazenamento de dados persistente precisa suportar. Cunhada no Managing the Data-base Environment de James Martin, de 1983, segue sendo a sigla mais durável do trabalho de backend porque nomeia o piso: o que quer que o seu sistema faça, registros precisam nascer, ser encontrados, mudar e desaparecer.

Principais pontos

CRUD em quatro linguagens

-- CRUD como SQL: o mapeamento 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

E o mesmo ciclo como um SDK o expressa — a forma que a maior parte do código de aplicação realmente escreve:

// 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

Uma tabela para mapear tudo

O mapeamento de seis colunas que nenhuma referência isolada reúne:

Duas notas de rodapé da spec do HTTP que valem realmente saber: GET é seguro (não muda estado), PUT e DELETE são idempotentes (repita sem dano), POST não é nenhuma das duas coisas — e é por isso que a lógica de retry os trata de formas diferentes, e por isso PUT significa “substituir o todo” enquanto PATCH significa “modificar a parte”.

Onde o CRUD acontece

O diagrama é também o lembrete de segurança: todo verbo cruza a camada de API, que é onde permissões e validação pertencem — uma superfície CRUD sem controle de acesso por operação é um banco de dados público com etapas extras.

CRUD vs. REST

A conclusão prática: uma API REST é, com frequência, uma API CRUD vestindo HTTP — mas “aprovar fatura” pertence à sua API e não é um verbo CRUD, e CRUD existe tranquilamente sem HTTP à vista. Os termos cooperam; não competem.

Casos de uso comuns

• O app CRUD propriamente dito. Painéis administrativos, CMSs, CRMs, estoque, reservas — a maioria do software de negócio, com honra.
• Protótipos e MVPs. Os quatro verbos sobre um punhado de classes são a primeira versão da maioria dos produtos.
• APIs geradas automaticamente. Schema entra, superfície CRUD sai — o padrão moderno que transforma os quatro verbos em configuração em vez de código, coberto por inteiro no verbete de APIs geradas automaticamente.
• Ferramentas de admin e suporte. Grades visuais sobre a mesma superfície CRUD, permissões incluídas.
• O substrato sob todo o resto. Sistemas event-sourced e pesados em workflow ainda expõem CRUD em algum lugar — configurações, perfis, dados de referência.

Toda ação deveria ser CRUD? Matriz de decisão

A última linha é o design smell que vale memorizar: quando os nomes dos endpoints derivam para updateStatus, o domínio está pedindo verbos próprios.

Limitações e trade-offs

• Update destrói o histórico. A mutação no lugar é o ato definidor do CRUD e a sua perda definidora — qualquer coisa que precise de “como isso estava na terça” quer journaling ou eventos.
• Delete é uma política, não um verbo. Soft vs. hard delete troca auditabilidade por apagamento exigido em regimes de privacidade e complexidade de query; decida por classe, de propósito.
• Concorrência não vem precificada. Dois updates, o último escritor vence, a mudança do primeiro some em silêncio — campos de versão e saves condicionais são o antídoto padrão.
• List é o quinto verbo. Filtros, ordenação e paginação carregam a maior parte do tráfego real de leitura e a maior parte dos bugs de performance — a razão de CRUDL e BREAD existirem.
• APIs CRUD podem ficar anêmicas. Uma superfície que é só linhas-entram-linhas-saem empurra a lógica de negócio para os clientes; mantenha os workflows no servidor, ao lado dos dados.

CRUD no Back4app

O Back4app é uma plataforma open-source de Backend as a Service (BaaS) que combina banco de dados gerenciado, APIs REST e GraphQL geradas automaticamente, autenticação, armazenamento de arquivos e funções serverless com Cloud Code. Sua relação com este artigo é de subtração: defina uma classe e a matriz CRUD inteira acima passa a existir de uma vez — endpoints REST conforme a coluna HTTP, mutations GraphQL e os idiomas de SDK das abas de código, com permissões por classe controlando cada verbo e triggers beforeSave segurando a validação. Os quatro verbos deixam de ser o seu código e viram o seu vocabulário.