MongoEngine is a Python Object-Document Mapper (ODM) that provides a high-level API for interacting with MongoDB. It allows for easy modeling and manipulation of data, making it a popular choice for working with MongoDB in Python applications.

One of the key features of MongoEngine is the ability to validate fields in MongoDB documents. Field validation ensures that the data stored in the database meets certain criteria, making it more reliable and consistent. In this blog post, we will explore how to perform field validation using MongoEngine in Python.

Installation

Before we dive into field validation, let’s quickly install MongoEngine using pip:

pip install mongoengine

Defining a Document

To define a MongoDB document with field validation, we need to create a Python class that inherits from the mongoengine.Document class. Let’s consider an example where we have a User document with the following fields:

• name (String)
• age (Integer, between 18 and 65)
• email (String, with a valid email format)

Here’s how we can define the User document in MongoEngine:

from mongoengine import Document, StringField, IntField, EmailField, ValidationError

class User(Document):
    name = StringField(required=True)
    age = IntField(min_value=18, max_value=65)
    email = EmailField()

    def validate(self):
        if not self.name.isalpha():
            raise ValidationError("Name can only contain alphabetic characters")

        super().validate()

In the code above, we imported the necessary field types from mongoengine. We defined the name field as a StringField with required=True, which means it must have a value. The age field is an IntField with min_value and max_value attributes, restricting it to be between 18 and 65. The email field is an EmailField, which automatically validates the input against a regular expression pattern for email addresses.

The validate method is a built-in mongoengine method that allows you to perform additional custom validation logic. In this example, we check if the name contains only alphabetic characters and raise a ValidationError if not. Finally, we call the super validation to run the default validation process.

Saving Documents

To save a document, we first create an instance of the User class and set its field values. We can then call the save method to store it in the database. Here’s an example:

user = User(name="John Doe", age=25, email="johndoe@example.com")
user.save()

If any of the field values violate the validation rules, a ValidationError will be raised, preventing the document from being saved.

Querying Documents

We can also perform query operations on documents that have field validation. For example, to find all users whose age is greater than or equal to 21, we can use the User.objects attribute along with the gte (greater than or equal to) operator:

users = User.objects(age__gte=21)

Conclusion

In this blog post, we explored how to perform field validation using MongoEngine in Python. We saw how to define a document with field validation rules, save documents while enforcing the rules, and perform queries on validated documents.

Field validation in MongoDB helps maintain data integrity and consistency. It ensures that the stored data meets the desired criteria, reducing the chances of errors and improving the overall quality of the database.

With MongoEngine’s intuitive API and powerful validation features, working with MongoDB in Python becomes a breeze. So the next time you’re working with MongoDB, consider using MongoEngine for seamless document validation.