Che cos'è il CRUD (create, read, update, delete)?

Il CRUD è l’acronimo di create, read, update e delete: le quattro operazioni di base che ogni archivio di dati persistente deve supportare. Coniato in Managing the Data-base Environment di James Martin (1983), resta l’acronimo più duraturo del lavoro di backend perché nomina il pavimento: qualunque altra cosa faccia il sistema, i record devono venire al mondo, essere ritrovati, cambiare e sparire.

Punti chiave

CRUD in quattro linguaggi

-- Il CRUD in SQL: la mappatura originale
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 lo stesso ciclo nel modo in cui lo esprime un SDK – la forma che il codice applicativo scrive davvero:

// 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 tabella per mapparli tutti

La mappatura a sei colonne che nessun singolo riferimento mette insieme:

Due note a piè di pagina della specifica HTTP che vale davvero la pena conoscere: GET è sicuro (nessun cambiamento di stato), PUT e DELETE sono idempotenti (ripetibili senza danni), POST non è né l’uno né l’altro – ed è per questo che la logica di retry li tratta in modo diverso, e perché PUT significa “sostituire tutto” mentre PATCH significa “modificare una parte”.

Dove accade il CRUD

Il diagramma è anche il promemoria di sicurezza: ogni verbo attraversa il livello API, ed è lì che permessi e validazione hanno il loro posto – una superficie CRUD senza controllo degli accessi per singola operazione è un database pubblico con qualche passaggio in più.

CRUD vs. REST

La lezione pratica: un’API REST è spesso un’API CRUD vestita da HTTP – ma “approvare la fattura” ha diritto di stare in un’API e non è un verbo CRUD, e il CRUD esiste tranquillamente senza HTTP all’orizzonte. I termini collaborano; non sono in concorrenza.

Casi d’uso tipici

• L’app CRUD in senso proprio. Pannelli di amministrazione, CMS, CRM, magazzino, prenotazioni – la maggior parte del software aziendale, con onore.
• Prototipi e MVP. I quattro verbi su una manciata di classi sono la prima versione della maggior parte dei prodotti.
• API generate automaticamente. Schema in ingresso, superficie CRUD in uscita – il default moderno che trasforma i quattro verbi in configurazione invece che in codice, trattato per esteso nella voce sulle API generate automaticamente.
• Strumenti di amministrazione e supporto. Griglie visuali sulla stessa superficie CRUD, permessi compresi.
• Il substrato sotto tutto il resto. Anche i sistemi event-sourced e pesanti di workflow espongono CRUD da qualche parte – impostazioni, profili, dati di riferimento.

Ogni azione deve essere CRUD? Matrice decisionale

L’ultima riga è il design smell che vale la pena memorizzare: quando i nomi degli endpoint derivano verso updateStatus, il dominio sta chiedendo verbi propri.

Limiti e trade-off

• L’aggiornamento distrugge la storia. La mutazione in loco è l’atto fondativo del CRUD e la sua perdita fondativa: tutto ciò che ha bisogno di sapere “com’era martedì” vuole journaling o eventi.
• Eliminare è una politica, non un verbo. Soft delete contro hard delete scambia la verificabilità con la cancellazione pretesa dai regimi di privacy e con la complessità delle query; conviene decidere per classe, in modo deliberato.
• La concorrenza non ha un prezzo esposto. Due update, vince l’ultimo che scrive, la modifica del primo scompare in silenzio – campi di versione e salvataggi condizionali sono l’antidoto standard.
• List è il quinto verbo. Filtri, ordinamenti e paginazione portano gran parte del traffico reale di lettura e gran parte dei bug prestazionali – è la ragione d’essere di CRUDL e BREAD.
• Le API CRUD possono diventare anemiche. Una superficie che è solo righe-in-righe-fuori spinge la logica di business verso i client; i workflow restano lato server, accanto ai dati.

Le operazioni CRUD su Back4app

Back4app è una piattaforma open-source di Backend as a Service (BaaS) che combina database gestito, API REST e GraphQL generate automaticamente, autenticazione, archiviazione di file e funzioni serverless con Cloud Code. Il suo rapporto con questo articolo è una sottrazione: si definisce una classe e tutta la matrice CRUD qui sopra esiste di colpo – endpoint REST secondo la colonna HTTP, mutation GraphQL e gli idiomi SDK delle schede di codice, con i permessi a livello di classe che presidiano ogni verbo e i trigger beforeSave che si fanno carico della validazione. I quattro verbi smettono di essere la codebase e diventano il vocabolario.