- In MongoDB, schema validation is a way to ensure that documents inserted into a collection adhere to a specific structure or pattern. This is done by defining rules or constraints using a JSON Schema. Schema validation is not mandatory in MongoDB because of its flexible schema model, but it can be helpful when you want to enforce data integrity or avoid errors due to improperly formatted data.
- Here is a detailed breakdown of schema validation in MongoDB:
- Schema validation defines rules that must be followed when inserting, updating, or replacing documents in a collection. It ensures that the documents conform to a specific structure, type, or other constraints, which helps in maintaining data quality.
- JSON Schema: MongoDB’s schema validation is based on the JSON Schema standard. JSON Schema provides a way to describe the structure of JSON data.
- Validation Level: Defines how strictly the rules will be enforced.
- 'strict': Validation is applied for both inserts and updates.
- 'moderate': Validation is applied only for new documents and updates that affect fields mentioned in the schema.
- Validation Action: Defines the behavior when documents don't meet the validation rules.
- 'error': Rejects documents that don’t follow the validation rules.
- 'warn': Allows invalid documents but logs a warning.
- Validation Rules: You define rules (constraints) that documents must adhere to. These could include:
- Data types (e.g., string, number, object)
- Required fields
- Field value constraints (e.g., regex, minimum/maximum values)
- Nested object validation
- Schema validation is usually done during collection creation, but it can also be applied to an existing collection.
- Let’s say we are creating a 'users' collection where each document must have the following structure:
- 'name': a required string field.
- 'age': an optional integer field that must be between 18 and 60.
- 'email': a required string field that must match a valid email format.
- 'address': an object containing:
- 'city': a required string field.
- 'zipcode': a required string field with a 5-digit format.
- Here’s how we can define schema validation for this collection:
db.createCollection("users", {
validator: {
$jsonSchema: {
bsonType: "object",
required: ["name", "email", "address"],
properties: {
name: {
bsonType: "string",
description: "must be a string and is required"
},
age: {
bsonType: "int",
minimum: 18,
maximum: 60,
description: "must be an integer in the range 18 to 60"
},
email: {
bsonType: "string",
pattern: "^.+@.+$",
description: "must be a valid email and is required"
},
address: {
bsonType: "object",
required: ["city", "zipcode"],
properties: {
city: {
bsonType: "string",
description: "must be a string and is required"
},
zipcode: {
bsonType: "string",
pattern: "^[0-9]{5}$",
description: "must be a 5-digit string and is required"
}
}
}
}
}
},
validationLevel: "strict",
validationAction: "error"
});
- 'bsonType: "object"': This indicates that each document in the 'users' collection must be a BSON object (i.e., a document).
- 'required: ["name", "email", "address"]': This specifies that the fields 'name', 'email', and 'address' must be present in every document.
- Field Properties:
- 'name': Must be a string and is required.
- 'age': Must be an integer, and its value must fall between 18 and 60, but it's optional.
- 'email': Must be a string, and it must match a basic email pattern ('^.+@.+$').
- 'address': Must be an object containing the fields 'city' and 'zipcode'. Each of these fields must be a string, and 'zipcode' must follow a 5-digit format.
- Strict: All insert and update operations will be checked against the validation rules. For example, inserting a document like:
db.users.insertOne({
name: "John Doe",
age: 30,
email: "john@example.com",
address: { city: "New York", zipcode: "10001" }
});
- would succeed because it meets the validation rules.
- But, inserting this:
db.users.insertOne({
name: "Jane Doe",
age: 17, // invalid age
email: "janeexample.com", // invalid email format
address: { city: "Los Angeles", zipcode: "9001" } // invalid zipcode
});
- would throw an error because 'age' is less than 18, the email is not valid, and the zipcode is not 5 digits.
- Moderate: Only new documents or updated fields that are mentioned in the schema will be validated. So, if you are updating just the 'name' of an existing document, it won’t validate other fields like 'age' or 'email'.
- Error: Invalid documents will be rejected, and an error message will be thrown. This is helpful when you want to enforce strict data integrity.
- Warn: The operation will still succeed, but MongoDB will log a warning that the document does not conform to the validation rules. This is useful for transitioning to schema validation without immediately enforcing strict validation.
- If you already have a collection, you can add schema validation using the 'collMod' command:
db.runCommand({
collMod: "users",
validator: {
$jsonSchema: {
bsonType: "object",
required: ["name", "email", "address"],
properties: {
name: {
bsonType: "string",
description: "must be a string and is required"
},
email: {
bsonType: "string",
pattern: "^.+@.+$",
description: "must be a valid email and is required"
}
}
}
},
validationLevel: "strict",
validationAction: "error"
});
- Data Quality: Ensure that all documents conform to a set of rules, preventing incorrect data entry.
- Type Enforcement: Enforce types like 'string', 'number', 'date', etc., so that data can be relied upon during processing.
- Range or Format Constraints: Ensure fields like 'age' fall within a specific range or that fields like 'email' or 'zipcode' follow a specific format.
- Required Fields: Make sure certain fields are always present in a document.
- Define schema validation during collection creation to enforce clean data from the beginning.
- Use moderate validation during data migration or when transitioning to a more structured schema.
- Use the 'warn' action for testing new validation rules without disrupting operations.
- Schema validation in MongoDB is a powerful feature that lets you enforce structure in a flexible, NoSQL database. It helps ensure data integrity while still maintaining the flexibility that MongoDB is known for.