Valider les données MongoDB

Introduction

Dans ce laboratoire, vous apprendrez les bases de la validation des données dans MongoDB. La validation des données est une fonctionnalité cruciale qui permet de maintenir l'intégrité et la cohérence de vos données en garantissant que tous les documents d'une collection respectent une structure et des règles spécifiques. Vous apprendrez à créer des collections avec des règles de validation, à tester ces règles en tentant d'insérer des données valides et invalides, et à modifier les règles de validation sur une collection existante. À la fin de ce laboratoire, vous serez en mesure d'appliquer la qualité des données directement dans votre base de données MongoDB.

Créer une collection avec validation de schéma

Dans cette première étape, vous allez vous connecter au serveur MongoDB et créer une nouvelle collection avec des règles de validation spécifiques. Ces règles définiront les types de données attendus et les contraintes pour les champs de vos documents.

Tout d'abord, ouvrez le MongoDB Shell (mongosh) pour interagir avec votre base de données. Ce shell interactif est votre outil principal pour gérer MongoDB.

mongosh

Une fois dans le shell, vous verrez une invite telle que test>. Cela indique que vous êtes connecté à la base de données par défaut test. Créons et basculons vers une nouvelle base de données nommée dataValidationLab.

use dataValidationLab

Maintenant, créons une collection users. Lors de la création de la collection, nous inclurons un document validator qui utilise $jsonSchema pour définir nos règles.

db.createCollection("users", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["name", "age", "email"],
      properties: {
        name: {
          bsonType: "string",
          description: "must be a string and is required"
        },
        age: {
          bsonType: "int",
          minimum: 18,
          description: "must be an integer >= 18 and is required"
        },
        email: {
          bsonType: "string",
          pattern: "^.+@.+$",
          description: "must be a valid email address and is required"
        }
      }
    }
  }
});

Après avoir exécuté la commande, vous devriez voir une sortie indiquant le succès :

{ "ok": 1 }

Décomposons le validateur :

• bsonType: "object" : La racine du document doit être un objet.
• required: ["name", "age", "email"] : Les champs name, age et email doivent être présents dans chaque document.
• properties : Cet objet définit les règles pour les champs individuels.
  • name : Doit être une string.
  • age : Doit être un int (entier) avec une valeur minimum de 18.
  • email : Doit être une string qui correspond à l'expression régulière pattern, qui vérifie un format d'e-mail basique.

Vous avez maintenant créé avec succès une collection avec des règles de validation de données. Dans la prochaine étape, vous testerez ces règles.

Tester la validation en insérant des documents

Maintenant que votre collection users possède des règles de validation, testons-les. Vous allez tenter d'insérer plusieurs documents : certains qui violent les règles et un qui s'y conforme. Cela vous aidera à comprendre comment MongoDB applique le schéma.

Tout d'abord, essayons d'insérer un document avec un type de données incorrect pour le champ age. Nous fournirons une chaîne "25" au lieu d'un entier.

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

Cette opération échouera. MongoDB rejettera le document et retournera une WriteError car le champ age ne satisfait pas l'exigence bsonType: "int". Le message d'erreur contiendra des détails sur l'échec de la validation.

MongoServerError: Document failed validation

Ensuite, essayons d'insérer un document auquel il manque un champ requis, email.

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

Cela échouera également car le champ email est listé dans le tableau required de notre validateur. Vous recevrez une WriteCommandError similaire.

Enfin, insérons un document qui respecte toutes les règles. Le name et l'email sont des chaînes de caractères, et l'age est un entier supérieur ou égal à 18.

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

Cette fois, la commande réussira, et vous verrez un message de confirmation avec l'_id du nouveau document inséré.

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

Pour confirmer que le document valide a été ajouté, vous pouvez interroger la collection.

db.users.find();

La sortie affichera le document qui a réussi la validation.

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

Modifier un validateur existant

Les exigences de votre application peuvent changer avec le temps, et vous pourriez avoir besoin de mettre à jour vos règles de validation. Dans cette étape, vous apprendrez comment modifier le validateur d'une collection existante en utilisant la commande collMod et tester ensuite les nouvelles règles.

Supposons que nous voulions ajouter un nouveau champ status à notre collection users. Ce champ doit être une chaîne de caractères et ne peut avoir que l'une des deux valeurs suivantes : "active" ou "inactive".

Nous utilisons la commande collMod (collection modify) pour appliquer le nouveau validateur.

db.runCommand({
  collMod: "users",
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["name", "age", "email", "status"],
      properties: {
        name: {
          bsonType: "string",
          description: "must be a string and is required"
        },
        age: {
          bsonType: "int",
          minimum: 18,
          description: "must be an integer >= 18 and is required"
        },
        email: {
          bsonType: "string",
          pattern: "^.+@.+$",
          description: "must be a valid email address and is required"
        },
        status: {
          enum: ["active", "inactive"],
          description: "can only be one of the enum values and is required"
        }
      }
    }
  }
});

La commande retournera { "ok": 1 } en cas de succès. Nous avons maintenant mis à jour le validateur pour exiger le champ status et restreindre sa valeur en utilisant le mot-clé enum.

Maintenant, testons la nouvelle règle. Essayez d'insérer un document avec un statut invalide.

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

Cela échouera car "pending" ne figure pas dans la liste enum pour le champ status. Ensuite, insérez un document qui respecte les règles mises à jour.

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

Cette insertion réussira. Pour voir tous les documents de votre collection, exécutez à nouveau find().

db.users.find();

Vous verrez maintenant les documents d'Alice et de Bob. Notez que le document d'Alice, inséré avant le changement de règle, ne possède pas le champ status. Par défaut, la validation ne s'applique pas aux documents existants tant qu'ils ne sont pas modifiés.

Résumé

Dans ce laboratoire, vous avez appris les techniques essentielles pour implémenter la validation des données dans MongoDB. Vous avez commencé par créer une collection avec un validateur $jsonSchema pour appliquer les types de données, les champs requis et les contraintes de valeur. Vous avez ensuite testé ces règles en tentant d'insérer des documents invalides et valides, en observant comment MongoDB rejette les données qui ne sont pas conformes au schéma. Enfin, vous avez appris à modifier les règles de validation d'une collection existante à l'aide de la commande collMod pour vous adapter aux nouvelles exigences. Ces compétences sont fondamentales pour construire des applications robustes et maintenir une haute qualité des données dans vos bases de données MongoDB.