<iframe class="gist-iframe" src="/gist/HussainArif12/d234220ebed9059db713033e8f7855db.js" allowfullscreen="" frameborder="0" height="undefined" width="undefined"> </div> </div> </figure></iframe></div></d

The Fundamentals of MongoDB Native API

Use MongoDB With Node.JS

Enable Database capabilities Within Your Node.Js Application

You’ve proven your fellow peers time and again that you’re an amazing programmer who can do a splendid job in developing the backend of a web app.You skillfully use Routers in Express to handle multiple routes that the user navigates to. One day, you receive a call from your library asking you to work on the server side of their website.

However later on, the librarian throws a wrench in your works. She says that the library needs some kind of storage system in the backend, so that users can view information about their books online through a database. With additional research, you find out that one of the best database solutions is MongoDB

Introduction: What Is MongoDB

MongoDB is a document-oriented database program. It uses JSON-like documents with schema. These terms will be explained later.

It’s has several advantages. Some of them are:

It’s performant, fast and extremely scalable.Furthermore, it has built in replication, and is flexible.
Unlike mySQL or other relational databases you don’t need to map out your data structure beforehand, you don’t need to create all your tables, your columns and take the stress about deciding what data type your data is i.e VARCHAR or STRING.
Other than that, the MongoDB API is extremely easy to learn and supports a plethora of languages including JavaScript, so you feel right at home whenever you develop apps involving MongoDB.

Things to remember

Basic Terminology

Before we get our feet wet, there are some keywords you should keep in mind.

Documents : They are simple data records. It is the basic unit of storing data in a database. If you have a background in relational databases, you can think of documents as a ROW. Documents comprise of field-and-value pairs. A simple example of a document can be:

{
name: 'Hussain'
Age : 18
occupation:'Student'
}

For every field , there will be a value . For example, here , one of the fields is name and its associated value is 'Hussain'

Collections : A set of documents within a database. A database can have multiple collections. For relational database users, they are similar to tables.
Queries : They are used to specify the conditions that determine which documents need to be selected for read,update, and delete operations.

The __id field

The __id field is mandatory for every MongoDB document. It is a primary key. In other words, it is used to uniquely determine a document in the database, thus it has a unique value. Even if you don’t specify this field, MongoDB will automatically generate an __id for you.

Other than that,bear in mind that none of the field names should contain the null container.

Getting Started

To get started, first you need to navigate to the MongoDB Community download page. We are installing this software to view and create documents and collections without any code. If you are developing on Windows, it’s preferable to install an MSI installer. The download options should look like this:

How your download options should look like in the end

In the end, the installation wizard will do the job for you.

When it’s done, verify that the installation has been done correctly by going to your command line and typing mongod

If you see this in your terminal window, your installation was done correctly.

Now, we need to create a project with mongodb module installed through NPM.

mkdir myMongoDBApp
cd myMongoDBApp
npm init -y
npm install mongodb

We’re now done! Let’s move on to create a database.

Initializing Our Database

We now need to build our database. First we need to require the mongodbmodule and then initialize an object of MongoClient:

const Mongo = require('mongodb')
const MongoClient = Mongo.MongoClient; 
const client = new MongoClient("mongodb://localhost:27017", { useUnifiedTopology: true })

In this code, we have initialized an object of Mongo.MongoClient which will give us access to the connect method, thus allowing us to create/connect to a database. The first parameter of the MongoClient constructor is the URL you want to connect to.

To connect to database, we use the client.connect method. To do so, write the following:

client.connect((err)=>{
  if(err) console.log(err)
  console.log('built database')
  const db = client.db('HussainsDatabase')
  client.close()
})

In this code, we have finally connected to a database named HussainsDatabase (illustrated by bold lines). In the end, we invoke the client.close method to close the database and its connections.

The output will be as follows:

Creating A MongoDB Collection

Now that our database has been built, we need to create a Collection to make a home for our Documents. To do so, we will utilize the db.createCollection() method

const createCollection = (db,callback)=>{
  db.createCollection('HussainsCollection',(err,results)=>{
    if(err) console.log(err)
    console.log('collection built');
    callback();
 })
}

In this code, we create a MongoDB collection named 'HussainsCollection' through the help of a Db instance .Then in the end, we execute a callback function. The presence of this callback is necessary as we will invoke client.close() as a callback function

Now that the createCollectionmethod has been created, we will invoke this function within client.connect that we’ve already used above.

Ultimately, the code will be as follows:

As stated, we have invoked client.close function as a callback to close all database connections in the end.

The output will be as follows:

CRUD Operations in MongoDB

All of these operations are made possible via the Collection class. For more details, click here.

Note: In these examples, for brevity’s sake, the createCollection method, the require and initialization methods have not been written in the next gists as they are the same as the previous example.

Inserting/Creating Documents

We’ve connected to a database and now have built a collection. Now we need to insert documents in that collection.

There are multiple methods to insert Documents.

db.collection.insertOne

As the name suggests, we will only insert one Document at a time. An example is:

Here, we are adding a document with name and age fields. The name will be Hussain and age will be 18

const insert = (db,callback)=>{

 db.collection('HussainsCollection').insertOne({name:'Hussain', age:       '18'},(err,result)=>{

  if(err) console.log(err)
  console.log(result.ops);
  callback();
 })
}

The first parameter of insertOne is to tell what data/document to insert. If there is an error, it will be logged accordingly.The result.ops property will tell us what document has been inserted.

We will add this code within our createCollection method with some minor modifications as follows:

The output will be as follows:

db.collection.insertMany

This method is used to insert multiple documents in a given time. This will be done by passing an array of documents in the first parameter of insertMany .

const insertMany = (db,callback)=>{

db.collection('HussainsCollection').insertMany([{name:'Hussain', age:'18'},{name:'Arif', age: 50}] ,(err,result)=>{

 if(err) console.log(err)
 console.log(result.ops);
 callback();
 })
}

As usual, this function will be invoked within the client.connect callback.

Notice that this method is almost similar to insertOne . The output will be as follows:

Reading/Finding Documents

We will first use the find method to query the database. find returns a cursor which allows the user to operate on the data.

The find method is defined as :

db.collection.find(query,options)

This will return a Cursor object, with which we will invoke the toArray method to convert the returned results(documents) into arrays

db.collection.find(query,options).toArray((result,documents)=>{
//code
})

In this example, we will have run a query to return the documents which will have the name value 'Hussain' .

const findDocument = (db,callback)=>{
   db.collection('HussainsCollection').find({name:'Hussain'}).toArray((err,docs)=>{
 console.log(docs);
 callback();
 })
}

The code will be within the client.connect callback

In my database, I have five documents having the name field to Hussain . Thus, on my program, the output will be as follows:

Note: Some of the values in agefield are strings as I inserted string values before writing the final version of the program. In your case, the age field should always be integer.

To get all of the documents in the list, make the query argument as empty i.e

db.collection.find({}).toArray(...)

Updating Documents

Updating documents has two functions, updateOne and updateMany .

Both functions have the following arguments.

db.collection.updateX({query},{$set: {field:value}},(err,result)=> {

//code
})

Here, X can be either One or Many

If any document matches the query then we can set its field value to its respective value

db.collection.updateOne :

It will update the first document it finds that matches the query.

In this example, we will find any document that has the name of Hussain and will change it to name of Ali :

const updateDocument=  (db,callback)=>{
db.collection('HussainsCollection').updateOne({name: 'Hussain'} , {$set : {name: 'Ali'}} , (err,result)=>{
if(err) console.log(err)
console.log(' 1 Document updated');
callback()
})
}

Ultimately, the code will be as follows:

The output will be as follows:

As updateOne only updates the first document, thus only one document is updated each time this function is run.

You can also update multiple fields within the $set argument.

You can use the db.collection.find to get a final list of the results after the modifications are performed.

db.collection.updateMany

It is similar to the updateOne method, however unlike updateOne ,updateMany will update all documents that match the given query.

In this example, we will update all documents that contain the name of 'Hussain' and change them to the name of 'Ali'

const updateMany =  (db,callback)=>{
  db.collection('HussainsCollection').updateMany({name: 'Hussain'} ,   {$set : {name: 'Ali'}} , (err,result)=>{

  if(err) console.log(err)

  console.log(result.result.nModified + ' documents have been     modified');

  callback()
})
}

This code will log the number of documents that have been altered due to this method. This property is given by the result.result.nModified property.

As usual, this method is to be invoked within the createCollection method with the callback executing the client.close method.

On my machine, I had four documents matching the query given in my code. Thus the output was as follows:

It is possible to update several fields in one go. Let’s change both the name and age in this piece of code(illustrated by bold):

db.collection.updateX({name:'Hussain'},{$set : {name:'Ali',age:43}},function(err,res){
//code
})

Here , X can be either One or Many

Deleting Documents

To delete documents, we use either deleteOne and deleteMany methods

deleteOne and deleteMany are defined as follows:

db.collection('HussainCollection').deleteX(query,(err,result)=>{
//code
})

Here, X is either One or Many . They both have the same parameters.

This function will delete the document/documents that match the given query . The result parameter in the callback contains information about the documents that were deleted due to this function.

db.collection.deleteOne

Only removes the first occurence of the document that matches this query.

In this example, we will delete the documents that have the name field to Arif .

const deleteDocument=  (db,callback)=>{
 db.collection('HussainsCollection').deleteOne({name: 'Arif'} ,  (err,result)=>{
  if(err) console.log(err)
  console.log(result.deletedCount);
  callback()
 })
}

The deletedCount property of result gives us how many documents were deleted.

Like all examples, this will be invoked within the createCollection function block. The output on my machine is as follows:

db.collection.updateMany

Deletes all documents that match the given query.

Let’s delete all documents that match the query where name is Arif .

const deleteDocument=  (db,callback)=>{
db.collection('HussainsCollection').deleteMany({name: 'Arif'} , (err,result)=>{
 if(err) console.log(err)
 console.log(result.deletedCount);
 callback()
 })
}

On my machine, two documents matched the query. Thus, the output is a s follows:

Summary

For all CRUD Operations

To connect to database and create collections:

A document is a simple record in MongoDb
A collection is a set of documents.

External Resources

A perhaps easier alternative to using the MongoDB Native API is using Mongoose API. In the next tutorial, we will learn how to implement relational database functionality with Mongoose.

This tutorial might seem long and incredibly tedious,but this topic is incredibly easy to wrap your head around if you apply the examples in your code. Remember, you’ll only learn when you start doing instead of just reading.

Thank you so much for making it to then end of this tutorial! Have a great day!

Stay home, stay safe!

A note from Plain English

Did you know that we have four publications? Show some love by giving them a follow: JavaScript in Plain English, AI in Plain English, UX in Plain English, Python in Plain English — thank you and keep learning!

Also, we’re always interested in helping to promote good content. If you have an article that you would like to submit to any of our publications, send an email to [email protected] with your Medium username and what you are interested in writing about and we will get back to you!