Add Field to an Existing MongoDB Bson Filter in Java

1. Overview

MongoDB is a popular distributed, open-source NoSQL document storage engine. It’s basically a document database that stores data in a type of JSON format called BSON (Binary Javascript Object Notation). Documents stored in MongoDB as BSON data are grouped together into a collection.

In this tutorial, we’ll discuss the different approaches we can use to add a field to an existing MongoDB Bson Filter. We’ll then examine their corresponding implementations using the MongoDB Java driver.

2. Database Initialization

Before we move on, let’s first create a new database and a sample collection. We’ll use these to demonstrate all our code examples.

Let’s create a database named baeldung:

use baeldung;

This command will create a new, empty database named baeldung for us if it doesn’t already exist.

Further, let’s create a collection called pet inside the newly created database:

db.createCollection("pet");

With this, our sample baeldung database and pet collection are successfully set up.

Finally, let’s add some sample data to the pet collection:

db.pet.insertMany([
{
    "petId":"P1",
    "name":"Tom", 
    "age":3,
    "type":"Cat",
    "gender": "Female"
},
{ 
    "petId":"P2",
    "name":"Max", 
    "age":4,
    "type":"Dog",
    "gender": "Male"
},
{
    "petId":"P3",
    "name":"Milo", 
    "age":8,
    "type":"Dog",
    "gender": "Male"
}]);

Upon successful insertion, the above script would return a JSON result:

{
    "acknowledged" : true,
    "insertedIds" : [
        ObjectId("64007c0a2b07cc62bfe6accc"),
        ObjectId("64007c0a2b07cc62bfe6accd"),
        ObjectId("64007c0a2b07cc62bfe6acce")
    ]
}

Let’s now dive deep into understanding how a field can be added to an existing BSON Filter.

3. Adding a Field to an Existing Bson Filter

We’ll use Filters builders to add a field to an existing Filter. Builders are classes provided by the MongoDB Java driver that will help us construct BSON objects.

The Filters class in Java provides static factory methods for all the MongoDB query operators. Each of these methods will return an instance of the Bson type. We can then pass this Bson object to any method that expects a query filter.

Note that since Filters are immutable, we cannot directly edit them. We’ll have to create a new Bson Filter using the existing one by applying some filter operators.

Specifically, we’ll be using the Filters.and() method to perform the addition operation. The Filters.and() method basically creates a filter that performs a logical AND operation for the provided list of filters.

There are two ways in which we can achieve this:

1. Using BsonDocument
2. Using Filters

Let’s now take a deeper dive into each of the above approaches.

3.1. Using BsonDocument

With this approach, we’ll first convert the existing Bson Filter to a BsonDocument. Then, we’ll append the required field to this BsonDocument.

First, let’s say we have a filter that returns all pet collection documents where the pet’s type is “Dog”:

Bson existingFilter = eq("type", "Dog");
BsonDocument existingBsonDocument = existingFilter.toBsonDocument(BsonDocument.class, MongoClient.getDefaultCodecRegistry());

We converted the filter to a BsonDocument type.

Second, let’s say we now want to add a field to this filter such that the pet’s age exceeds 5. We’ll create a Bson filter for this field and convert it into a BsonDocument object:

Bson newFilter = gt("age", 5);
BsonDocument newBsonDocument = newFilter.toBsonDocument(BsonDocument.class, MongoClient.getDefaultCodecRegistry());

Finally, we append the new field to the existing BsonDocument:

existingBsonDocument.append("age", newBsonDocument.get("age"));

FindIterable<Document> documents = collection.find(existingBsonDocument);

MongoCursor<Document> cursor = documents.iterator();
while (cursor.hasNext()) {
    System.out.println(cursor.next());
}

The BsonDocument.append() method accepts a key and a BsonValue, which will then be appended to the existing BsonDocument. We can then use the resulting BsonDocument to query documents from the MongoDB collection.

3.2. Using Filters

This approach directly uses Filters to add fields without converting them first to a BsonDocument.

Let’s say we have a filter that returns all pet collection documents where the pet’s type is “Dog” and the pet’s gender is “Male”:

Bson exisingFilter = and(eq("type", "Dog"), eq("gender", "Male"));
FindIterable<Document> documents = collection.find(exisingFilter);

MongoCursor<Document> cursor = documents.iterator();
while (cursor.hasNext()) {
    System.out.println(cursor.next());
}

The above snippet would print all the pet collection documents matching our criteria:

Document{{_id=64007c0a2b07cc62bfe6accd, petId=P2, name=Max, age=4.0, type=Dog, gender=Male}}
Document{{_id=64007c0a2b07cc62bfe6acce, petId=P3, name=Milo, age=8.0, type=Dog, gender=Male}}

Let’s say we now want to modify this filter to add a condition where the pet’s age is greater than 5. We make use of the Filters.and() method that accepts the existing filter and the new field to be added as its parameters.

Let’s check out the Java implementation code:

Bson existingFilter = and(eq("type", "Dog"), eq("gender", "Male"));

Bson newFilter = and(existingFilter, gt("age", 5));
FindIterable<Document> documents = collection.find(newFilter);

MongoCursor<Document> cursor = documents.iterator();
while (cursor.hasNext()) {
    System.out.println(cursor.next());
}

The above snippet will create a new Bson filter by adding the required field with a condition to the existing filter. We can use the new field along with any of the available filter operators in MongoDB. The snippet would now print all the pet collection documents where the type equals “Dog”, the gender equals “Male”, and the age is greater than 5:

Document{{_id=64007c0a2b07cc62bfe6acce, petId=P3, name=Milo, age=8.0, type=Dog, gender=Male}}

This is the most convenient approach for adding a field to an existing Bson Filter.

4. Conclusion

In this article, we’ve seen various ways to add a field to an existing Bson Filter in MongoDB. We then discussed these use cases using the corresponding Java driver code implementation.

With the Java driver code, we first looked at the implementation using the BsonDocument class. Then, we learned to directly implement the same using the Filters class.