How to Create a Database in MongoDB in 5 Minutes?

What is a Database Command in MongoDB?

Database commands are like helper functions that allow us to write/send the data to the database. These commands are also used to modify the structure or documents that are present inside the database and helps in MongoDB create database.

We will look at some important commands which are MongoDB sort command, MongoDB find command, etc.

Before we start learning the MongoDB create database commands, let’s have a look at the entire tutorial outline.

• Database Creation Using MongoDB Insert Command
  • Syntax
  • Example
• Primary Key in MongoDB
• MongoDB Limit and MongoDB Sort Commands
  • MongoDB Limit Command
  • MongoDB Sort Command
• MongoDB Find Command
  • Syntax
  • Syntax for the Find with Pretty Command
  • Example
• MongoDB Update Command
  • Syntax
  • Example
• MongoDB Count and Remove Commands
  • MongoDB Count Command
  • MongoDB Remove Command
  • Syntax
  • Example
• Concept of MongoDB Cursor
  • Example
  • cursor.explain()

Kick-start your career in MongoDB with the perfect MongoDB Training Course now!

The most important part of MongoDB create database is MongoDB insert command to insert data into MongoDB collection. We can use two methods here; they are insert() or save()methods.

The basic syntax of MongoDB insert command is as follows:

db.COLLECTION_NAME.insert(document)

In the above code, mycommand is the name of our MongoDB collection. If the collection doesn’t exist in the database, then MongoDB creates the collection itself and then inserts a document into it.

In the MongoDB document that we have inserted, if we don’t specify the _id parameter, then MongoDB assigns a unique ObjectId for this document by default.
Let me tell you about the _id. It is a 12-byte hexadecimal number unique for every document in a collection. 12 bytes are divided as follows:

_id: ObjectId (4 bytes for timestamp, 3 bytes for machine id, 2 bytes for process id, and 3 bytes for incrementer)

Let’s see an example of code with _id:

db.mycommand.insert({
    _id: ObjectId(7df78ad8902c),
    title: 'MongoDB Overview', 
    description: 'MongoDB is no sql database',
    by: 'Intellipaat',
    url: 'http://www.intellipaat.com',
    tags: ['mongodb', 'database', 'NoSQL'],
    likes: 100
})

As we have inserted the data into MongoDB collection, now we will see how to view the inserted data. To view the inserted data in MongoDB create database, we will use the following command:

db.mycol.find().pretty()

The find() command will give us our data and the pretty() command is used to display the result in a formatted way.

Further in this tutorial, we will cover MongoDB find command in detail.

Get familiar with the top MongoDB Interview Questions to get a head start in your career!

Now, we will discuss the primary key in the MongoDB create database. The _id field works as the primary key for the MongoDB collection so that each document can be uniquely identified in the collection. There is a unique ObjectId value associated with each _id field by default, which is a hexadecimal number.

However, we do not need to worry about inserting the primary key in our queries because, by default, when inserting documents in MongoDB collection, if you forget to add a field name with the _id, then MongoDB automatically handles the situation and adds an ObjectId field as shown below:

In the above code, we have not mentioned the _id field, but when we run that code the _id appears by default in the output of the code.

For modifying the queries, MongoDB provides query modifiers that are limit() and sort() clauses. These provide more flexibility when executing queries. We will have a look at these query modifiers.

MongoDB limit is used to limit the number of documents that are returned in the result set for a query. Below is an example that shows how this can be done.

db.mycommand.find().limit(2).forEach(printjson)

The above code takes the find function that returns all the documents created by MongoDB create database in the MongoDB collection. But, the limit clause in the code limits the number of documents being returned to just 2.

The MongoDB sort command is used to specify the order of documents to be returned based on an ascending or descending order of any key in MongoDB collection. Below is an example which shows how this can be done.

db.mycommand.find().sort({mycommandid:-1}).forEach(printjson);

The above code is using the MongoDB sort function that returns all the documents in MongoDB collection, but then it is using the modifier to change the order in which the records are returned. The number ‘-1’ in the above code indicates that we need to return the documents based on the descending order of mycommandid.

Let’s see the live code below:

We use MongoDB find method to query data from MongoDB collection.

The basic syntax of the find() method is as follows:

db.COLLECTION_NAME.find()

As we have mentioned earlier, the MongoDB find method will display all the documents in a non-structured way.

Another method we use with our MongoDB find method is the pretty() Method. The pretty() method is used to display the results in a formatted way.

The syntax of the find() command with the pretty() command is as given below:

db.mycol.find().pretty()

Apart from the find() method, there is yet another method, which is the findOne() method that returns only one document.

To have a detailed comparison between Firebase and MongoDB, check out Firebase Vs MongoDB!

The MongoDB update method is used to update the MongoDB document into a collection. The update method updates the values in the existing document.

The basic syntax of the update() method is as follows:

db.COLLECTION_NAME.update(SELECTION_CRITERIA, UPDATED_DATA)

First, we will create a database with some details. Next, we will change the name, and then we will use the update command to see whether our database has been updated or not.

After creating our first database, we got the following output.

Now, we will update it with the update method.

Here is our updated data as given below. We can see that all the values have been changed.

MongoDB provides the count() function that is used to know the count of documents in a collection as per the query fired.

 db.mycommand.count()

We can see that the output comes as ‘4’, i.e., the number of documents in the MongoDB collection is 4.

To remove documents from a MongoDB collection, MongoDB uses the remove() method. This command either removes all of the documents from a collection or only those that match a specific condition.

If we just issue the remove command, then all documents will be removed from the collection.

db.collection.remove()

db.university.remove({})

db.university.remove({some_condition})