---
term: 'Operações CRUD'
seoTitle: 'O que é CRUD? Operações Criar, Ler, Atualizar e Excluir'
headline: 'O que é CRUD (Create, Read, Update, Delete)?'
slug: operacoes-crud
category: database
shortDefinition: 'CRUD é uma sigla para criar, ler, atualizar e excluir — as quatro operações básicas que todo armazenamento de dados persistente precisa suportar.'
relatedTerms:
  - auto-generated-database-apis
  - rest-api
  - database-queries
  - backend-sdk
  - graphql-vs-rest
contrastsWith:
  - graphql-vs-rest
faq:
  - question: 'O que significa CRUD?'
    answer: 'Create, Read, Update, Delete — criar, ler, atualizar e excluir: as quatro operações fundamentais do armazenamento persistente e o mínimo que qualquer aplicação com dados precisa suportar. A sigla foi popularizada por James Martin no livro Managing the Data-base Environment, de 1983, com semântica relacionada formalizada por Haim Kilov em 1990 — um dos termos mais antigos ainda usados todo dia no vocabulário de backend.'
  - question: 'Como o CRUD mapeia para SQL e para HTTP?'
    answer: 'Dois mapeamentos limpos que todo dev memoriza uma vez: em SQL, criar é INSERT, ler é SELECT, atualizar é UPDATE e excluir é DELETE. Sobre HTTP, criar é POST, ler é GET, atualizar é PUT para substituição completa ou PATCH para mudanças parciais, e excluir é DELETE — com 201, 200 e 204 como os status codes do caminho feliz, respectivamente.'
  - question: 'CRUD é a mesma coisa que REST?'
    answer: 'Não — eles respondem a perguntas diferentes. CRUD nomeia o que você faz com os dados; REST é um estilo arquitetural para como clientes interagem com recursos sobre HTTP, com restrições como statelessness e interface uniforme. Endpoints REST costumam mapear direto para CRUD, mas REST pode expor ações não-CRUD, e CRUD vive feliz fora do HTTP — em sessões SQL, SDKs e filas.'
  - question: 'Qual é a diferença entre PUT e PATCH?'
    answer: 'O escopo da atualização. PUT substitui o recurso inteiro pela representação que você envia — idempotente por definição, já que enviá-la duas vezes produz o mesmo estado. PATCH aplica uma modificação parcial — só os campos enviados mudam. A maior parte do tráfego real de "update" tem formato de PATCH, e é por isso que os métodos save() dos SDKs enviam apenas os campos alterados.'
  - question: 'O que é um app CRUD?'
    answer: 'Uma aplicação cujo ciclo central é criar, visualizar, editar e excluir registros — painéis administrativos, CMSs, CRMs, sistemas de estoque e de reservas. É um termo levemente depreciativo que não deveria ser: a maioria do software de negócio é CRUD no fundo, e é exatamente por isso que plataformas que geram a camada CRUD automaticamente removem tanto trabalho.'
  - question: 'O que é soft delete?'
    answer: 'Marcar um registro como excluído — uma flag ou um timestamp — em vez de removê-lo. Preserva histórico de auditoria, integridade referencial e o desfazer, ao preço de filtrar toda query e complicar constraints de unicidade. A contraparte, o hard delete, é a remoção real, que regimes de privacidade como os pedidos de apagamento da GDPR podem genuinamente exigir. A maioria dos sistemas precisa de uma política deliberada por classe, não de um padrão.'
  - question: 'Quando o CRUD não é suficiente?'
    answer: 'Quando o domínio é sobre eventos e histórico, não sobre o estado atual. Atualizar no lugar destrói o passado — event sourcing mantém um log append-only e deriva o estado dele; CQRS separa por completo os modelos de leitura e escrita. E ações de negócio como "aprovar fatura" ou "fechar pedido" são workflows, não edições de linha — modelá-las como updates crus esconde o domínio. CRUD é o piso do acesso a dados, não o teto.'
  - question: 'O que são variantes de CRUD como CRUDL e BREAD?'
    answer: 'Extensões e regrafias da mesma ideia: CRUDL adiciona List como operação distinta do Read de registro único; BREAD soletra Browse, Read, Edit, Add, Delete. Elas reconhecem a verdade prática de que listar coleções — com filtros e paginação — é uma operação própria, com decisões de design próprias, e não apenas "read, no plural".'
codeLanguages: [javascript, dart, swift, kotlin]
externalAuthorities:
  - name: 'Create, read, update and delete (Wikipedia)'
    url: 'https://en.wikipedia.org/wiki/Create,_read,_update_and_delete'
  - name: 'CRUD — MDN Web Docs Glossary'
    url: 'https://developer.mozilla.org/en-US/docs/Glossary/CRUD'
  - name: 'RFC 9110 — HTTP Semantics'
    url: 'https://www.rfc-editor.org/rfc/rfc9110'
  - name: 'REST API guide'
    url: 'https://docs.parseplatform.org/rest/guide/'
cta:
  title: 'A camada CRUD, já escrita'
  text: 'Defina uma classe no Back4app e toda a sua superfície CRUD existe na hora: endpoints REST, mutations GraphQL e métodos de SDK para cada plataforma — com permissões, hooks de validação e paginação embutidos. Os quatro verbos deixam de ser o seu código.'
  linkText: 'Comece grátis'
  linkUrl: 'https://www.back4app.com/signup'
author: 'Back4app Engineering'
publishedDate: '2026-08-20'
translationKey: crud-operations
---

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

| Pergunta | Resposta |
| --- | --- |
| Os quatro verbos | Create · Read · Update · Delete — o mínimo da persistência |
| Em SQL | INSERT · SELECT · UPDATE · DELETE |
| Sobre HTTP | POST · GET · PUT/PATCH · DELETE |
| vs. REST | CRUD é o que você faz com os dados; REST é como clientes chegam aos recursos |
| O movimento moderno | A camada CRUD é gerada, não escrita |

## CRUD em quatro linguagens

```sql
-- 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:**

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

**Swift:**

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

**Kotlin:**

```kotlin
// 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:

| Operação | SQL | Verbo HTTP | Status | Banco de documentos | Idioma de SDK/ORM |
| --- | --- | --- | --- | --- | --- |
| Criar | `INSERT` | POST | 201 | `insertOne` | `object.save()` (novo) |
| Ler | `SELECT` | GET | 200 | `find` / `findOne` | `query.find()` / `.get()` |
| Atualizar | `UPDATE` | PUT / PATCH | 200 | `updateOne` | `object.save()` (campos alterados) |
| Excluir | `DELETE` | DELETE | 204 | `deleteOne` | `object.destroy()` |

Duas notas de rodapé da [spec do HTTP](https://www.rfc-editor.org/rfc/rfc9110) 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

```mermaid
flowchart LR
  accTitle: Onde as operações CRUD acontecem em uma stack
  accDescr: Uma interface de usuário dispara chamadas de SDK ou HTTP; a camada de API mapeia verbos para operações, aplica permissões e validação e executa os comandos correspondentes no banco de dados.
  UI["UI<br/>formulários, listas, botões"] --> API["Camada de API<br/>verbos → operações<br/>permissões · validação"]
  API --> DB[("Banco de dados<br/>INSERT · SELECT<br/>UPDATE · DELETE")]
```

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

| Pergunta | CRUD | REST |
| --- | --- | --- |
| O que nomeia | Operações sobre dados | Um estilo arquitetural para clientes e recursos |
| Definido por | Quatro verbos | Restrições: stateless, interface uniforme, cacheável… |
| Vive onde | SQL, SDKs, filas, qualquer lugar | APIs HTTP |
| Relação | A carga habitual dos endpoints REST | Costuma mapear para CRUD — mas pode expor ações não-CRUD |

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](/glossary/pt/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

| Modele como CRUD quando… | Busque mais quando… |
| --- | --- |
| O estado atual do registro é a verdade | O histórico *é* o domínio → event sourcing |
| Editar é o modelo mental do usuário | Leituras e escritas escalam diferente → CQRS |
| "Excluir" pode remover de verdade | Auditoria ou desfazer exigem soft deletes |
| Edições concorrentes são raras | Updates perdidos rondam → lock otimista, versões |
| A ação é "mudar este registro" | A ação é um verbo de negócio → nomeie o workflow |

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](https://docs.parseplatform.org/rest/guide/) 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.