MongoDB-Daten validieren

Einführung

In diesem Lab lernen Sie die Grundlagen der Datenvalidierung in MongoDB kennen. Datenvalidierung ist ein entscheidendes Merkmal, das hilft, die Integrität und Konsistenz Ihrer Daten aufrechtzuerhalten, indem sichergestellt wird, dass alle Dokumente in einer Collection einer bestimmten Struktur und Regeln entsprechen. Sie lernen, wie Sie Collections mit Validierungsregeln erstellen, diese Regeln testen, indem Sie versuchen, sowohl gültige als auch ungültige Daten einzufügen, und Validierungsregeln für eine bestehende Collection ändern. Am Ende dieses Labs werden Sie in der Lage sein, Datenqualität direkt in Ihrer MongoDB-Datenbank durchzusetzen.

Collection mit Schema-Validierung erstellen

In diesem ersten Schritt verbinden Sie sich mit dem MongoDB-Server und erstellen eine neue Collection mit spezifischen Validierungsregeln. Diese Regeln definieren die erwarteten Datentypen und Einschränkungen für die Felder in Ihren Dokumenten.

Öffnen Sie zunächst die MongoDB Shell (mongosh), um mit Ihrer Datenbank zu interagieren. Diese interaktive Shell ist Ihr primäres Werkzeug zur Verwaltung von MongoDB.

mongosh

Sobald Sie sich in der Shell befinden, sehen Sie eine Eingabeaufforderung wie test>. Dies zeigt an, dass Sie mit der Standarddatenbank test verbunden sind. Erstellen und wechseln wir nun zu einer neuen Datenbank namens dataValidationLab.

use dataValidationLab

Lassen Sie uns nun eine users-Collection erstellen. Beim Erstellen der Collection fügen wir ein validator-Dokument hinzu, das $jsonSchema verwendet, um unsere Regeln zu definieren.

db.createCollection("users", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["name", "age", "email"],
      properties: {
        name: {
          bsonType: "string",
          description: "muss ein String sein und ist erforderlich"
        },
        age: {
          bsonType: "int",
          minimum: 18,
          description: "muss eine Ganzzahl >= 18 sein und ist erforderlich"
        },
        email: {
          bsonType: "string",
          pattern: "^.+@.+$",
          description:
            "muss eine gültige E-Mail-Adresse sein und ist erforderlich"
        }
      }
    }
  }
});

Nach Ausführung des Befehls sollten Sie eine Ausgabe sehen, die den Erfolg anzeigt:

{ "ok": 1 }

Lassen Sie uns den Validator aufschlüsseln:

• bsonType: "object": Die Wurzel des Dokuments muss ein Objekt sein.
• required: ["name", "age", "email"]: Die Felder name, age und email müssen in jedem Dokument vorhanden sein.
• properties: Dieses Objekt definiert die Regeln für einzelne Felder.
  • name: Muss ein string sein.
  • age: Muss ein int (Ganzzahl) mit einem minimum-Wert von 18 sein.
  • email: Muss ein string sein, der dem regulären Ausdruck pattern entspricht, der ein grundlegendes E-Mail-Format prüft.

Sie haben nun erfolgreich eine Collection mit Datenvalidierungsregeln erstellt. Im nächsten Schritt werden Sie diese Regeln testen.

Validierung durch Einfügen von Dokumenten testen

Nachdem Ihre users-Collection nun Validierungsregeln hat, testen wir diese. Sie werden versuchen, mehrere Dokumente einzufügen: einige, die die Regeln verletzen, und eines, das ihnen entspricht. Dies wird Ihnen helfen zu verstehen, wie MongoDB das Schema erzwingt.

Versuchen wir zunächst, ein Dokument mit einem falschen Datentyp für das Feld age einzufügen. Wir geben den String "25" anstelle einer Ganzzahl an.

db.users.insertOne({
  name: "John Doe",
  age: "25",
  email: "john.doe@example.com"
});

Diese Operation wird fehlschlagen. MongoDB wird das Dokument ablehnen und einen WriteError zurückgeben, da das Feld age nicht die Anforderung bsonType: "int" erfüllt. Die Fehlermeldung enthält Details zum Validierungsfehler.

MongoServerError: Document failed validation

Als Nächstes versuchen wir, ein Dokument einzufügen, dem ein erforderliches Feld, email, fehlt.

db.users.insertOne({
  name: "Jane Doe",
  age: 30
});

Dies wird ebenfalls fehlschlagen, da das Feld email in unserem Validator im required-Array aufgeführt ist. Sie erhalten einen ähnlichen WriteCommandError.

Schließlich fügen wir ein Dokument ein, das allen Regeln entspricht. name und email sind Strings, und age ist eine Ganzzahl größer oder gleich 18.

db.users.insertOne({
  name: "Alice",
  age: 28,
  email: "alice@example.com"
});

Dieses Mal wird der Befehl erfolgreich sein, und Sie sehen eine Bestätigungsnachricht mit der _id des neu eingefügten Dokuments.

{
  "acknowledged": true,
  "insertedId": ObjectId("...")
}

Um zu bestätigen, dass das gültige Dokument hinzugefügt wurde, können Sie die Collection abfragen.

db.users.find();

Die Ausgabe zeigt das eine Dokument an, das die Validierung erfolgreich bestanden hat.

[
  {
    "_id": ObjectId("..."),
    "name": "Alice",
    "age": 28,
    "email": "alice@example.com"
  }
]

Vorhandenen Validator ändern

Die Anforderungen Ihrer Anwendung können sich im Laufe der Zeit ändern, und Sie müssen möglicherweise Ihre Validierungsregeln aktualisieren. In diesem Schritt lernen Sie, wie Sie den Validator einer vorhandenen Collection mit dem Befehl collMod ändern und anschließend die neuen Regeln testen.

Nehmen wir an, wir möchten unserer users-Collection ein neues Feld status hinzufügen. Dieses Feld sollte ein String sein und nur einen von zwei Werten haben: "active" oder "inactive".

Wir verwenden den Befehl collMod (collection modify), um den neuen Validator anzuwenden.

db.runCommand({
  collMod: "users",
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["name", "age", "email", "status"],
      properties: {
        name: {
          bsonType: "string",
          description: "muss ein String sein und ist erforderlich"
        },
        age: {
          bsonType: "int",
          minimum: 18,
          description: "muss eine Ganzzahl >= 18 sein und ist erforderlich"
        },
        email: {
          bsonType: "string",
          pattern: "^.+@.+$",
          description:
            "muss eine gültige E-Mail-Adresse sein und ist erforderlich"
        },
        status: {
          enum: ["active", "inactive"],
          description: "darf nur einer der Enum-Werte sein und ist erforderlich"
        }
      }
    }
  }
});

Der Befehl gibt bei Erfolg { "ok": 1 } zurück. Wir haben nun den Validator aktualisiert, um das Feld status zu erfordern und seinen Wert mithilfe des Schlüsselworts enum einzuschränken.

Testen wir nun die neue Regel. Versuchen Sie, ein Dokument mit einem ungültigen Status einzufügen.

db.users.insertOne({
  name: "Bob",
  age: 45,
  email: "bob@example.com",
  status: "pending"
});

Dies schlägt fehl, da "pending" nicht in der enum-Liste für das Feld status enthalten ist. Fügen Sie als Nächstes ein Dokument ein, das den aktualisierten Regeln entspricht.

db.users.insertOne({
  name: "Bob",
  age: 45,
  email: "bob@example.com",
  status: "active"
});

Diese Einfügung wird erfolgreich sein. Um alle Dokumente in Ihrer Collection anzuzeigen, führen Sie find() erneut aus.

db.users.find();

Sie sehen nun sowohl Alices als auch Bobs Dokumente. Beachten Sie, dass Alices Dokument, das vor der Regeländerung eingefügt wurde, nicht das Feld status enthält. Standardmäßig gilt die Validierung nicht für vorhandene Dokumente, bis diese geändert werden.

Zusammenfassung

In diesem Lab haben Sie die wesentlichen Techniken zur Implementierung von Datenvalidierung in MongoDB kennengelernt. Sie haben mit der Erstellung einer Collection mit einem $jsonSchema-Validator begonnen, um Datentypen, erforderliche Felder und Wertebeschränkungen durchzusetzen. Anschließend haben Sie diese Regeln getestet, indem Sie versucht haben, sowohl ungültige als auch gültige Dokumente einzufügen, und beobachtet, wie MongoDB Daten ablehnt, die nicht dem Schema entsprechen. Schließlich haben Sie gelernt, wie Sie die Validierungsregeln für eine vorhandene Collection mit dem Befehl collMod ändern können, um sich an neue Anforderungen anzupassen. Diese Fähigkeiten sind grundlegend für den Aufbau robuster Anwendungen und die Aufrechterhaltung einer hohen Datenqualität in Ihren MongoDB-Datenbanken.