MongoDB-Schema-Validierung: Ein praktischer Leitfaden mit Beispielen

MongoDB hat zwar kein Schema, aber das heißt nicht, dass deine Daten chaotisch sein müssen.

In diesem Artikel erfährst du alles von den Grundlagen der Schema-Validierung bis hin zu fortgeschrittenen Anwendungsfällen mit dem Operator „ $jsonSchema “. Du lernst, wie du Pflichtfelder durchsetzen, Datentypen einschränken, Muster anwenden und verschachtelte Dokumente überprüfen kannst. 

Wir zeigen dir auch, wie die Validierung beim Einfügen und Aktualisieren funktioniert, wie du vorhandene Sammlungen ändern kannst und wann du verschiedene Validierungsstufen und Aktionen verwenden solltest. 

Am Ende wirst du Schema-Validierung sicher in deinen MongoDB-Sammlungen anwenden können, sodass deine Daten sauber und vorhersehbar bleiben, ohne die Flexibilität von MongoDB einzubüßen.

Warum Schema-Validierung in MongoDB wichtig ist

Das dynamische Dokumentenmodell von MongoDB ist schnell und flexibel, weil Dokumente in derselben Sammlung unterschiedliche Felder oder Strukturen haben können. Das ist echt praktisch in der frühen Entwicklungsphase oder bei schnellen Iterationen. Diese Flexibilität kann aber schnell zum Problem werden und zu ungenauen, unvollständigen oder falschen Daten führen, wenn deine Anwendung wächst.

Hier kommtdie Schema-Validierungs ins Spiel. Damit kannst du Regeln für deine Dokumente festlegen – wie Pflichtfelder, bestimmte Datentypen oder verschachtelte Strukturen – und trotzdem die Flexibilität von MongoDB nutzen.

In diesem Artikel erfährst du, wie du den coolen Operator „ $jsonSchema “ von MongoDB nutzen kannst, um diese Regeln auf deine Sammlungen anzuwenden. Egal, ob du fehlerhafte Einträge in einer neuen Anwendung verhindern oder Validierungsregeln in eine alte Datenbank einbauen willst – mit der Schema-Validierung stellst du sicher, dass deine Daten sauber bleiben, deine Abfragen vorhersehbar sind und deine Anwendung stabil läuft.

Wenn du noch keine Erfahrung mit MongoDB und Python hast,ist dieser Einführungskurs in MongoDB eine super Möglichkeit, um dich mit Abfragen und Integrationen vertraut zu machen, bevor du dich mit der Schema-Validierung beschäftigst.

Bevor du loslegst

Um alles aus diesem Handbuch rauszuholen, brauchst du Zugriff auf einen MongoDB Atlas-Cluster. Die kostenlose Version reicht völlig aus, um mitzukommen.

Um die Konzepte so klar und anwendbar wie möglich zu machen, verwenden wireinen MongoDB Atlas-Beispieldatensatz –, genauer gesagt die Datenbank „ sample_mflix “. Dieser Datensatz enthält Sammlungen wie Filme, Kommentare, Benutzer und Kinos, auf die wir im Laufe des Artikels immer wieder zurückkommen werden, um die einzelnen Beispiele zu veranschaulichen. Der Datensatz hat Dokumente mit Feldern wie verschachtelten Objekten, Arrays, Strings, Zahlen und optionalen Feldern.

Lade den Beispiel-Datensatz (wenn nötig)

1. Geh zu deinem MongoDB Atlas-Dashboard.

2. Such dir deinen Cluster aus, klick auf die Schaltfläche „…“ und wähl „Beispieldatensatz laden“ aus.

3. Warte ein paar Minuten, bis die Datenbank sample_mflix verfügbar ist.

Erste Schritte mit der Schema-Validierung

Sobald dein Dataset geladen ist, verbinde dich über MongoDB Shell (mongosh) oder MongoDB Compass mit deinem Cluster und wechsle dann zum Dataset:

use sample_mflix

Den Datensatz mit findOne() durchsuchen

Schauen wir uns mal eins der Dokumente aus der Filmsammlung an:

db.movies.findOne()

Hier ist eine vereinfachte Version dessen, was du sehen könntest:

Abbildung 1. Diese Abfrage nutzt findOne(), um ein einzelnes Beispieldokument aus der Sammlung „movies“ in der Datenbank „sample_mflix“ zu holen. Das Ergebnis zeigt verschiedene Felder, darunter Titel, Jahr, Genres und eingebettete Objekte wie imdb und tomatoes.viewer.

Dieses Dokument hat eine Mischung aus Skalarwerten, Arrays und verschachtelten Objekten, was es super zum Zeigen verschiedener Validierungstechniken macht. Im nächsten Abschnitt erstellen wir eine neue Sammlung basierend auf dieser Struktur und definieren unser erstes Validierungsschema mit „ $jsonSchema “.

Unterstützte Schlüsselwörter, Erweiterungen und Einschränkungen

$jsonSchema Die Validierung von MongoDB-Schemas basiert auf der JSON Schema Draft 4-Spezifikation, mit ein paar Änderungen und Auslassungen. Es werden zwar nicht alle Funktionen aus der ursprünglichen Spezifikation unterstützt, aber MongoDB hat eine fokussierte und praktische Teilmenge, die sich gut zum Validieren von BSON-Dokumenten eignet.

Hier sind ein paar der am häufigsten verwendeten Stichwörter:

• bsonType: MongoDB-spezifisches Typ-Schlüsselwort (z. B. „string“, „int“, „array“, „object“)
• Benötigte Datei: Sagt, welche Felder da sein müssen
• Minimal-/Maximal: Für die Überprüfung von Zahlenbereichen
• Muster: Für die Überprüfung von Zeichenfolgenformaten mit regulären Ausdrücken
• Aufzählung: Schränkt ein Feld auf eine Reihe von erlaubten Werten ein.
• items, minItems, maxItems: Für die Array-Validierung
• Eigenschaften: Definiert Regeln für Felder innerhalb eines Objekts.
• additionalProperties: Steuert, ob zusätzliche (nicht definierte) Felder erlaubt sind.

MongoDB lässt bewusst ein paar fortgeschrittene Funktionen aus dem vollständigen JSON-Schema weg, zum Beispiel:

• Schema-Referenzen ($ref).
• Bedingte Logik (wenn/dann/sonst).
• Zusammensetzungsoperatoren (oneOf, allOf, anyOf).

Die komplette Liste der unterstützten Optionen findest du in der offiziellen MongoDB $jsonSchema-Dokumentation.

In diesem Artikel schauen wir uns die praktischsten und am besten unterstützten Schlüsselwörter an, die für die gängigen Validierungsanforderungen in der Praxis ausreichen, ohne zu kompliziert zu sein.

Wenn du mehr darüber erfahren möchtest, wie MongoDB in die NoSQL-Landschaft passt, schau dir dieses umfassende Tutorial an.

Erstellen einer Sammlung mit grundlegender Validierung

Nachdem wir uns die Struktur eines Filmdokuments angesehen haben, erstellen wir jetzt eine neue Sammlung, die mithilfe von „ $jsonSchema “ ein paar grundlegende Regeln durchsetzt. Wir fangen mit ein paar typischen Einschränkungen an:

• title: muss eine Zeichenfolge sein und ist erforderlich
• Jahr: Muss eine ganze Zahl sein und ist Pflichtfeld.
• Genres: Muss ein Array von Strings sein.
• Laufzeit: muss eine positive ganze Zahl sein

Wir nennen diese neue Kollektion „ validated_movies “.

Die Sammlung erstellen

Führ den folgenden Befehl aus, um die Sammlung mit Validierung zu erstellen:

db.createCollection("validated_movies", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["title", "year", "runtime"],
      properties: {
        title: {
          bsonType: "string",
          description: "must be a string and is required"
        },
        year: {
          bsonType: "int",
          minimum: 1888,
          description: "must be an integer >= 1888 (year of the first film)"
        },
        runtime: {
          bsonType: "int",
          minimum: 1,
          description: "must be a positive integer and is required"
        },
        genres: {
          bsonType: "array",
          items: {
            bsonType: "string"
          },
          description: "must be an array of strings"
        }
      }
    }
  },
  validationLevel: "strict",
  validationAction: "error"
});

Ein gültiges Dokument einfügen

Jetzt fügen wir ein Dokument ein, das dem Schema folgt:

db.validated_movies.insertOne({
  title: "Inception",
  year: 2010,
  runtime: 148,
  genres: ["Action", "Sci-Fi", "Thriller"]
});

✅ Das sollte klappen.

Ein ungültiges Dokument einfügen

Versuche mal, ein Dokument einzufügen, bei dem das Feld „ title “ fehlt:

db.validated_movies.insertOne({
  year: 2020,
  runtime: 95,
  genres: ["Drama"]
});

❌ Das wird wegen eines Validierungsfehlers nicht klappen, weil „ title “ gebraucht wird.

Abbildung 2. Der erste Befehl fügt ein gültiges Filmdokument in die Sammlung validated_movies ein und übergibt dabei alle erforderlichen Felder und Datentypen. Der zweite Befehl versucht, ein Dokument ohne das erforderliche Titelfeld einzufügen, was zu einem Validierungsfehler führt.

Arbeiten mit vorhandenen Sammlungen

Du musst nicht bei Null anfangen, um die Schema-Validierung zu nutzen. Mit MongoDB kannst du Validierungsregeln mit dem Befehl „ collMod “ auf vorhandene Sammlungen anwenden. Das ist besonders praktisch, wenn du einen alten Datensatz strukturieren willst, ohne die bestehenden Dokumente zu verändern.

In diesem Abschnitt wenden wir einen Validator auf die Film-Sammlung aus der Datenbank „ sample_mflix “ an.

Hinzufügen eines Validators mit collMod

Lass uns eine einfache Regel einhalten: Jedes Filmdokument muss ein Feld „ title “ vom Typ „Zeichenkette“ haben.

db.runCommand({
  collMod: "movies",
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["title"],
      properties: {
        title: {
          bsonType: "string",
          description: "must be a string and is required"
        }
      }
    }
  },
  validationLevel: "moderate",
  validationAction: "warn"
});

Validierungsregeln für die Sammlung checken

Nachdem du die Sammlung „ movies “ mit dem Befehl „ collMod “ geändert hast, solltest du überprüfen, welche Validierungsregeln gerade aktiv sind.

Um den aktuellen Schema-Validator zu überprüfen, mach Folgendes:

db.getCollectionInfos({ name: "movies" })[0].options.validator

Das gibt das Objekt „ $jsonSchema “ zurück, das die Validierungsregeln für die Sammlung festlegt. Das ist eine coole Möglichkeit, um zu checken, ob deine Konfiguration richtig funktioniert, vor allem wenn du den Modus von „warn“ auf „error“ umgestellt oder die Struktur der Pflichtfelder geändert hast.

Verstehen von validationLevel und validationAction

• Validierungsstufe: „moderat“: Überprüft nur Dokumente, die gerade eingefügt oder aktualisiert werden. Bestehende Dokumente, die nicht zum Schema passen, lösen keine Fehler aus.

• validierungAction: „warn“: Anstatt ungültige Schreibvorgänge abzulehnen, protokolliert MongoDB eine Warnung. Das ist in der Produktion nützlich, wenn du Schema-Verstöße checken willst, bevor du sie erzwingst.

Versuch mal, ein Dokument einzufügen, das nicht zum Schema passt:

db.movies.insertOne({
  year: 2023
});

In den Protokollen wird eine Warnung angezeigt, aber der Schreibvorgang wird erfolgreich durchgeführt. Du kannst die Aktion später auf „Fehler“ ändern, um die Regel strikt durchzusetzen, sobald du dir sicher bist.

Abbildung 3. Der Befehl insertOne() fügt ein Dokument, das gegen die Schemaregel verstößt, erfolgreich hinzu, weil die Validierungsaktion auf „warn“ gesetzt ist. MongoDB akzeptiert den Schreibvorgang, aber das fehlende Feld „title“ hätte einen Validierungsfehler ausgelöst, wenn „error“ erzwungen worden wäre.

Verschachtelte Dokumente und Arrays überprüfen

MongoDB-Dokumente haben oft verschachtelte Strukturen, wie Objekte in Objekten und Arrays von Werten. Zum Glück unterstützt „ $jsonSchema “ die Validierung von beiden. Schauen wir mal, wie man Regeln auf Unterdokumente und Array-Inhalte anwendet, indem wir Felder aus der Sammlung „movies“ nutzen.

Ein verschachteltes Dokument überprüfen

In der Filmsammlung hat jedes Dokument ein eingebettetes „ imdb ”-Objekt mit Feldern wie „ rating ”, „ votes ” und „ id ”. Lass uns eine Regel einhalten, die Folgendes sicherstellt:

• imdb ist ein Objekt (falls vorhanden).
• imdb.rating ist eine Zahl zwischen 0 und 10.

So würdest du das definieren:

db.createCollection("validated_nested", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      properties: {
        imdb: {
          bsonType: "object",
          properties: {
            rating: {
              bsonType: "double",
              minimum: 0,
              maximum: 10,
              description: "Must be a number between 0 and 10"
            }
          }
        }
      }
    }
  }
});

Testen des verschachtelten Dokuments

✅ Gültiger Einsatz:

db.validated_nested.insertOne({
  title: "Interstellar",
  imdb: { rating: 8.6 }
});

Ungültige Eingabe (Bewertung außerhalb des Bereichs):

db.validated_nested.insertOne({
  title: "Bad Movie",
  imdb: { rating: 12.5 }
});

Das wird einen Validierungsfehler auslösen, weil die Bewertung größer als 10 ist.      Abbildung 4. Dieser Einfügevorgang klappt nicht, weil das Feld „rating” im verschachtelten Objekt „imdb” den maximal erlaubten Wert von 10 überschreitet, der im Schema festgelegt ist. MongoDB gibt einen Validierungsfehler wegen eines Verstoßes gegen die $jsonSchema-Regel aus.

Arrays überprüfen

Du kannst auch Array-Einschränkungen durchsetzen. Nehmen wir mal an, du willst sichergehen, dass:

• genres ist ein Array von Strings.
• Das Array muss mindestens ein Element haben.

Füge das hier zu deinem Schema hinzu:

genres: {
  bsonType: "array",
  minItems: 1,
  items: {
    bsonType: "string"
  },
  description: "Must be a non-empty array of strings"
}

Mehrere Einschränkungen kombinieren

In der Praxis müssen deine Dokumente oft mehrere Validierungsregeln gleichzeitig erfüllen – zum Beispiel Pflichtfelder, erlaubte Werte, Typen und verschachtelte Strukturen. Mit „ $jsonSchema “ kannst du ganz einfach mehrere Einschränkungen in einer einzigen Schemadefinition zusammenfassen.

Lass uns ein besseres Beispiel mit der Dokumentstruktur für Filme machen. Wir halten uns an die folgenden Regeln:

• Titel: erforderlich, muss eine Zeichenfolge sein
• Jahr: muss angegeben werden, ganze Zahl, ≥ 1888
• bewertet: optional, muss aber mit einem vordefinierten Satz von Werten übereinstimmen
• Genres: muss ein nicht leeres Array von Strings sein
• imdb.rating: Zahl zwischen 0 und 10
• tomatoes.viewer.rating: optional, Zahl zwischen 0 und 5

Erstellen einer validierten Sammlung

db.createCollection("validated_full", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["title", "year"],
      properties: {
        title: {
          bsonType: "string",
          description: "Title is required and must be a string"
        },
        year: {
          bsonType: "int",
          minimum: 1888,
          description: "Year must be an integer >= 1888"
        },
        rated: {
          enum: ["G", "PG", "PG-13", "R", "NC-17"],
          description: "Must be a valid MPAA rating"
        },
        genres: {
          bsonType: "array",
          minItems: 1,
          items: { bsonType: "string" },
          description: "Must be a non-empty array of strings"
        },
        imdb: {
          bsonType: "object",
          properties: {
            rating: {
              bsonType: "double",
              minimum: 0,
              maximum: 10,
              description: "IMDB rating must be between 0 and 10"
            }
          }
        },
        tomatoes: {
          bsonType: "object",
          properties: {
            viewer: {
              bsonType: "object",
              properties: {
                rating: {
                  bsonType: "double",
                  minimum: 0,
                  maximum: 5,
                  description: "Viewer rating must be between 0 and 5"
                }
              }
            }
          }
        }
      }
    }
  }
});

Ein gültiges Dokument einfügen: 

db.validated_full.insertOne({
  title: "The Matrix",
  year: 1999,
  rated: "R",
  genres: ["Action", "Sci-Fi"],
  imdb: { rating: 8.7 },
  tomatoes: { viewer: { rating: 4.2 } }
});

Ein ungültiges Dokument einfügen:

db.validated_full.insertOne({
  title: "Untitled Project",
  year: 2025,
  rated: "Unrated",
  genres: [],
  imdb: { rating: 15 },
  tomatoes: { viewer: { rating: 6.1 } }
});

Das wird aus folgenden Gründen nicht funktionieren:

• Der Wert „ rated “ ist nicht okay.
• Leeres Array „ genres “.
• imdb.rating mehr als 10.
• tomatoes.viewer.rating mehr als 5.

Abbildung 5. Dieser Einfügevorgang klappt nicht, weil es in der Sammlung validated_full mehrere Schema-Verstöße gibt. Das Feld „rated“ hat einen Wert, der in der Aufzählung nicht erlaubt ist, „genres“ ist ein leeres Array, was gegen die Regel „minItems“ verstößt, „imdb.rating“ ist größer als 10 und hat den falschen Typ, und „tomatoes.viewer.rating“ ist größer als das erlaubte Maximum von 5. MongoDB lehnt die Einfügung mit einem detaillierten Validierungsfehler ab.

Validierungsstufen und Maßnahmen erklärt

Mit MongoDB kannst du ganz genau festlegen, wie und wann die Schema-Validierung angewendet wird. Beim Festlegen von Validierungsregeln gibt es zwei Optionen, die das Verhalten deiner Datenbank beeinflussen:

• validationLevel: Wann die Regel angewendet werden sollte
• Validierungsaktion: Was passiert, wenn ein Dokument nicht den Regeln entspricht?

validationLevel

Diese Option legt fest, welche Vorgänge einer Schemaüberprüfung unterliegen.

• streng: Alle neuen Einträge und Änderungen müssen dem Schema entsprechen. Das ist der Standardmodus und der sicherste.
• mäßig: Es werden nur Dokumente überprüft, die gerade eingefügt oder aktualisiert werden. Bestehende Dokumente bleiben, auch wenn sie ungültig sind, unverändert.

Wann verwenden:

• Verwende „strict“ für neue Sammlungen, bei denen du das Schema von Anfang an komplett durchsetzen willst.
• Sei vorsichtig, wenn du die Validierung auf Sammlungen anwendest, die schon alte oder unstrukturierte Daten haben.

Validierungsaktion

Diese Option legt fest, wie MongoDB reagiert, wenn ein Dokument gegen die Validierungsregeln verstößt.

• Fehler: Der Schreibvorgang wird abgelehnt und ein Validierungsfehler wird zurückgegeben.
• warn: Der Schreibvorgang wird akzeptiert, aber der Server speichert intern eine Warnung.

Wichtig: In MongoDB Atlas sind Warnungen von „warn“ für Benutzer nicht sichtbar – du siehst sie weder in der Benutzeroberfläche noch in den Standardprotokollen.

Wann verwenden:

• Verwende „warn“ in der Entwicklungsphase oder während der schrittweisen Einführung, um Verstöße zu überwachen, ohne Schreibvorgänge zu blockieren.
• Wechsel zu „Fehler“, wenn du sicher bist, dass deine Anwendung gültige Dokumente schreibt und du das Schema strikt durchsetzen willst.

Beispiel: Von Warnung zu Fehler wechseln

Nehmen wir mal an, du hast so angefangen:

db.runCommand({
  collMod: "validated_full",
  validationAction: "warn",
  validationLevel: "moderate"
});

Nachdem du das Verhalten deiner Anwendung beobachtet hast, kannst du auf strenge Durchsetzung umschalten:

db.runCommand({
  collMod: "validated_full",
  validationAction: "error",
  validationLevel: "strict"
});

Abbildung 6. Mit zwei collMod-Befehlen wird das Validierungsverhalten der Sammlung validated_full geändert. Der erste setzt validationAction auf „warn“ und validationLevel auf „moderate“, sodass ungültige Dokumente eingefügt werden können, während interne Warnungen protokolliert werden. Der zweite Befehl schaltet auf strenge Durchsetzung um, indem validationAction auf „error“ und validationLevel auf „strict“ gesetzt werden, sodass alle Einfügungen und Aktualisierungen vollständig mit dem definierten Schema übereinstimmen müssen.

Jetzt wird jede falsche Eingabe oder Aktualisierung mit einer Fehlermeldung blockiert.

Häufige Probleme und Tipps zum Debuggen

Bei der Schema-Validierung können kleine Fehler zu verwirrenden Fehlern führen – oder schlimmer noch, Dokumente umgehen deine Regeln einfach. Hier sind ein paar der häufigsten Probleme und wie du sie vermeiden kannst:

Falsche bsonType-Werte

Einer der häufigsten Fehler bei der Verwendung von „ $jsonSchema “ ist, JSON-Typen mit „bsonType“ von MongoDB zu verwechseln. Während „string“ und „array“ ganz klar sind, können andere wie Zahlen und Boolesche Werte etwas knifflig sein.

Zum Beispiel:

• Verwende „int“ oder „long“ für ganze Zahlen.
• Verwende „double“ für Gleitkommazahlen.
• Benutz „bool” (nicht „boolean”) für Wahr/Falsch-Werte.
• Benutz „object” für Unterdokumente (nicht „dict” oder „map”).
• Verwende „array“ für Listen.

Wenn du nicht weißt, als welcher Typ ein Feld gespeichert ist, kannst du ein Dokument mit typeof in der Mongo-Shell überprüfen oder die Daten mit MongoDB Compass anschauen.

Fehlende Pflichtfelder bei Teilaktualisierungen

Bei Verwendung von „ $set “ werden nur die Felder überprüft, die geändert werden. Wenn du eine komplette Schema-Prüfung erwartest, stell sicher, dass du alle Dokumente komplett ersetzt oder „ validationLevel: "strict" “ mit Anwendungslogik verwendest, die die komplette Struktur durchsetzt.

Leere Arrays werden weitergegeben, obwohl sie das nicht sollten

Wenn du vergisst, „ minItems “ anzugeben, wird ein leeres Array übergeben:

	genres: {
	  bsonType: "array",
	  items: { bsonType: "string" }
	}
	// Accepts empty arrays by default

Benutz „ minItems: 1 “, um sicherzugehen, dass mindestens ein Wert da ist.

Kein Fehler im Warnmodus

Wie schon erwähnt, blockiert „ validationAction: "warn" “ keine Schreibvorgänge oder Fehler in MongoDB Atlas. Es wird nur intern protokolliert, sodass die Validierung möglicherweise „nicht funktioniert“.

Verwende den „Fehlermodus” während der Entwicklung oder in Testumgebungen, um Probleme frühzeitig zu erkennen.

Verschachtelte Feldpfade werden nicht überprüft, wenn das übergeordnete Objekt fehlt.

Wenn „ imdb.rating “ nötig ist, aber „ imdb “ komplett fehlt, checkt MongoDB „ rating “ nicht.

Um die Validierung für verschachtelte Felder zu erzwingen, musst du sicherstellen, dass das übergeordnete Objekt entweder erforderlich ist oder über „ bsonType: "object" “ verfügt.

Dokumente abfragen oder aktualisieren, die nicht zum Schema passen

Nachdem du die Validierung auf eine vorhandene Sammlung angewendet hast, ist es oft hilfreich, Dokumente zu finden, die nicht zum neuen Schema passen. Du kannst das machen, indem du den Operator „ $jsonSchema “ in einer Abfrage mit „ $nor “ oder „ $not “ verwendest.

Beispiel: Ungültige Dokumente in der Filmsammlung finden

Angenommen, dein Schema braucht einen Titel vom Typ „string“. Um Dokumente zu finden, die nicht übereinstimmen, kannst du Folgendes ausführen:

db.movies.find({
  $nor: [
    { $jsonSchema: {
        bsonType: "object",
        required: ["title"],
        properties: {
          title: { bsonType: "string" }
        }
      }
    }
  ]
});

Das gibt dir Dokumente zurück, bei denen der Titel fehlt oder der falsche Titel-Typ angegeben ist.

Abbildung 7. Diese Abfrage nutzt $nor mit $jsonSchema, um Dokumente in der Sammlung „movies“ zu finden, die kein Feld vom Typ „string“ mit dem Namen „title“ haben. Das Ergebnis zeigt ein Dokument mit _id: 683ce0050bd195c35e417534, das nur das Jahresfeld enthält, was zeigt, dass es gegen das Schema verstößt, das einen Titel verlangt. Diese Technik ist nützlich, um ungültige Dokumente zu erkennen, bevor strengere Validierungsregeln angewendet werden.

Du kannst diesen Ansatz auch für Folgendes nutzen:

• Überprüfe alte Dokumente, bevor du von „Warnung” zu „Fehler” wechselst.
• Ungültige Dokumente automatisch bereinigen oder reparieren.
• Erstell Berichte zur Schema-Konformität.

Zusammenfassung: Daten bereinigen, ohne Flexibilität zu verlieren

Das schemalose Design von MongoDB ist eine der größten Stärken, aber das heißt nicht, dass du deine Daten einfach so lassen solltest. Mit „ $jsonSchema “ kannst du starke Validierungsregeln festlegen, die die Struktur durchsetzen und gleichzeitig die Flexibilität von MongoDB nutzen.

In diesem Artikel hast du gelernt, wie du:

• Erstell Sammlungen mit Validierungsregeln.
• Wende Einschränkungen auf neue und vorhandene Sammlungen an.
• Verwende verschachtelte Validierung für Objekte und Arrays.
• Validierungsmodi und Aktionen einrichten.
• Debugge und verfeinere deine Schemata ganz entspannt.

Egal, ob du eine komplett neue App entwickelst oder ein älteres System auf Vordermann bringst – mit Schema-Validierung hast du die Tools, um deine Daten zu schützen, ohne die Entwicklung zu bremsen.

Nächste Schritte und Ressourcen

Willst du tiefer eintauchen? Schau dir diese Ressourcen an:

• Dokumentation zur Schema-Validierung in MongoDB 
• MongoDB JSON Schema docs
• Beispieldaten auf MongoDB Atlas

Bereit für ein Vorstellungsgespräch? Diese Top-Fragen zu MongoDB testen dein Wissen über Themen wie Schema-Validierung und mehr. Willst du deine Fähigkeiten in yorieren? Dieser Zertifizierungsleitfaden enthältalles, was du wissen musst, um die MongoDB-Zertifizierung zu bekommen.

Denk dran, fang klein an, probier's erst mal mit „warn“ und geh dann zu „error“ über, wenn du dich sicher fühlst – dein zukünftiges Ich (und deine Daten) werden es dir danken.