<a href="https://docs.mongodb.com/" rel="noopener noreferrer" target="_blank">MongoDB</a> is a NoSQL database. It is different from traditional SQL based databases. How is it different ? First, it doesn't have a predefined structure like SQL tables. We don't need to define how our table will look like before hand. Second, it doesn't use tables, instead it uses JSON-like documents and it's up to you to choose if you want a schema or not. RDBMS: Relational DatabasesNoSQL : Not only SQL or Non Relational Databases or Distributed Databases <h2>Benefits of NoSQL:</h2><ul><li>Dynamic schema for data that is unstructured. Each document can have unique structure.</li><li>It is optional to define Schema.</li><li>NoSQL databases are are horizontally scalable</li><li>It uses objects with key-value pairs. So, if you are familiar with JSON or javascript objects, it will be easier to understand and use NoSQL for you.</li><li>Best suited for storing hierarchical data.</li></ul><h2> </h2><h2>Installation</h2>Installation is quite easy and you can follow mongodb <a href="https://docs.mongodb.com/manual/installation/" rel="noopener noreferrer" target="_blank">docs</a> and install the community edition. If during installation it prompts you to install mongodb compass then install it. It is a GUI application that will help you visualize your databases in an intuitive manner.The two important things that you will get from installation are:<ol><li>mongod : the mongodb server</li><li>mongo : the mongo shell, in which we can issue commands and play with the db</li></ol><h2> </h2><h2>Getting started</h2>In linux, starting mongodb is as easy as typing a few commands in terminal. So let's do it Starting mongod server<pre class="ql-syntax" spellcheck="false"># start server
sudo systemctl start mongod

# start server : alternative way
sudo service mongod start

# check if server running
sudo systemctl status mongod

# check if server running : alternative way
sudo service mongod status

# stop server
sudo systemctl stop mongod

# stop server: alternative way
sudo service mongod stop
</pre>Once server is started, we can connect mongo shell with the running instance. To access mongo shell, use the following command:<pre class="ql-syntax" spellcheck="false">mongo
</pre>Yes, it is as easy as typing&nbsp;mongo&nbsp;and pressing Enter.Hopefully you will be in shell. There will be some warnings and other stuff. To clear the terminal, either type&nbsp;cls&nbsp;in shell and press Enter, or press&nbsp;ctrl + L.To exit out of the shell, type&nbsp;exit&nbsp;and press Enter.<h2> </h2><h2>Basics</h2>Before moving forward, let's discuss some important things that we need to know to understand MongoDB in a better way.<h3> </h3><h3>Database</h3>In mongodb you can have multiple databases on a single mongodb server to hold data in a collective manner. E.g. If you are working on a school application, you would create a school database in which all your collections(similar to table in sql) reside. This database can have collection of students, collection of teachers, etc.A useful command to know when working with databases is:<pre class="ql-syntax" spellcheck="false">&gt; show dbs
</pre>This command will show you all the available databases that you have on your mongo server. And to switch between databases, you can simply type:<pre class="ql-syntax" spellcheck="false">&gt; use &lt;database name&gt;
</pre><h4> </h4><h3>Collections</h3>A collections is like a table in SQL. It holds your record in one place. E.g. You can create a collection of students, in which you can store records of all the students. In these records, you can have student's name, age, class, subjects, percentage etc.A collection holds multiple&nbsp;documents&nbsp;in one place.We will discuss more about collections in further posts.Some useful commands to know for collections are: (switch to a database with&nbsp;use &lt;database name&gt;&nbsp;to use this commands)<pre class="ql-syntax" spellcheck="false"># show all the collections in db
&gt; show collections

# using a collections
&gt; db.&lt;collection name&gt;.find()
</pre><h4> </h4><h3>Documents</h3>Documents are the main records that hold your information in JSON-like format.<pre class="ql-syntax" spellcheck="false">{
 "name": "apple pie",
 "age": 15,
 "colors": ["Green", "Red", "Yellow", "Pink"]
}
</pre>Creating a document is as easy as creating an object in javascript. You can nest values. Have document inside documents. You can have arrays, objects, boolean values, numbers, strings etc. This makes mongodb good for hierarchical data where nesting is required.One thing to keep in mind is that the structure of document is not rigid, that is, it is not necessary for us to define all the fields in all documents. This makes mongodb flexible for unstructured data. <h2>Working with Database</h2>Database will contains all your collections(tables in sql). We will create a database named&nbsp;pies&nbsp;in this post and it will have collections like&nbsp;pies,&nbsp;sauce&nbsp;etc. Create Database<pre class="ql-syntax" spellcheck="false">&gt; use pies
</pre> Check the db in use<pre class="ql-syntax" spellcheck="false">&gt; db
#or
&gt; db.getName()
</pre> Drop db<pre class="ql-syntax" spellcheck="false">&gt; db.dropDatabase()
</pre> Get db stats<pre class="ql-syntax" spellcheck="false">&gt; db.stats()
</pre> Get info about collections in db<pre class="ql-syntax" spellcheck="false">&gt; db.getCollectionInfos()
</pre><h2> </h2><h2>Working with Collections</h2>Collections hold documents together. They are similar to tables in sql. E.g. Just like in sql we can have a table or users with fields such as name, age, gender, occupation etc. we can have a collection of users where documents(JSON-like) can have those fields as well in key value pairs.Example document:<pre class="ql-syntax" spellcheck="false">{
 name: "HellBoy",
 age: 20,
 gender: "male",
 occupation: "Fighter"
}
</pre>CRUD operations are also carried on collections. So, most of our work will revolve around collections from now on. We will create some collections in our&nbsp;pies&nbsp;db and learn some useful methods related to them. Create CollectionIn mongo, collections are automatically created when adding data to a non-existing collection. But to create them explicitly, use the following method:<pre class="ql-syntax" spellcheck="false">&gt; db.createCollection("pies")
</pre> Show Collections in db<pre class="ql-syntax" spellcheck="false">&gt; show collections
# or
&gt; db.getCollectionNames()
</pre> Drop a Collection<pre class="ql-syntax" spellcheck="false">&gt; db.pies.drop()
</pre> Rename a Collection<pre class="ql-syntax" spellcheck="false">&gt; db.pies.renameCollection("pies-renamed")
</pre> Check Collection Stats<pre class="ql-syntax" spellcheck="false">&gt; db.pies.stats()
</pre> Count docs in collection<pre class="ql-syntax" spellcheck="false">&gt; db.pies.count()
</pre><h2> </h2><h2>CRUD Operations</h2>All the operations that we need for creating, reading, updating &amp; deleting are available on collection. Let's see the basic and most used operations you need. CreateThere are two methods that we need to create documents in collection.<ul><li>insertOne</li><li>insertMany</li></ul>Why not add data to our&nbsp;pies&nbsp;collection in&nbsp;pies&nbsp;db.<pre class="ql-syntax" spellcheck="false"># insert one pie 
&gt; db.pies.insertOne({
 name: "Yellow Pie",
 type: "sweet",
 sweetness: 35
})

# insert more than one pie at once
&gt; db.pies.insertMany([
 { name: "Yellow Pie", type: "sweet", sweetness: 44 },
 { name: "Red Pie", type: "sweet", sweetness: 40 },
 { name: "Green Pie", type: "sour", sweetness: 45 },
 { name: "Pink Pie", type: "sweet", sweetness: 40 }
])
</pre> ReadFor reading data from our collection, we can just need two methods. These methods have several operators and options that can help us filter our data according to our needs.<ul><li>find: returns multiple documents</li><li>findOne: returns the first document only</li></ul>In these two operations, we can pass filters. If no filter passed, it will return all the documents in case of&nbsp;find&nbsp;and first document in case of&nbsp;fineOne<pre class="ql-syntax" spellcheck="false"># find one 
&gt; db.pies.findOne({ name: "Green Pie" })

# find all sweet type pies
&gt; db.pies.find({ type: "sweet "}) 

# find pies with sweetness greater than 40
&gt; db.pies.find({ health: { $gt: 40 } })

# find pies with type sweet and sweetness greater than 40
&gt; db.pies.find({ type: "sweet", sweetness: { $gt: 40 }})
</pre>In the above example, there is&nbsp;$gt&nbsp;operator that we used. There are other operators and we will discuss in later posts. UpdateAgain, we have two methods for updating documents<ul><li>updateOne</li><li>updateMany</li></ul>Both takes a filter, just like find, to find the document that we need to update, and an object that defines what we want to update. We use&nbsp;$set&nbsp;operator to update fields in a document.<pre class="ql-syntax" spellcheck="false"># update one pie
&gt; db.pies.updateOne(
 { name: "Green Pie" },
 { $set: { Sweetness: 30 }}
)

# update multiple pie and add sourness to yellow types
&gt; db.pies.updateMany(
 { type: "yellow" },
 { $set: { sourness: 25 }}
)

# increment sweetness of red-pie by 10 and also add sourness
&gt; db.pies.updateOne(
 { name: "Red Pie" },
 { 
 $inc: { sweetness: 10 },
 $set: { sourness: 10 }
 }
)
</pre>In above examples, you can see, we can change multiple fields in one update.&nbsp;$inc&nbsp;is one operator you see here that we can use to increment/decrement&nbsp;Number&nbsp;types. There are other operators that we will discuss later. DeleteOur last operation is Delete.<ul><li>deleteOne</li><li>deleteMany</li></ul>Both are similar to update and find methods. They take a filter to identify the document that we want to delete. Let's see some examples:<pre class="ql-syntax" spellcheck="false"># delete one pie
&gt; db.pies.deleteOne({ name: "Yellow Pie" })

# delete pies with health greater than or equal to 40
&gt; db.pies.deleteMany({sweetness: { $gte: 30 }})

# delete all pies !!
&gt; db.pies.deleteMany({})
</pre>But that's how delete methods work. As you can see, it is similar to finding the document or documents. If you can find it, you can delete it. In the above example we used an operator&nbsp;$gte. It stands for greater than equal. And you can see how it is used to query data. Happy Coding ...

MongoDB Tutorial for Beginners

Related blogs

About us: