Was ist CRUD (Create, Read, Update, Delete)?

CRUD ist ein Kürzel für Create, Read, Update und Delete – die vier Grundoperationen, die jeder persistente Datenspeicher unterstützen muss. Geprägt in James Martins Managing the Data-base Environment von 1983, ist es bis heute das langlebigste Akronym der Backend-Arbeit, weil es das Fundament benennt: Was Ihr System sonst auch tut – Datensätze müssen entstehen, gefunden werden, sich ändern und wieder verschwinden.

Das Wichtigste in Kürze

CRUD in vier Sprachen

-- CRUD in SQL: die ursprüngliche Zuordnung
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

Und derselbe Zyklus, wie ihn ein SDK ausdrückt – die Form, in der der meiste Anwendungscode tatsächlich geschrieben wird:

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

Eine Tabelle für alle Zuordnungen

Die Zuordnung über sechs Spalten, die keine einzelne Referenz zusammenstellt:

Zwei Fußnoten aus der HTTP-Spezifikation, die man wirklich kennen sollte: GET ist sicher (keine Zustandsänderung), PUT und DELETE sind idempotent (ohne Schaden wiederholbar), POST ist keines von beiden – deshalb behandelt Retry-Logik sie unterschiedlich, und deshalb bedeutet PUT “vollständig ersetzen”, PATCH dagegen “teilweise ändern”.

Wo CRUD stattfindet

Das Diagramm ist zugleich eine Sicherheitsmahnung: Jedes Verb passiert die API-Schicht, und genau dort gehören Berechtigungen und Validierung hin – eine CRUD-Schnittstelle ohne Zugriffskontrolle pro Operation ist nichts anderes als eine öffentliche Datenbank mit Umweg.

CRUD vs. REST

Die praktische Erkenntnis: Eine REST-API ist häufig eine CRUD-API im HTTP-Gewand – aber “Rechnung freigeben” gehört in Ihre API und ist kein CRUD-Verb, und CRUD existiert problemlos ganz ohne HTTP. Die Begriffe ergänzen sich; sie konkurrieren nicht.

Typische Anwendungsfälle

• Die klassische CRUD-App. Admin-Panels, CMS, CRM, Lagerverwaltung, Buchungen – der Großteil der Unternehmenssoftware, und das ganz ehrenwert.
• Prototypen und MVPs. Die vier Verben auf einer Handvoll Klassen sind die erste Version der meisten Produkte.
• Automatisch generierte APIs. Schema rein, CRUD-Schnittstelle raus – der moderne Standard, der die vier Verben zu Konfiguration statt Code macht; ausführlich behandelt im Eintrag zu automatisch generierten APIs.
• Admin- und Support-Werkzeuge. Visuelle Tabellenansichten über derselben CRUD-Schnittstelle, Berechtigungen inklusive.
• Das Fundament unter allem anderen. Auch Systeme mit Event Sourcing oder vielen Workflows stellen irgendwo CRUD bereit – Einstellungen, Profile, Stammdaten.

Sollte jede Aktion CRUD sein? Eine Entscheidungsmatrix

Die letzte Zeile ist das Designwarnsignal, das man sich merken sollte: Wenn Endpoint-Namen in Richtung updateStatus abdriften, verlangt die Domäne nach eigenen Verben.

Grenzen und Trade-offs

• Update zerstört Historie. Die Änderung an Ort und Stelle ist der prägende Akt von CRUD und zugleich sein prägender Verlust – alles, was wissen muss, “wie das am Dienstag aussah”, braucht ein Journal oder Events.
• Löschen ist eine Richtlinie, kein Verb. Soft vs. Hard Delete wägt Nachvollziehbarkeit gegen datenschutzrechtliche Löschpflichten und Abfragekomplexität ab; entscheiden Sie pro Klasse, und zwar bewusst.
• Nebenläufigkeit ist nicht eingepreist. Zwei Updates, der letzte Schreiber gewinnt, die Änderung des ersten ist stillschweigend weg – Versionsfelder und bedingtes Speichern sind das übliche Gegenmittel.
• List ist das fünfte Verb. Filtern, Sortieren und Paginierung tragen den Großteil des realen Lesetraffics und die meisten Performance-Bugs – der Grund, warum es CRUDL und BREAD gibt.
• CRUD-APIs können blutleer werden. Eine Schnittstelle, die nur Zeilen hinein- und herausreicht, drängt Geschäftslogik in die Clients; halten Sie die Workflows auf dem Server, direkt bei den Daten.

CRUD mit Back4app

Back4app ist eine Open-Source-Plattform für Backend as a Service (BaaS), die eine verwaltete Datenbank, automatisch generierte REST- und GraphQL-APIs, Authentifizierung, Dateispeicher und Serverless-Funktionen mit Cloud Code kombiniert. Ihr Beitrag zu diesem Artikel ist Subtraktion: Sie definieren eine Klasse, und die gesamte CRUD-Matrix von oben existiert auf einen Schlag – REST-Endpoints gemäß der HTTP-Spalte, GraphQL-Mutations und die SDK-Idiome aus den Code-Tabs, wobei Berechtigungen auf Klassenebene jedes Verb absichern und beforeSave-Trigger die Validierung übernehmen. Die vier Verben sind nicht länger Ihre Codebasis, sondern Ihr Vokabular.