Mongodb | Kevin Chisholm

Apr102018 by dcmNo Comments

MongoDB Shell vs MongoDB Node.JS Driver

The mongo Shell and the MongoDB Node.JS Driver both provide a way to interact with a Mongo database. There are fairly significant differences in how they work, however, as well as the benefits they provide.

There are multiple ways to interact with MongoDB, and two of those are with the mongo shell and the MongoDB Node.js driver. Now at this point it might make sense to ask which approach is best. Well, the answer really depends on the scenario. So, perhaps the first question should be: “What is it that I need to do?” Once that question is answered, you can determine which tool is best suited for the task. In this article, I’ll demonstrate the differences between the mongo shell and the MongoDB Node.js driver when performing basic CRUD operations. My hope is that this will help you to decide which approach works best for what you need to do.

The mongo shell is an interactive JavaScript interface to MongoD, and it is a component of the MongoDB package. The mongo shell can be used to perform CRUD operations on data, as well as administrative operations. In other words, think of the mongo shell as a way to interact with a MongoDB database without the need to build or interact with an application.

The MongoDB Node.js driver provides a way to interact with a MongoDB database from your Node application code. It supports both callback-based and Promise-based interaction with your mongo database. This would be the opposite of the mongo shell, which is meant to be used in your Node.js application code.

Inserting One Document Into the Database

Insert One Document with the Mongo Shell – Example # 1A

Insert One Document with the MongoDB Node.JS Driver – Example # 1B

With the mongo shell, we need to specify which database we want to use. We do this by using the “use” command. The syntax is: “use DATABASE_NAME”. So, In Example # 1A, we accomplish two things; we select the madMen database with the user command (i.e. “use madMen”), and then we insert one document into the names collection. Actually, a third step was taken here, although you may not have noticed because it was not explicit; i.e., the names collection was created. With the mongo shell, if we reference a collection that does not already exist when using the insert command, then that collection is created. Note that when we inserted the document, we passed an object to the insert method. This object can have one or more key/value pairs. In this case, we provided that one key/value pair.

You’ll notice that in Example # 1B, an all of the following MongoDB Node.JS Driver examples, there is more code. The reason for this is that there this is application code, so there are some setup steps needed in order to provide dependencies to our application and tell it what we want to do. With the mongo Shell, there is context. That is to say, the mongo Shell understands that you will be working on performing MongoDB-specific tasks, so there is no need to provide dependencies or explain much.

Now here in Example # 1B, we accomplish the same tasks using the MongoDB Node.JS Driver. The first five lines of code provide dependencies and some configuration information. And on line # 8, we establish a connection to the madMen database using the mongoDbClient.connect() method. This method takes a callback, and inside the callback we set references to the madMen database and the names collection. We then use the insert method of the names collection to insert one document. We also add some console.log() statements, just to provide some helpful message so that we can see that the operation was successful. So far, so good.

Inserting Multiple Documents Into the Database

Insert Multiple Documents with the Mongo Shell – Example # 2A

Insert Multiple Documents with the MongoDB Node.JS Driver – Example # 2B

In Example # 2A we insert multiple documents Into the madMen database using the mongo Shell, and we do this in two ways. First, we insert the new documents one at a time. There is no need for a for-loop as this is not application code; since we are in the mongo Shell, we can simply run each command manually. Then, we insert three new documents by using the insertMany method. Now, the difference between the insert and insertMany methods is that with the insert method, you pass one document object as an argument, whereas with the insertMany() method, you provide an array of document objects.

In Example # 2B we insert multiple documents into the madMen database, using the MongoDB Node.JS Driver. The difference between this code and the code found in Example # 2A is that instead of only passing an array of objects to the collection.insertMany() method, we also provide a callback as the second argument. The callback is not required, but it is likely that you will want to provide it because the collection.insertMany() method is asynchronous and you will likely want to act upon the successful insertion of the documents. So, in this example, we’ve shown a couple of console.log() messages to indicate that the database insert was a success. But more importantly, we’ve called the database.close() method, which as you might expect, closed the database. The main thing to keep in mind about leveraging the collection.insertMany() method in your Node application is that it is an asynchronous action, as is often the case in Node.

Viewing All Documents in the Database

View All Documents with the Mongo Shell – Example # 3A

View All Documents with the MongoDB Node.JS Driver – Example # 3B

In Example # 3A, we use the mongo Shell to view all records in the database by simply executing the command: db.names.find(). If we were executing a script file in the shell, we’d need to set a reference to all records, set up a loop, and then in each iteration of the loop we could output the current record over which we are iterating. But because the mongo Shell provides REPL functionality, we can simply execute an expression that results in a value representing every record in the database.

In Example # 3B, we use the MongoDB Node.JS Driver to view all of the records in the database, and here, we need to roll up our sleeves, because we have a little more work to do. Now once again, this is because this is application code, so we need to explain to Node exactly what we want to do. So, if you’ll take a look at line # 11, you’ll see that we use the find() method to obtain a reference to all records in the database. We then chain the each() method to the return value of this, passing it a callback. In the callback, the second argument is the current document over which we are iterating, so we log that document. If the current document is null, then we close the database connection.

Deleting a Single Document

Dele a Single Document with the Mongo Shell – Example # 4A

Delete a Single Document with the MongoDB Node.JS Driver – Example # 4B

In Example # 3A, we use the mongo Shell to remove one document at a time. Notice that we reference a specific document by providing the key: “_id”, and the ID of the document we wish to remove. But we don’t provide the ID simply as a string; we pass a call to the ObjectId function, and then pass the document ID to that function. The reason for this is that MongoDB prefers the wrapper function that converts that string ID to an object.

In Example # 3B, we use the MongoDB Node.JS Driver to remove one document from the database. Now the main difference here is that we use the deleteOne() method, instead of the remove() method. And similar to the mongo Shell approach, we provide an object that uniquely identifies the document we want to remove. This action returns a promise, so we can chain the then() method to its return value and inside the callback, we close the database (line # 19).

Deleting All Documents

Delete All Documents with the Mongo Shell – Example # 5A

Delete All Documents with the MongoDB Node.JS Driver – Example # 5B

In Example # 5A, we use the mongo Shell to remove all documents from the database. Now this is a fairly simple task because we provided an empty object to the remove() method. This indicates to MongoDB that we want to remove all documents.

Example # 5B is somewhat similar. Using the MongoDB Node.JS Driver, we remove all documents in the database by calling the deleteMany() method (as opposed to the “remove()” method). And in a similar fashion, we provide an empty object that signals to MongoDB that we want to remove all documents from the database. Once again, this action returns a promise, so we chain the then() method, passing a callback, and inside of that callback, we close the database.

Summary

In this article, we walked through a comparison accomplishing basic CRUD operations with both the mongo Shell and the MongoDB Node.JS Driver. In each example, we saw that there is a fairly significant difference in the syntax and in some cases, the method names. The main reason for the differences is that the mongo Shell is a REPL environment; i.e., all actions are synchronous, and the shell understands that we are working with MongoDB databases. The MongoDB Node.JS Driver generally requires more work, because our Node application is vanilla JavaScript, and is not necessarily hosted in a MongoDB-specific environment. So, in this case, we need to establish a database connection, set a reference to the MongoDB client, and set references to the database and collection.

Now, as to which approach works best, it really depends on your needs. Both the mongo Shell and MongoDB Node.JS Driver provide significant power for your work with your MongoDB database. The difference is that the mongo Shell is a terminal-based REPL environment and the commands will tend to be simpler. On the other hand, the MongoDB Node.JS driver provides a way to interact with MongoDB from your Node.js code. So, in this case, you’ll need to take a more low-level approach and write code that takes care of connecting to and from the database, as well as your business logic. But while this will usually require more effort, there is great power in that you are writing application code that can have complex logic and be executed repeatedly.

Apr32018 by dcmNo Comments

Getting Started With the MongoDB Node.JS Driver – Basic CRUD Operations

MongoDB

Working with any database always requires some CRUD. Learn how to connect to a MongoDB database and perform basic data transactions.

Database technology is a subject that can quickly become complicated, but here, we’re going to stick to the basics. For example, on a very high level, you’ll usually want to do the same few things repeatedly, that is: connect to a database, insert or update one or more records, or delete one or more records. This is otherwise known as “CRUD” (“create read update delete”). Now even though the exact syntax for these actions will differ from one database technology to the next, the good news is that the general concepts are the same.

In this article, I’ll demonstrate very basic MongoDB CRUD operations using the MongoDB Node.JS Driver. Let me just begin, however, by mentioning the part that I’ll be leaving out: the “U” (“update”) step of our CRUD operations. This is a practical move on my part, because I’m guessing that you no doubt found this article through a web search, and you’re perhaps just getting started with MongoDB. If this is the case, then I think the “create,” “read,” and “delete” steps in this article are the best ones to begin with, and I will follow up with an article dedicated specifically to the more challenging “update” operations in MongoDB. That said, let’s just dive right into some MongoDB CRUD (minus the “U” : – )

Connect to the Database – Example # 1

In Example # 1 we connect to the madMen database. There are just a few steps needed to set up the connection. On line #s 2, 3 and 4 we have the URL of the database server, the name of the database we want to connect to, as well as the name of the collection with which we want to work. On line # 7 we use the mongoDbClient object that was created on line # 1 and we call its connect() method, passing it the database url. The second argument that we pass to mongoDbClient.connect is a callback which will allow us to act upon a successful connection. Now our reason for needing the callback function is that the mongoDbClient.connect method is asynchronous. So inside of the callback function, we execute a console.log() statement just to let ourselves know that were able to establish the connection. Now there’s not too much going on here; I just wanted to point out the basics of how to connect to the database. Once again, just keep in mind that connecting to the MongoDB database is an asynchronous operation.

Insert a New Document – Example # 2

Example # 2 takes us to our next logical step in our CRUD operations by having us insert a new document into the database. The required steps for connecting to the database are exactly the same as those for Example # 1, so let’s save some time, skip over that, and talk about what’s new in Example # 2. Here, we’re using the database variable, which is the second argument passed to the mongoDbClient.connect callback function. Now, in using that database variable, we get ahold of the madMen database, and also set a reference to the names collection. So, using that variable, we call the collection.insert method, passing it the new document that we want to insert, as well as a callback function. Now the hope is that by now, you’ve noticed a pattern, which is that we need to provide a callback function because the collection.insert method is asynchronous. In the callback that we pass to the collection.insert method, we use console.log() to indicate that the document that was inserted was successful. This, of course, is just for demonstration purposes. We then call the database.close() method, to close the database connection.

Insert Multiple Documents – Example # 3

There is only a small difference between Example #s 2 and 3, and that is in Example # 3 we use the collection.insertMany method instead of collection.insert. And instead of passing one document, we pass an array of documents. Everything else is virtually the same; i.e., we execute a log message for demonstration purposes and then close the database connection.

View All Documents – Example # 4

So, now that we have created a few documents, it’s time to view them. Let’s take a look at Example # 4, and drill down to the collection object. By getting ahold of the collection, we can use its find() method. And by passing no arguments to the find() method, we get all of the documents in the collection. We iterate that list of documents, and output each one in the console. Then, when we have gotten to the end of the list, we close the database connection.

Delete One Document – Example # 5

So here we are at CRUD’s letter “D”, which is what we take care of in Example # 5. The main difference between this one and Example # 4 is that once we drill down to the collection object, we use the deleteOne() method, passing it an object that represents the document that we want to delete. Now, I say “…object that represents” because we do not pass it the exact document that we want to delete; what we actually pass it is an object that contains the ID that matches the document we want to delete. Note here that in this document the value of the _id property is an instance of ObjectID, which we initialized on line # 2. ObjectID is a special object that we need in order to pass around mongoDB document IDs. Now it’s important to point out that while it may be tempting to simply pass the ID of the document that we want to delete, unfortunately, MongoDB does not work like that. You need to actually provide an instance of ObjectID. It’s also important to note that, although the deleteOne() method is asynchronous, we handle it a bit differently. In other words, instead of passing a callback function, we use the then() method and pass a callback to that method. And once again, inside of that callback, we close the database connection.

Delete All Documents – Example # 6

In Example #6 we sort of kill two birds with one stone. We leverage the deleteMany() method and as you may have guessed, this method allows us to delete multiple documents in the database. Now, if we simply wanted to delete two or more documents, we would take an approach similar to the one in Example # 5, and pass an array of objects that contain ObjectIDs which match the documents we want to delete. In Example # 6, we wind up deleting every document in the database because we pass an empty object to the deleteMany() method. As with the deleteOne() method, deleteMany() is asynchronous, so we chain its then() method and pass a callback function to it. Inside of that callback function, we log our success and then close the database.

Summary

I’m hoping that this article has provided enough of a high-level understanding of MongDB’s basic operations to get you started. The examples are pretty simple, but they should be enough to help you do further digging around into CRUD operations. The main things to keep in mind are: most of the important methods that you will call are asynchronous, and the ObjectID is a critical component when you want to generate one or more matches with documents in the database.

Apr12015 by dcmNo Comments

Getting Started with Mongo Shell Scripting – Basic CRUD Operations

MongoDB

Learn how to create a JavaScript file that executes mongo shell commands

Why Mongo Shell Scripting ?

In the article: “Getting Started With the Mongo Shell – Basic CRUD Operations“, I covered the basics needed to perform CRUD operations on a MongoDB database, using the mongo shell. All of the examples in that article were in real-time. This is perfectly acceptable, and there may be cases in which you will want to perform administrative tasks manually. But it is also possible (and more likely) that you’ll want to create a script that executes a batch of mongo shell tasks. So, since JavaScript is the language used to interact with the mongo shell, we can pass a JS file to the mongo command in a terminal. This is mongo shell scripting.

This functionality offers a great deal of potential. For example, in this article I will provide a very simple demonstration that performs basic CRUD operations (“Create, Read, Update, Delete”).

An important note about the following examples:

If you want to run these examples locally, you have two options:

Clone this GitHub repo and follow the instructions: https://github.com/kevinchisholm/mongo-shell-scripting-basic-crud-operations
Scroll down to the section: “How to Demo“, and then follow the instructions

Creating a Database

Create the “madMen” database – Example # 1

//create the madMen database and connect to it
var db = connect('127.0.0.1:27017/madMen'),
    allMadMen = null;

//create the madMen database and connect to it

var db = connect('127.0.0.1:27017/madMen'),

allMadMen = null;

In Example # 1, we create the “madMen” database and establish a connection to it. The “allMadMen” variable is set to null for now, but will indeed be used in the next example.

Adding Data to / Reading Data from a Database

Create the “names” collection – Example # 2

//create the names collection and add documents to it
db.names.insert({'name' : 'Don Draper'});
db.names.insert({'name' : 'Peter Campbell'});
db.names.insert({'name' : 'Betty Draper'});
db.names.insert({'name' : 'Joan Harris'});

//set a reference to all documents in the database
allMadMen = db.names.find();

//iterate the names collection and output each document
while (allMadMen.hasNext()) {
   printjson(allMadMen.next());
}

//create the names collection and add documents to it

db.names.insert({'name' : 'Don Draper'});

db.names.insert({'name' : 'Peter Campbell'});

db.names.insert({'name' : 'Betty Draper'});

db.names.insert({'name' : 'Joan Harris'});

//set a reference to all documents in the database

allMadMen = db.names.find();

//iterate the names collection and output each document

while (allMadMen.hasNext()) {

printjson(allMadMen.next());

}

In Example # 2, we create the “names” collection and then add four documents to it. We then use the “allMadMen” variable to store a reference to the names collection, and then iterate it. The purpose of the iteration is to allow you to see in your terminal that the madMen database has actually been populated with documents. Example # 2 demonstrates both the “Create” part of our CRUD operations, and the “Read” part as well.

Updating A Collection Document

Let’s make a change to “Donald Draper” – Example # 3

//search for the document whose name property is: "Don Draper"
db.names.find().forEach( function(thisDoc) {
  if(thisDoc.name === 'Don Draper'){
    //update the record that contains "Donald Draper" and change it to "Dick Whitman"
    db.names.update( { "_id" : thisDoc._id }, { "name": "Dick Whitman" } );
  }; 
});

//search for the document whose name property is: "Don Draper"

db.names.find().forEach( function(thisDoc) {

if(thisDoc.name === 'Don Draper'){

//update the record that contains "Donald Draper" and change it to "Dick Whitman"

db.names.update( { "_id" : thisDoc._id }, { "name": "Dick Whitman" } );

};

});

Example # 3 is the “U” in our CRUD operation; in other words: “Update”. Here we use the forEach method of the names collection to iterate and find the document whose “name” property is set to: “Don Draper”. So, once we find that document, we update its “name” property to: “Dick Whitman”.

Deleting A Collection Document

Let’s delete “Dick Whitman.” – Example # 4

db.names.find().forEach( function(thisDoc) {
  if(thisDoc.name === 'Dick Whitman'){
    //remove the record that contains "Dick Whitman"
    db.names.remove({ "_id" : thisDoc._id });
  }; 
});

db.names.find().forEach( function(thisDoc) {

if(thisDoc.name === 'Dick Whitman'){

//remove the record that contains "Dick Whitman"

db.names.remove({ "_id" : thisDoc._id });

};

});

In Example # 4, we delete the document whose “name” property is set to: “Dick Whitman.”

Dropping a Database

Drop the “madMen” database – Example # 5

//drop the database

1	//drop the database

db.dropDatabase();

In Example # 5, we drop the “madMen” database.

The Entire App – Example # 6A

//create the madMen database and connect to it
var db = connect('127.0.0.1:27017/madMen'),
    allMadMen = null;

print('* Database created');

//create the names collection and add documents to it
db.names.insert({'name' : 'Don Draper'});
db.names.insert({'name' : 'Peter Campbell'});
db.names.insert({'name' : 'Betty Draper'});
db.names.insert({'name' : 'Joan Harris'});

print('* Documents created');

//set a reference to all documents in the database
allMadMen = db.names.find();

print('* All documents:');

//iterate the names collection and output each document
while (allMadMen.hasNext()) {
   printjson(allMadMen.next());
}

//search for the document whose name property is: "Don Draper"
db.names.find().forEach( function(thisDoc) {
  if(thisDoc.name === 'Don Draper'){
    //update the record that contains "Donald Draper" and change it to "Dick Whitman"
    db.names.update( { "_id" : thisDoc._id }, { "name": "Dick Whitman" } );

    print('* Updated document: ' + thisDoc._id);
  }; 
});

print('* All documents:');

//set a reference to all documents in the database
allMadMen = db.names.find();

//iterate the names collection and output each document
while (allMadMen.hasNext()) {
   printjson(allMadMen.next());
}


db.names.find().forEach( function(thisDoc) {
  if(thisDoc.name === 'Dick Whitman'){
    //remove the record that contains "Dick Whitman"
    db.names.remove({ "_id" : thisDoc._id });

    print('* Removed document:');

    //output the removed document as json
    printjson(thisDoc);
  }; 
});

print('* All documents ("Dick Whitman" removed):');

//set a reference to all documents in the database
allMadMen = db.names.find();

//iterate the names collection and output each document
while (allMadMen.hasNext()) {
   printjson(allMadMen.next());
}

//drop the database
db.dropDatabase();

print('* Database dropped');

//create the madMen database and connect to it

var db = connect('127.0.0.1:27017/madMen'),

allMadMen = null;

print('* Database created');

//create the names collection and add documents to it

db.names.insert({'name' : 'Don Draper'});

db.names.insert({'name' : 'Peter Campbell'});

db.names.insert({'name' : 'Betty Draper'});

db.names.insert({'name' : 'Joan Harris'});

print('* Documents created');

//set a reference to all documents in the database

allMadMen = db.names.find();

print('* All documents:');

//iterate the names collection and output each document

while (allMadMen.hasNext()) {

printjson(allMadMen.next());

}

//search for the document whose name property is: "Don Draper"

db.names.find().forEach( function(thisDoc) {

if(thisDoc.name === 'Don Draper'){

//update the record that contains "Donald Draper" and change it to "Dick Whitman"

db.names.update( { "_id" : thisDoc._id }, { "name": "Dick Whitman" } );

print('* Updated document: ' + thisDoc._id);

};

});

print('* All documents:');

//set a reference to all documents in the database

allMadMen = db.names.find();

//iterate the names collection and output each document

while (allMadMen.hasNext()) {

printjson(allMadMen.next());

}

db.names.find().forEach( function(thisDoc) {

if(thisDoc.name === 'Dick Whitman'){

//remove the record that contains "Dick Whitman"

db.names.remove({ "_id" : thisDoc._id });

print('* Removed document:');

//output the removed document as json

printjson(thisDoc);

};

});

print('* All documents ("Dick Whitman" removed):');

//set a reference to all documents in the database

allMadMen = db.names.find();

//iterate the names collection and output each document

while (allMadMen.hasNext()) {

printjson(allMadMen.next());

}

//drop the database

db.dropDatabase();

print('* Database dropped');

In Example # 6A, we have the completed example code. To demonstrate, numerous print and printjson statements have been added so that the terminal output makes a bit more sense.

The Output – Example # 6B

MongoDB shell version: 2.6.5
connecting to: test
connecting to: 127.0.0.1:27017/madMen
* Database created
* Documents created
* All documents:
{ "_id" : ObjectId("550f2939a8a5d2643f6408fb"), "name" : "Don Draper" }
{ "_id" : ObjectId("550f2939a8a5d2643f6408fc"), "name" : "Peter Campbell" }
{ "_id" : ObjectId("550f2939a8a5d2643f6408fd"), "name" : "Betty Draper" }
{ "_id" : ObjectId("550f2939a8a5d2643f6408fe"), "name" : "Joan Harris" }
* Updated document: 550f2939a8a5d2643f6408fb
* All documents:
{ "_id" : ObjectId("550f2939a8a5d2643f6408fb"), "name" : "Dick Whitman" }
{ "_id" : ObjectId("550f2939a8a5d2643f6408fc"), "name" : "Peter Campbell" }
{ "_id" : ObjectId("550f2939a8a5d2643f6408fd"), "name" : "Betty Draper" }
{ "_id" : ObjectId("550f2939a8a5d2643f6408fe"), "name" : "Joan Harris" }
* Removed document:
{ "_id" : ObjectId("550f2939a8a5d2643f6408fb"), "name" : "Dick Whitman" }
* All documents ("Dick Whitman" removed):
{ "_id" : ObjectId("550f2939a8a5d2643f6408fc"), "name" : "Peter Campbell" }
{ "_id" : ObjectId("550f2939a8a5d2643f6408fd"), "name" : "Betty Draper" }
{ "_id" : ObjectId("550f2939a8a5d2643f6408fe"), "name" : "Joan Harris" }
* Database dropped

MongoDB shell version: 2.6.5

connecting to: test

connecting to: 127.0.0.1:27017/madMen

* Database created

* Documents created

* All documents:

{ "_id" : ObjectId("550f2939a8a5d2643f6408fb"), "name" : "Don Draper" }

{ "_id" : ObjectId("550f2939a8a5d2643f6408fc"), "name" : "Peter Campbell" }

{ "_id" : ObjectId("550f2939a8a5d2643f6408fd"), "name" : "Betty Draper" }

{ "_id" : ObjectId("550f2939a8a5d2643f6408fe"), "name" : "Joan Harris" }

* Updated document: 550f2939a8a5d2643f6408fb

* All documents:

{ "_id" : ObjectId("550f2939a8a5d2643f6408fb"), "name" : "Dick Whitman" }

{ "_id" : ObjectId("550f2939a8a5d2643f6408fc"), "name" : "Peter Campbell" }

{ "_id" : ObjectId("550f2939a8a5d2643f6408fd"), "name" : "Betty Draper" }

{ "_id" : ObjectId("550f2939a8a5d2643f6408fe"), "name" : "Joan Harris" }

* Removed document:

{ "_id" : ObjectId("550f2939a8a5d2643f6408fb"), "name" : "Dick Whitman" }

* All documents ("Dick Whitman" removed):

{ "_id" : ObjectId("550f2939a8a5d2643f6408fc"), "name" : "Peter Campbell" }

{ "_id" : ObjectId("550f2939a8a5d2643f6408fd"), "name" : "Betty Draper" }

{ "_id" : ObjectId("550f2939a8a5d2643f6408fe"), "name" : "Joan Harris" }

* Database dropped

In Example # 6B, we have the terminal output from the code in Example # 6A.

How to Demo:

Make sure the MongoDB database server is running
Create a file named: “create-db.js”.
Copy the entire contents of Example # 6 to “create-db.js”
In a terminal window, execute the following command: “mongo create-db.js”

Summary

In summary, we learned how to perform basic CRUD operations on a MongoDB database by leveraging mongo shell scripting.

Helpful Links for Mongo Shell Scripting

Getting Started With the Mongo Shell – Basic CRUD Operations | Kevin Chisholm – Blog

http://docs.mongodb.org/manual/administration/scripting/

Mar252015 by dcm1 Comment

Getting Started With the Mongo Shell – Basic CRUD Operations

MongoDB

Learn how to perform CRUD operations on a MongoDB database, using the mongo shell

While it is likely that you will want to leverage MongoDB for your Node.js application, the mongo shell is an incredibly useful administrative tool that should not be overlooked. The definition provided by mongodb.org is: “The mongo shell is an interactive JavaScript shell for MongoDB, and is part of all MongoDB distributions.” It really is that straightforward: you can interact with your MongoDB database using JavaScript, in a command shell. Brilliant.

In this article I will demonstrate how to create a MongoDB database, add documents to the database, update a document, delete a document, and then delete your database. All of this will be done using a command prompt and JavaScript.

NOTE: I assume that you already have MongoDB installed globally. If you do not have MongoDB installed and need assistance with that, please see the “Installation Links” section at the end of this article.

Starting the Mongo shell

Before you can interact with a MongoDB database using the mongo shell, you’ll need to have the MongoDB database server running. In order to start the MongoDB server, execute: “mongod” in your terminal window. The output you see should be similar to this:

mongod --help for help and startup options
2015-03-22T13:09:24.130-0400 [initandlisten] MongoDB starting : pid=1562 port=27017 dbpath=/data/db 64-bit host=YOUR_MACHINE_NAME.local
2015-03-22T13:09:24.130-0400 [initandlisten] db version v2.6.5

mongod --help for help and startup options

2015-03-22T13:09:24.130-0400 [initandlisten] MongoDB starting : pid=1562 port=27017 dbpath=/data/db 64-bit host=YOUR_MACHINE_NAME.local

2015-03-22T13:09:24.130-0400 [initandlisten] db version v2.6.5

Starting the Mongo shell couldn’t be easier. Open a second terminal window, and then execute the command: “mongo”. You should see the following output in your terminal window:

MongoDB shell version: 2.6.5
connecting to: test

1 2	MongoDB shell version: 2.6.5 connecting to: test

You may be surprised to see that you are connected to “test”, but that is the default database. In order to see a list of existing databases, execute the following command:

show dbs

show dbs

You should see the following output in your terminal window:

admin (empty)

1	admin (empty)

Creating a MongoDB Database

In order to create a new database, use the “use” command. Execute the following command:

use madMen

1	use madMen

You should see the following output in your terminal window:

switched to db madMen

1	switched to db madMen

Now take a look at the existing databases again by executing the command: “show dbs”. You may be wondering why the new database “madMen” does not show up in the list of existing databases. This is because it has no data. Let’s add some data to that database.

Adding Documents to a Collection

With MongoDB, we can create collections on the fly when we add data. For example, the new database “madMen” is empty. We can add a “names” collection and insert a document into that collection all in one command.

Execute this command:

db.names.insert({'name' : 'Don Draper'});

1	db.names.insert({'name' : 'Don Draper'});

You should see the following output in your terminal:

WriteResult({ "nInserted" : 1 })

1	WriteResult({ "nInserted" : 1 })

Now, let’s take another look at the list of databases. Execute the command: “show dbs”.

You should see the following output in your terminal:

admin (empty)
madMen 0.078GB

1 2	admin (empty) madMen 0.078GB

The reason you now see the madMen database in the list is because it contains some data. Let’s add three more documents to the “names” collection. Execute the following commands:

db.names.insert({'name' : 'Pete Campbell'});
db.names.insert({'name' : 'Betty Draper'});
db.names.insert({'name' : 'Joan Harris'});

db.names.insert({'name' : 'Pete Campbell'});

db.names.insert({'name' : 'Betty Draper'});

db.names.insert({'name' : 'Joan Harris'});

If you executed the previous JavaScript, the “names” collection should now have four documents. Let’s talk about how you can view all the documents in a collection.

Iterating Over the Documents in a Collection

If you want to view all of the documents in a collection, using the mongo shell, it is at minimum, a two-step process. First, obtain a reference to the collection, and then iterate over the collection using the next() method. In the following example, we’ll create a while loop. The hasNext() method will be used as the condition of the loop, and then inside of the loop, we’ll use the next() method to get the “next” document in the collection. The return value of that method will be passed to the printJson function, which is specific to mongo.

Execute this code:

var allRecords = db.names.find();

while ( allRecords.hasNext() ) {
printjson(allRecords.next());
}

var allRecords = db.names.find();

while ( allRecords.hasNext() ) {

printjson(allRecords.next());

}

In the previous example, we set the variable “allRecords” equal to the result of “db.names.find()”. The “allRecords” variable then has a reference to all of the documents in the “names” collection. We then use a while loop to iterate over the collection. On each iteration, the next method of the allRecords variable is passed to the printjson function. The output in your terminal should be similar to this:

{ "_id" : ObjectId("550ef996bca11fc0a6df88d0"), "name" : "Don Draper" }
{ "_id" : ObjectId("550efb31ec7714832416d885"), "name" : "Pete Campbell" }
{ "_id" : ObjectId("550efb31ec7714832416d886"), "name" : "Betty Draper" }
{ "_id" : ObjectId("550efb32ec7714832416d887"), "name" : "Joan Harris" }

{ "_id" : ObjectId("550ef996bca11fc0a6df88d0"), "name" : "Don Draper" }

{ "_id" : ObjectId("550efb31ec7714832416d885"), "name" : "Pete Campbell" }

{ "_id" : ObjectId("550efb31ec7714832416d886"), "name" : "Betty Draper" }

{ "_id" : ObjectId("550efb32ec7714832416d887"), "name" : "Joan Harris" }

The values of each document’s “_id” property will differ in your terminal because these are unique IDs, generated by the instance of MongoDB. The rest of the data should be the same.

Updating a Document

Now that we have four documents in the “names” collection, let’s update one of those documents. We do this by using the “save” method of the collection object. We’ll need to pass the “_id” of the document that we want to update, as well as the new data. Let’s change “Don Draper” to “Dick Whitman”.

db.names.save({_id:ObjectId('550ef996bca11fc0a6df88d0'),"name" : "Dick Whitman" });

1	db.names.save({_id:ObjectId('550ef996bca11fc0a6df88d0'),"name" : "Dick Whitman" });

You should see the following output in your terminal:

WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 });

1	WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 });

Now, let’s use the while loop we created earlier to inspect all records of the “names” collection:

var allRecords = db.names.find();

while ( allRecords.hasNext() ) {
printjson(allRecords.next());
}

var allRecords = db.names.find();

while ( allRecords.hasNext() ) {

printjson(allRecords.next());

}

You should see the following output in your terminal:

{ "_id" : ObjectId("550ef996bca11fc0a6df88d0"), "name" : "Dick Whitman" }
{ "_id" : ObjectId("550efb31ec7714832416d885"), "name" : "Pete Campbell" }
{ "_id" : ObjectId("550efb31ec7714832416d886"), "name" : "Betty Draper" }
{ "_id" : ObjectId("550efb32ec7714832416d887"), "name" : "Joan Harris" }

{ "_id" : ObjectId("550ef996bca11fc0a6df88d0"), "name" : "Dick Whitman" }

{ "_id" : ObjectId("550efb31ec7714832416d885"), "name" : "Pete Campbell" }

{ "_id" : ObjectId("550efb31ec7714832416d886"), "name" : "Betty Draper" }

{ "_id" : ObjectId("550efb32ec7714832416d887"), "name" : "Joan Harris" }

As you can see, the document that contained “Don Draper” has now been changed to “Dick Whitman”.

Deleting a Document

Let’s delete the same document that we just updated. In order to do that, we’ll use the “remove” method of the collection object, passing it the “_id” of the exact document that we want to delete:

db.names.remove({_id:ObjectId('550ef996bca11fc0a6df88d0')});

1	db.names.remove({_id:ObjectId('550ef996bca11fc0a6df88d0')});

You should see the following output in your terminal:

WriteResult({ "nRemoved" : 1 })

1	WriteResult({ "nRemoved" : 1 })

Now let’s take a look at all the documents in the database again:

var allRecords = db.names.find();

while ( allRecords.hasNext() ) {
printjson(allRecords.next());
}

var allRecords = db.names.find();

while ( allRecords.hasNext() ) {

printjson(allRecords.next());

}

As you can see, the document that we deleted no longer exists.

{ "_id" : ObjectId("550efb31ec7714832416d885"), "name" : "Pete Campbell" }
{ "_id" : ObjectId("550efb31ec7714832416d886"), "name" : "Betty Draper" }
{ "_id" : ObjectId("550efb32ec7714832416d887"), "name" : "Joan Harris" }

{ "_id" : ObjectId("550efb31ec7714832416d885"), "name" : "Pete Campbell" }

{ "_id" : ObjectId("550efb31ec7714832416d886"), "name" : "Betty Draper" }

{ "_id" : ObjectId("550efb32ec7714832416d887"), "name" : "Joan Harris" }

Deleting a Database

While not something you are likely to do too often, deleting a database is a perfectly valid MongoDB operation. The syntax could not be more simple; use the “dropDatabase” method of the db object.

db.dropDatabase();

1	db.dropDatabase();

You should see the following output in your terminal:

{ "dropped" : "madMen", "ok" : 1 }

1	{ "dropped" : "madMen", "ok" : 1 }

Now, execute the command: “show dbs”. You should see the following output in your terminal:

admin (empty)

1	admin (empty)

Summary

In this article, we learned about basic CRUD operations in Mongo Shell. We learned how to start the database server, start the shell and view a list of all databases. We also covered steps needed to create a database, add documents to that database, update a document, delete a document and delete a database. There is a mountain of topics when it comes to the Mongo Shell. I hope this article helped you in getting started.