Java MongoDB Deleting a Document to Database

Of the four basic database operations (i.e. CRUD), delete operations are those that remove documents from a collection in MongoDB. In Java MongoDB API, you can use collection.remove() to delete document from collection.

If we want to remove the document from the collection ’employees’ which contains the empId “10001” the following mongodb command can be used :

view plainprint?

1. >db.employees.remove( { “empId” : “10001” } )

Use the remove() method to delete documents from a collection. The remove() method has the following syntax:

view plainprint?

1. db.collection.remove( <query>, <justOne> )

Corresponding operation in SQL
The remove() method is analogous to the DELETE statement, and:

the <query> argument corresponds to the WHERE statement, and
the <justOne> argument takes a Boolean and has the same affect as LIMIT 1.

remove() deletes documents from the collection. If you do not specify a query, remove() removes all documents from a collection, but does not remove the indexes.

If we want to remove all data from the collection ’employees’ the following mongodb command can be used :

view plainprint?

1. >db.employees.remove( { } )

For testing the Remove function first we insert 10 documents to employees collection

view plainprint?

1. for (int i=1001; i <= 10010; i++) {
2.  collection.insert(new BasicDBObject().append(“empId”, i));
3. }

DBCollection.remove()- 1. Get first document and delete it. In this case, empId = 10001 is deleted.

view plainprint?

1. DBObject doc = collection.findOne(); //get first document
2. collection.remove(doc);

2. Puts query data in a BasicDBObject object. In this case, empId = 10002 is deleted.

view plainprint?

1. BasicDBObject document = new BasicDBObject();
2. document.put(“empId”, 10002);
3. collection.remove(document);

Query like this only delete empId= 3.

view plainprint?

1. BasicDBObject document = new BasicDBObject();
2.  document.put(“empId”, 10002);
3.  document.put(“empId”, 10003); //override above value 10002
4.  collection.remove(document);

Nice try, but query like this will not work, it will delete NOTHING.

view plainprint?

1. BasicDBObject document = new BasicDBObject();
2.  List<Integer> list = new ArrayList<Integer>();
3.  list.add(10007);
4.  list.add(10008);
5.  document.put(“empId”, list);
6.  collection.remove(document);

3. Use BasicDBObject directly. In this case, empId = 10002 is deleted.

view plainprint?

1. collection.remove(new BasicDBObject().append(“empId”, 10002));

4. Puts a “greater than” operator in a BasicDBObject object. In this case, empId = 10003 is deleted.

view plainprint?

1. BasicDBObject query = new BasicDBObject();
2. query.put(“empId”, new BasicDBObject(“$gt”, 10002));
3. collection.remove(query);

5. Puts a “in” operator in a BasicDBObject object, construct the query in ArrayList. In this case, empId = 10004 and empId = 10005 are deleted.

view plainprint?

1. BasicDBObject query = new BasicDBObject();
2. List<Integer> list = new ArrayList<Integer>();
3. list.add(10004);
4. list.add(10005);
5. query.put(“number”, new BasicDBObject(“$in”, list));
6. collection.remove(query);

6. Use cursor to delete all available document.

view plainprint?

1. DBCursor cursor = collection.find();
2. while (cursor.hasNext()) {
3.  collection.remove(cursor.next());
4. }

7. Pass an empty BasicDBObject, and cause it delete all available document.

view plainprint?

1. collection.remove(new BasicDBObject());

More Conditional Operators-
$all-
$all selects the documents where the field holds an array and contains all elements (e.g. <value>, <value1>, etc.) in the array. Consider the following example:

view plainprint?

1. db.inventory.find( { tags: { $all: [ “appliances”, “school”, “book” ] } } )

$lt- 
Syntax: {field: {$lt: value} } $lt selects the documents where the value of the field is less than (i.e. <) the specified value. Consider the following example:

view plainprint?

1. db.inventory.find( { qty: { $lt: 20 } } )

This query will select all documents in the inventory collection where the qty field value is less than 20.

$gt-
Syntax: {field: {$gt: value} }
$gt selects those documents where the value of the field is greater than (i.e. >) the specified value.

Consider the following example:

view plainprint?

1. db.inventory.find( { qty: { $gt: 20 } } )

This query will select all documents in the inventory collection where the qty field value is greater than 20.

Now lets see the full example on the following java file and its output.

view plainprint?

1. package com.dineshonjava.mongo.test;
3. import java.net.UnknownHostException;
4. import java.util.ArrayList;
5. import java.util.List;
7. import com.mongodb.BasicDBObject;
8. import com.mongodb.DB;
9. import com.mongodb.DBCollection;
10. import com.mongodb.DBCursor;
11. import com.mongodb.DBObject;
12. import com.mongodb.Mongo;
13. import com.mongodb.MongoException;
15. /**
16.  * @author Dinesh Rajput
17.  *
18.  */
19. public class DeleteDocumentDemo {
21.  /**
22.   * @param args
23.   */
24.  public static void main(String[] args) {
25.  try {
26.   // connect to mongoDB, IP and port number
27.   Mongo mongo = new Mongo(“localhost”, 27017);
29.   // get database from MongoDB,
30.   // if database doesn’t exists, mongoDB will create it automatically
31.   DB db = mongo.getDB(“dineshonjavaDB”);
33.   // get a single collection
34.   DBCollection collection = db.getCollection(“employee”);
36.   //insert empId 10001 to 10010 for testing
37.   for (int i=10001; i <= 10010; i++) {
38.   collection.insert(new BasicDBObject().append(“empId”, i));
39.   }
41.   //remove empId = 10001
42.   DBObject doc = collection.findOne(); //get first document
43.   collection.remove(doc);
45.   //remove empId = 10002
46.   BasicDBObject document = new BasicDBObject();
47.   document.put(“empId”, 10002);
48.   collection.remove(document);
50.   //remove empId = 10003
51.   collection.remove(new BasicDBObject().append(“empId”, 10003));
53.   //remove empId > 10009 , means delete empId = 10010
54.   BasicDBObject query = new BasicDBObject();
55.   query.put(“empId”, new BasicDBObject(“$gt”, 10009));
56.   collection.remove(query);
58.   //remove empId = 10004 and 10005
59.   BasicDBObject query2 = new BasicDBObject();
60.   List<Integer> list = new ArrayList<Integer>();
61.   list.add(10004);
62.   list.add(10005);
63.   query2.put(“empId”, new BasicDBObject(“$in”, list));
64.   collection.remove(query2);
66.   //remove all documents
67.   //DBCursor cursor = collection.find();
68.   //while (cursor.hasNext()) {
69.   // collection.remove(cursor.next());
70.   //}
72.   //remove all documents , no query means delete all
73.   //collection.remove(new BasicDBObject());
75.   //print out the document
76.   DBCursor cursor = collection.find();
77.             while(cursor.hasNext()) {
78.                  System.out.println(cursor.next());
79.             }
81.             System.out.println(“Done”);
83.   } catch (UnknownHostException e) {
84.    e.printStackTrace();
85.   } catch (MongoException e) {
86.    e.printStackTrace();
87.   }
89.  }
91. }

If everything is fine then run as a java application and you will get the following output on the console.

output:
{ “_id” : { “$oid” : “51054d998217798d9fc43545”} , “empId” : 10006}
{ “_id” : { “$oid” : “51054d998217798d9fc43546”} , “empId” : 10007}
{ “_id” : { “$oid” : “51054d998217798d9fc43547”} , “empId” : 10008}
{ “_id” : { “$oid” : “51054d998217798d9fc43548”} , “empId” : 10009}
Done