MongoDB validations refer to the mechanisms used to ensure that data stored in a MongoDB database conforms to certain rules or constraints. This is crucial for maintaining data integrity and consistency. MongoDB provides various validation features that can be applied to collections to enforce data quality rules.

Key Concepts of MongoDB Validations

1. Schema Validation

Schema Validation allows you to define rules for the structure of documents within a collection. This helps ensure that documents meet specific criteria before they are inserted or updated in the database.

1. Validation Rules:

   • You can define validation rules using JSON Schema, a standard for specifying document structure and constraints.
   • Validation rules can include data types, required fields, minimum and maximum values, string lengths, and more.

2. Validation Levels:

   • Strict: Documents must fully comply with the schema validation rules. If a document does not meet the criteria, the operation (insert or update) will fail.
   • Moderate: Documents are validated only when they are inserted or updated. If a document does not meet the validation rules, it is rejected, but existing documents that do not match the schema are not affected.

3. Defining Validation Rules:

   • Validation rules are defined using the validationAction and validationLevel options when creating or modifying a collection.

   Example of defining schema validation rules using JSON Schema:

   db.createCollection("myCollection", {
     validator: {
       $jsonSchema: {
         bsonType: "object",
         required: ["name", "age"],
         properties: {
           name: {
             bsonType: "string",
             description: "Name must be a string and is required"
           },
           age: {
             bsonType: "int",
             minimum: 0,
             description: "Age must be an integer greater than or equal to 0 and is required"
           }
         }
       }
     },
     validationAction: "warn", // Use "error" for strict validation
     validationLevel: "moderate" // Use "strict" for strict validation
   });
   

2. Document Validation

Document Validation ensures that documents adhere to the defined schema before being inserted or updated in a collection.

1. Validating Inserts and Updates:

   • When you insert or update a document, MongoDB checks whether the document meets the schema validation rules.
   • If a document does not meet the rules, the operation is either rejected or a warning is issued, depending on the validation action.

2. Updating Validation Rules:

   • You can modify the validation rules for an existing collection using the collMod command.

   Example of updating validation rules:

   db.runCommand({
     collMod: "myCollection",
     validator: {
       $jsonSchema: {
         bsonType: "object",
         required: ["name"],
         properties: {
           name: {
             bsonType: "string",
             description: "Name must be a string and is required"
           }
         }
       }
     }
   });
   

3. Custom Validators

Custom Validators allow you to define more complex validation logic beyond what is possible with JSON Schema. You can use MongoDB’s aggregation framework and other operators to create custom validation rules.

1. Using $expr:

   • The $expr operator allows you to use aggregation expressions in validation rules. This provides flexibility for more advanced validation scenarios.

   Example of a custom validator:

   db.createCollection("myCollection", {
     validator: {
       $expr: {
         $and: [
           { $gt: [{ $strLenCP: "$name" }, 3] }, // Name must have more than 3 characters
           { $gte: ["$age", 18] } // Age must be 18 or older
         ]
       }
     },
     validationAction: "error",
     validationLevel: "strict"
   });
   

4. Index Validation

Index Validation ensures that indexes are properly maintained and used. MongoDB performs index validation to verify that index definitions are correct and that indexes are used efficiently for query operations.

1. Index Creation:

   • When you create an index, MongoDB validates the index definition to ensure that it adheres to index creation rules.

   Example of creating an index:

   db.myCollection.createIndex({ name: 1 }); // Create an ascending index on the "name" field
   

2. Index Management:

   • MongoDB provides tools to manage and validate existing indexes, including checking index usage and performance.

   Example of listing indexes:

   db.myCollection.getIndexes();
   

Summary

MongoDB Validations provide mechanisms to ensure that data in a database conforms to specific rules and constraints, enhancing data integrity and consistency. Schema validation using JSON Schema allows you to define and enforce document structure rules, while custom validators offer flexibility for complex validation logic. Document validation ensures that insert and update operations comply with defined rules, and index validation ensures that indexes are properly maintained and utilized. Proper use of these validation features helps maintain a robust and reliable MongoDB database.