Database

A database is a set of collections (tables). Each databse is physically stored as files on the host filesystem. A single MongoDB instance can host multiple databases. It is equivalent to an RDBMS schema. To see which databases currently exist type show dbs. By default you will see the local and admin databases. These are specal databases that we will not cover in this tutorial.

Collection

Collection is a group of documents. It is the equivalent of an RDBMS table. A collection exists within a single database. Collections do not enforce a schema. Documents within a collection can have different fields. Typically, all documents in a collection are of similar or related purpose.

Document

Entries in MongoDB are called documents, and are representeed by a JSON object, These are equivelant to a row in a mysql table. Documents have dynamic schema which means that documents in the same collection do not need to have the same set of fields or structure.

To work on a specifc databse we use the use DATABSE_NAME command. In this tutorial we'll work on mydb. Type use mydb to switch to mydb databse.

To check the current database, type db. Before we continue, make sure you are indeed using mydb.

Let's insert our first documents to a users collection. We don't need to create the collection in advance - it will be created as soon as we insert the 1st document.

To insert a document we use db.collection_name.insert(document), where document is the JSON representing the object we would like to store. For example: db.users.insert( { fname: "John", lname: "Doe", email: "[email protected]", age: 25 });

Now that we inserted our first document, let's see what we have. Using show dbs we can see that our new databse mydb was created. Using show collections or db.getCollectionNames() we can see that we now have a users collection in our mydb databse.

To see the document we created, use the find() command: db.users.find() The find() query returns all the documents in the collection. You can see the document is returned in a single row. We can add the pretty() command to format the json to a more readble form.

Try it out: db.users.find().pretty()i

Tip

When typing in the mongo shell, hit tab to get auto-suggestions on how to complete the command.

Each document has an _id field, which acts as its primary key. This field must be unique across all documents in the collection. When inserting documents, if the _id field is not supplied as part of the document, MongoDB will generate its own ObjectId.

See for yourself - our user in the users collection now has an _id field: db.users.find().pretty().

Lets insert more users: db.users.insert({fname:"Jane", lname: "Doe", email: "[email protected]", age:36}). db.users.insert({fnbame:"Calvin", lname: "Lucas", email: "[email protected]", "age":31})

Now we have 3 users in our collection, each with its own unique _id.

Check it out: db.users.find().pretty()

TIP

Remember. if the screen get's clattered use cls to clear it

We saw that the find() command returns all documents in the collection. We can add a query to do a more refined search. Queries are also represented as JSON documents.

For example, to search just for John we can do:

db.users.find({fname:"John"})

If we search by last name we'll get 2 results, as expected:

db.users.find({lname:"Doe"})

There are a lot of query operators we can use. For example, the $gt stands for 'greater than':

db.users.find({age: {$gt: 30}})

Tip

For all the query options, visit MongoDB documentation: https://docs.mongodb.com/manual/reference/operator/query/

Sorting query results is donw using the sort() command. It takes a single json as a parameter. to define by which field to sort, and whether to do it in ascending or descneding order.

For example, to sort by our users by age:

In ascending order: db.users.find().sort({age:1}).pretty()

In decending order: db.users.find().sort({age:-1}).pretty()

Use the update() command to change a document. The update() command takes 2 parameters, a query to select which documents to update, and an update instruction, with the details of what to update.

Typically we use the $set operator in the update part, to set values to specific fields in the document.

For example, to update the age of our John Doe user we will do this:

db.users.update({fname:"John"},{$set: {age:50}})

Using db.users.findOne({fname:"John"}) will show us the change.

By default update() will update a single document matching the query part. If we want to update multiple documents we need to explicitly state it by adding {multi:true} to the update command. Run the following update() commands to see the difference. Remember: use db.users.find() to query the users collection to see what you have after each update().

Updating a single document matching the query:

db.users.update({lname:"Doe"},{$set: {age:20}})

Updating all documents matching the query:

db.users.update({lname:"Doe"},{$set:{age:15}},{multi:true})

Tip

findOne() will return a single document matching the query - the 1st one that is found.

Sometimes when runnig queries you don't want to get the entire document back, but just specific fields. We use a projection instruction in the find command to do so.

For example, to retrieve just the email field from our users:

db.users.find({},{email:1})

Note that we have an empty {}. This is an empty query, since we want to find all objects. The secnod {} block is the projection block, which instructs the query to return only the email field.

By default the _id field is also returned. You can remove that as well:

db.users.find({},{_id:0, email:1})

Tip

In mongo shell, using the up arrow will show you previously run commands, which yo ucna re-run byu hitting ENTER.

Use the remove() command to delete objects. Similar to find() and update() it takes a query parameter (as json) to define which documents to remove. Unlike update(), it operates on all matching objects.

Recall what we have in the collection using find() (did you remember the syntax?)

Let's remove all users that are younger than 20:

db.users.remove({age:{$lt:20}})

Let's see what we've got now. We should be left with a single document:

db.users.find()

Finaly, we can use drop() to drop the entire collection:

db.users.drop()

We no longer have a users collection: show collections returns an emprty result.

Tip

You can use db.users.remove({}) to remove all documents in a collection, without dropping the collection itself.

To remove a single document add {justOne:true} to the remove() options: db.users.remove({},{justOne:true})