CODEWITHSUNDEEP
spring-data-mongodb
msameep
msameep

Reputation: 131

Spring Data Mongodb Bulk Operation Example

Can some one please point me a complete example of Spring Data Mongodb DB bulk operation example.

I am trying to switch to bulk updates using spring data mongodb. Not able to find a good example.

Thank you.

Upvotes: 8

Views: 18451

Answers (4)

Prasanth Rajendran
Prasanth Rajendran

Reputation: 5512

There are some elegant ways to perform the bulkOperations in Spring data mongodb refer

An excerpt from the reference

Starting in version 2.6, MongoDB servers support bulk write commands for insert, update, and delete in a way that allows the driver to implement the correct semantics for BulkWriteResult and BulkWriteException.
There are two types of bulk operations, ordered and unordered bulk operations.

  • Ordered bulk operations execute all the operations in order and error out on the first write error.
  • Unordered bulk operations execute all the operations and report any errors. Unordered bulk operations do not guarantee the order of execution.

Sample bulk operation covering most of the features

import com.mongodb.BasicDBObject;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.model.BulkWriteOptions;
import com.mongodb.client.model.DeleteOneModel;
import com.mongodb.client.model.InsertOneModel;
import com.mongodb.client.model.ReplaceOneModel;
import com.mongodb.client.model.UpdateOneModel;
import com.mongodb.client.model.Updates;
import com.mongodb.client.model.WriteModel;
import org.bson.Document;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoOperations;
import org.springframework.data.mongodb.core.aggregation.Fields;
import org.springframework.stereotype.Repository;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import static org.springframework.data.mongodb.core.aggregation.Fields.UNDERSCORE_ID;

@Repository
public class BulkUpdateDemoRepository {

    @Autowired
    private MongoOperations mongoOperations;

    public void bulkUpdate() {
        MongoCollection<Document> postsCollection = mongoOperations.getCollection("posts");
        //If no top-level _id field is specified in the documents, the Java driver automatically
        // adds the _id field to the inserted documents.
        Document document = new Document("postId", 1)
                .append("name", "id labore ex et quam laborum")
                .append("email", "[email protected]")
                .append("secondary-email", "[email protected]")
                .append("body", "laudantium enim quasi est");
        List<WriteModel<Document>> list = Arrays.asList(
                    //Inserting the documents
                    new InsertOneModel<>(document),
                    //Adding a field in document
                    new UpdateOneModel<>(new Document(UNDERSCORE_ID, 3),
                                new Document().append("$set",
                                       new BasicDBObject("postDate", new Date()))),
                    //Removing field from document
                    new UpdateOneModel<>(new Document(Fields.UNDERSCORE_ID, 4),
                                            Updates.unset("secondary-email")),
                    //Deleting document
                    new DeleteOneModel<>(new Document(Fields.UNDERSCORE_ID, 2)),
                    //Replacing document
                    new ReplaceOneModel<>(new Document(Fields.UNDERSCORE_ID, 3),
                                new Document(Fields.UNDERSCORE_ID, 3)
                         .append("secondary-email", "[email protected]")));

        //By default bulk Write operations is ordered because the BulkWriteOptions'
        // ordered flag is true by default, by disabling that flag we can perform 
       // the Unordered bulk operation
        
        //ordered execution
        postsCollection.bulkWrite(list);

      //2. Unordered bulk operation - no guarantee of order of operation - disabling  
        // BulkWriteOptions' ordered flag to perform the Unordered bulk operation
        postsCollection.bulkWrite(list, new BulkWriteOptions().ordered(false));
    }
}

Upvotes: -1

Dila Gurung
Dila Gurung

Reputation: 1764

I think following code is the simple example that anybody can uderstand

Note : Ensure that custom mongo repository is correctly configured.

@Autowired
MongoTemplate mongoTemplate;

public int bulkUpdate(String member)
{
    Query query = new Query();
    Criteria criteria=Criteria.where("column name").is(member);
    query.addCriteria(criteria);
    Update update = new Update();
    update.set("column name",true);
    return mongoTemplate.bulkOps(BulkOperations.BulkMode.UNORDERED, YourModelClass.class,"name of collection").updateMulti(query,update).execute().getModifiedCount();
}

Upvotes: -1

abhinav kumar
abhinav kumar

Reputation: 1803

Sharing the code for bulk operations which worked for me

BulkOperations bulkOps = mongoTemplate.bulkOps(BulkMode.UNORDERED, Person.class);
for(Person person : personList) {
    Query query = new Query().addCriteria(new Criteria("id").is(person.getId()));
    Update update = new Update().set("address", "new Address as per requirement");
    bulkOps.updateOne(query, update);
}
BulkWriteResult results = bulkOps.execute();

Upvotes: 6

Lucia
Lucia

Reputation: 855

BulkOprations in Spring data mongodb uses bulkWrite() from mongodb.
From mongoDB documentation ->

MOngoDbDocumention

So When you want to update many entities with different updated in one query you can do that via this bulkOps.

Let us see an example eventhough it may not be an perfect one. Lets consider you have an Employee Collection with employees working in a company. Now After appraisal there will be change in salary for all the employees, and each employee salary change will be different and let's pretend there is no percentage wise hike involved and if you want to update the changes in one go you can use bulkOps.

import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.BulkOperations;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.data.util.Pair;

public class Example {
    @Autowired
    MongoTemplate mongoTemplate;
    public int bulkUpdateEmployee(List<Pair<Query, Update>> updates){
        return mongoTemplate.bulkOps(BulkOperations.BulkMode.UNORDERED,"employees",Employee.class).updateMulti(updates).execute().getModifiedCount();
    }
}

--------------Here we can prepare the pair of query and update from ------- -------for each employee-> ---"query" - id of employee is blabla ---"update"- set salary to xxx

Upvotes: 5

Related Questions