MongoDB-Daten validieren

Einführung

In diesem Lab werden Sie lernen, wie Sie die MongoDB-Datentypen validieren, ungültige Daten behandeln und schlechte Eingaben verhindern, um die Integrität der Daten in Ihrer MongoDB-Datenbank aufrechtzuerhalten. Sie beginnen mit der Exploration der verschiedenen von MongoDB unterstützten Datentypen und erstellen eine Beispielsamling mit bestimmten Datentypanforderungen. Anschließend üben Sie das Einfügen von Dokumenten mit falschen Typen und lernen, wie Sie Daten korrekt einfügen, die den Validierungskriterien entsprechen. Am Ende dieses Labs werden Sie eine solide Vorstellung von den MongoDB-Datvalidierungs- und Fehlerbehandlungs-Techniken haben.

Skills Graph

Datentypen überprüfen

In diesem Schritt lernen Sie, wie Sie Datentypen in MongoDB überprüfen und validieren, was für die Aufrechterhaltung der Datenintegrität und die Fehlervermeidung in Ihrer Datenbank von entscheidender Bedeutung ist.

Das Verständnis von Datentypen in MongoDB

MongoDB unterstützt verschiedene Datentypen, darunter:

• String
• Integer
• Double
• Boolean
• Array
• Object
• Date
• ObjectId
• Null

Lassen Sie uns beginnen, indem wir die MongoDB-Shell öffnen und die Datentypvalidierung erkunden:

mongosh

Erstellen einer Beispielsamling mit Typvalidierung

Wir werden eine users-Sammlung mit bestimmten Datentypanforderungen erstellen:

use dataValidationLab

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,
               maximum: 120,
               description: "muss ein Integer zwischen 18 und 120 sein"
            },
            email: {
               bsonType: "string",
               pattern: "^.+@.+$",
               description: "muss eine gültige E-Mail-Adresse sein"
            }
         }
      }
   }
})

Zergliedern wir die Validierung:

• bsonType: "string" stellt sicher, dass das Feld ein String ist
• bsonType: "int" stellt sicher, dass das Feld ein Integer ist
• minimum und maximum setzen Bereichsbeschränkungen
• pattern validiert das E-Mail-Format

Versuchen, Dokumente mit falschen Typen einzufügen

Lassen Sie uns jetzt versuchen, Dokumente einzufügen, um unsere Validierung zu testen:

// Dies wird fehlschlagen, da der Alterstyp falsch ist
db.users.insertOne({
  name: "John Doe",
  age: "25", // String statt Integer
  email: "john@example.com"
});

// Dies wird ebenfalls fehlschlagen, da die E-Mail ungültig ist
db.users.insertOne({
  name: "Jane Smith",
  age: 30,
  email: "invalid-email"
});

Korrektes Dokument einfügen

So können Sie ein gültiges Dokument einfügen:

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

Beachten Sie die Verwendung von NumberInt(), um explizit einen Integer zu erstellen.

Erforderliche Felder validieren

In diesem Schritt bauen wir auf unsere vorherigen Datvalidierungsarbeiten auf, indem wir uns darauf konzentrieren, sicherzustellen, dass in unseren MongoDB-Dokumenten immer die erforderlichen Felder vorhanden sind.

Das Verständnis von erforderlichen Feldern

Erforderliche Felder sind wesentliche Informationen, die in jedem Dokument vorhanden sein müssen. Im vorherigen Schritt haben wir ein Validierungsschema mit erforderlichen Feldern erstellt. Jetzt werden wir untersuchen, wie diese Anforderungen erzwungen und validiert werden.

Fahren wir in unserer MongoDB-Shell fort:

mongosh

Wechseln Sie zu unserer bestehenden Datenbank:

use dataValidationLab

Definieren einer strengen Validierung für erforderliche Felder

Wir werden unsere bestehende users-Sammlung ändern, um eine strenge Validierung für erforderliche Felder durchzuführen:

db.runCommand({
  collMod: "users",
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["name", "age", "email", "registrationDate"],
      properties: {
        name: {
          bsonType: "string",
          description: "Name ist erforderlich und muss ein String sein"
        },
        age: {
          bsonType: "int",
          minimum: 18,
          maximum: 120,
          description:
            "Alter ist erforderlich und muss ein Integer zwischen 18 und 120 sein"
        },
        email: {
          bsonType: "string",
          pattern: "^.+@.+$",
          description:
            "E-Mail ist erforderlich und muss eine gültige E-Mail-Adresse sein"
        },
        registrationDate: {
          bsonType: "date",
          description:
            "Registrierungsdatum ist erforderlich und muss ein Datum sein"
        }
      }
    }
  },
  validationLevel: "strict"
});

Versuchen, Dokumente mit fehlenden Feldern einzufügen

Lassen Sie uns versuchen, Dokumente mit fehlenden erforderlichen Feldern einzufügen:

// Dies wird fehlschlagen, da das Registrierungsdatum fehlt
db.users.insertOne({
  name: "Bob Wilson",
  age: NumberInt(35),
  email: "bob@example.com"
});

// Dies wird ebenfalls fehlschlagen, da erforderliche Felder fehlen
db.users.insertOne({
  name: "Charlie Brown"
});

Korrektes Dokument einfügen

So können Sie ein Dokument einfügen, das alle Anforderungen erfüllt:

db.users.insertOne({
  name: "Emma Thompson",
  age: NumberInt(42),
  email: "emma@example.com",
  registrationDate: new Date()
});

Überprüfen von Validierungsfehlern

Um zu verstehen, warum Einfügungen fehlschlagen, bietet MongoDB Validierungsfehlermeldungen:

try {
  db.users.insertOne({
    name: "Incomplete User"
  });
} catch (error) {
  print("Validation Error:", error.message);
}

Dies wird Ihnen helfen, genau zu verstehen, welche erforderlichen Felder fehlen.

Ungültige Daten behandeln

In diesem Schritt lernen wir, wie wir ungültige Daten in MongoDB behandeln und verwalten, wobei wir uns auf das Erfassen von Fehlern, das Protokollieren und die Implementierung von Datvalidierungsstrategien konzentrieren.

Die Umgebung vorbereiten

Fahren wir in unserer MongoDB-Shell fort:

mongosh

Wechseln Sie zu unserer bestehenden Datenbank:

use dataValidationLab

Erstellen einer Sammlung zur Fehlerbehandlung

Wir werden eine neue Sammlung mit fortgeschrittener Validierung und Fehlerbehandlung erstellen:

db.createCollection("products", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["name", "price", "category"],
      properties: {
        name: {
          bsonType: "string",
          minLength: 2,
          maxLength: 100
        },
        price: {
          bsonType: ["double", "int"],
          minimum: 0,
          description: "Der Preis muss eine positive Zahl sein"
        },
        category: {
          enum: ["Electronics", "Clothing", "Books", "Food"],
          description: "Die Kategorie muss einer der vorgegebenen Werte sein"
        }
      }
    }
  },
  validationAction: "error"
});

Implementieren eines Fehlerbehandlungsmechanismus

Wir werden eine Funktion zur Behandlung von Einfügungen von ungültigen Daten erstellen:

function safeInsertProduct(product) {
  try {
    db.products.insertOne(product);
    print("Produkt erfolgreich eingefügt:", product.name);
  } catch (error) {
    print("Fehler beim Einfügen des Produkts:", error.message);

    // Protokollieren von ungültigen Daten in eine separate Sammlung
    db.invalidProducts.insertOne({
      product: product,
      errorMessage: error.message,
      timestamp: new Date()
    });
  }
}

Testen der Fehlerbehandlung

Lassen Sie uns unsere Fehlerbehandlung in verschiedenen Szenarien testen:

// Gültige Produkt-Einfügung
safeInsertProduct({
  name: "Smartphone",
  price: 599.99,
  category: "Electronics"
});

// Ungültiges Produkt - falscher Preistyp
safeInsertProduct({
  name: "Laptop",
  price: "1000", // String statt Zahl
  category: "Electronics"
});

// Ungültiges Produkt - ungültige Kategorie
safeInsertProduct({
  name: "T-Shirt",
  price: 29.99,
  category: "Accessories" // Nicht in den vorgegebenen Kategorien
});

// Ungültiges Produkt - kurzer Name
safeInsertProduct({
  name: "A",
  price: 10,
  category: "Books"
});

Überprüfen der Protokolle von ungültigen Daten

Lassen Sie uns die Protokolle von ungültigen Produkten überprüfen:

print("Protokoll von ungültigen Produkten:");
db.invalidProducts.find();

Best Practices für die Fehlerbehandlung

1. Validieren Sie immer die Daten vor der Einfügung
2. Verwenden Sie try-catch-Blöcke
3. Protokollieren Sie ungültige Daten für eine spätere Überprüfung
4. Implementieren Sie die Validierung auf Schemaebene
5. Verwenden Sie passende Validierungsaktionen

Datenprobleme beheben

In diesem Schritt lernen wir Techniken, um Datenprobleme in MongoDB zu identifizieren und zu beheben, wobei wir uns auf Datenbereinigung und Transformationsstrategien konzentrieren.

Die Umgebung vorbereiten

Fahren wir in unserer MongoDB-Shell fort:

mongosh

Wechseln Sie zu unserer bestehenden Datenbank:

use dataValidationLab

Erstellen einer Sammlung zur Datenbereinigung

Wir werden eine Sammlung mit möglicherweise problematischen Daten erstellen:

db.createCollection("customers", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["name", "email", "age"],
      properties: {
        name: {
          bsonType: "string",
          minLength: 2
        },
        email: {
          bsonType: "string",
          pattern: "^.+@.+$"
        },
        age: {
          bsonType: "int",
          minimum: 18,
          maximum: 120
        }
      }
    }
  }
});

// Fügen Sie einige Beispiel-Daten mit potenziellen Problemen hinzu
db.customers.insertMany([
  { name: "John Doe", email: "john@example", age: "35" },
  { name: "A", email: "invalid-email", age: 15 },
  { name: "Jane Smith", email: "jane@example.com", age: 25 }
]);

Funktion zur Datenbereinigung

Lassen Sie uns eine Funktion zur Bereinigung und Validierung von Kundendaten erstellen:

function cleanCustomerData() {
  // Finden und beheben von ungültigen Dokumenten
  const invalidCustomers = db.customers.find({
    $or: [
      { age: { $type: "string" } },
      { email: { $not: /^.+@.+$/ } },
      {
        name: { $exists: true, $expr: { $lt: [{ $strLenBytes: "$name" }, 2] } }
      }
    ]
  });

  invalidCustomers.forEach((customer) => {
    // Alter beheben: in Integer umwandeln
    const fixedAge =
      typeof customer.age === "string"
        ? parseInt(customer.age)
        : customer.age < 18
          ? 18
          : customer.age;

    // E-Mail beheben: Domain hinzufügen, wenn fehlend
    const fixedEmail = customer.email.includes("@")
      ? customer.email
      : `${customer.email}@example.com`;

    // Name beheben: kurze Namen auffüllen
    const fixedName =
      customer.name.length < 2 ? customer.name.padEnd(2, "X") : customer.name;

    // Aktualisieren des Dokuments mit korrigierten Daten
    db.customers.updateOne(
      { _id: customer._id },
      {
        $set: {
          age: NumberInt(fixedAge),
          email: fixedEmail,
          name: fixedName
        }
      }
    );

    print(`Behobener Kunde: ${customer.name}`);
  });

  // Überprüfen der bereinigten Daten
  print("Überprüfung der bereinigten Daten:");
  db.customers.find().forEach(printjson);
}

// Führen Sie die Bereinigungsfunktion aus
cleanCustomerData();

Datenvalidierung nach der Bereinigung

Lassen Sie uns überprüfen, ob die bereinigten Daten unseren Validierungskriterien entsprechen:

function validateCustomers() {
  const invalidCustomersCount = db.customers
    .find({
      $or: [
        { age: { $not: { $type: "int" } } },
        { age: { $lt: 18, $gt: 120 } },
        { email: { $not: /^.+@.+$/ } },
        {
          name: {
            $exists: true,
            $expr: { $lt: [{ $strLenBytes: "$name" }, 2] }
          }
        }
      ]
    })
    .count();

  print(`Anzahl verbleibender ungültiger Kunden: ${invalidCustomersCount}`);
  return invalidCustomersCount === 0;
}

validateCustomers();

Best Practices für die Datenbehebung

1. Validieren Sie immer vor und nach der Datenumwandlung
2. Verwenden Sie die Typumwandlung mit Sorgfalt
3. Legen Sie Standard- oder Mindestwerte für kritische Felder fest
4. Protokollieren Sie Datenänderungen für die Auditing
5. Erstellen Sie eine Sicherung vor einer großen Datenbereinigung

Schlechte Eingaben verhindern

In diesem letzten Schritt werden wir fortgeschrittene Techniken zur Verhinderung von schlechten Eingaben und zur Verbesserung der Datenintegrität in MongoDB durch umfassende Validierungsstrategien erkunden.

Die Umgebung vorbereiten

Fahren wir in unserer MongoDB-Shell fort:

mongosh

Wechseln Sie zu unserer bestehenden Datenbank:

use dataValidationLab

Erstellen eines robusten Validierungsschemas

Wir werden ein umfassendes Validierungsschema für eine 'registrations'-Sammlung erstellen:

db.createCollection("registrations", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["username", "email", "password", "registrationDate"],
      properties: {
        username: {
          bsonType: "string",
          minLength: 3,
          maxLength: 20,
          pattern: "^[a-zA-Z0-9_]+$",
          description:
            "Der Benutzername muss alphanumerisch sein und 3 - 20 Zeichen lang"
        },
        email: {
          bsonType: "string",
          pattern: "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$",
          description: "Muss eine gültige E-Mail-Adresse sein"
        },
        password: {
          bsonType: "string",
          minLength: 8,
          description: "Das Passwort muss mindestens 8 Zeichen lang sein",
          pattern:
            "^(?=.*[A-Za-z])(?=.*\\d)(?=.*[@$!%*#?&])[A-Za-z\\d@$!%*#?&]{8,}$"
        },
        registrationDate: {
          bsonType: "date",
          description: "Das Registrierungsdatum muss ein gültiges Datum sein"
        }
      }
    }
  },
  validationAction: "error",
  validationLevel: "strict"
});

Implementieren eines Middlewares zur Eingabeverhinderung

Erstellen Sie eine Funktion, um die Eingabe vor der Einfügung zu validieren:

function safeRegister(userData) {
  // Sanitize and validate input
  const sanitizedData = {
    username: userData.username.trim().toLowerCase(),
    email: userData.email.trim().toLowerCase(),
    password: userData.password,
    registrationDate: new Date()
  };

  // Additional custom validations
  if (sanitizedData.username.length < 3) {
    throw new Error("Benutzername zu kurz");
  }

  if (db.registrations.findOne({ username: sanitizedData.username })) {
    throw new Error("Benutzername existiert bereits");
  }

  if (db.registrations.findOne({ email: sanitizedData.email })) {
    throw new Error("E-Mail bereits registriert");
  }

  try {
    // Attempt to insert with MongoDB validation
    db.registrations.insertOne(sanitizedData);
    print("Registrierung erfolgreich:", sanitizedData.username);
  } catch (error) {
    print("Registrierung fehlgeschlagen:", error.message);

    // Log failed registration attempts
    db.registrationAttempts.insertOne({
      attemptData: userData,
      errorMessage: error.message,
      timestamp: new Date()
    });
  }
}

// Test input prevention
function testRegistrations() {
  const testCases = [
    // Valid registration
    {
      username: "john_doe",
      email: "john@example.com",
      password: "Strong!Pass123"
    },

    // Invalid cases
    { username: "ab", email: "invalid-email", password: "short" },
    { username: "john_doe!", email: "john@example.com", password: "WeakPass" },
    {
      username: "special_chars!",
      email: "invalid@email",
      password: "NoSpecialChar123"
    }
  ];

  testCases.forEach((testCase) => {
    print("\nTesting registration:");
    printjson(testCase);
    safeRegister(testCase);
  });
}

// Run registration tests
testRegistrations();

Überprüfen der Registrierungsversuche

Überprüfen Sie die protokollierten Registrierungsversuche:

print("Fehlgeschlagene Registrierungsversuche:");
db.registrationAttempts.find();

Best Practices für die Eingabeverhinderung

1. Verwenden Sie umfassende Schemavalidierung
2. Implementieren Sie die Eingabesanierung auf Serverseite
3. Verwenden Sie reguläre Ausdrücke für die strenge Validierung
4. Protokollieren und verfolgen Sie ungültige Eingabeversuche
5. Implementieren Sie zusätzliche benutzerdefinierte Validierungslogik

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie in MongoDB die Datentypen überprüfen und validieren, um die Datenintegrität zu gewährleisten und Fehler in Ihrer Datenbank zu vermeiden. Sie haben die verschiedenen von MongoDB unterstützten Datentypen untersucht, darunter String, Integer, Double, Boolean, Array, Object, Date, ObjectId und null. Sie haben eine Beispielusers-Sammlung mit spezifischen Anforderungen an den Datentyp erstellt, indem Sie beispielsweise sichergestellt haben, dass der Name ein String ist, das Alter eine Ganzzahl zwischen 18 und 120 ist und die E-Mail eine gültige E-Mail-Adresse ist. Sie haben auch gelernt, wie Sie ungültige Daten behandeln, indem Sie versuchen, Dokumente mit falschen Typen einzufügen und die Fehlermeldungen zu verstehen.

Schließlich haben Sie die Praxis des Einfügens von Dokumenten mit den richtigen Datentypen geübt, um sie erfolgreich der users-Sammlung hinzuzufügen.