NoSQL CRUD Operations Made Easy | A 101 Guide

NoSQL is a broad term that describes various database technologies that don’t conform to the traditional relational database model. CRUD stands for create, read, update, and delete and refers to the basic functions you’ll need to perform on your data. CRUD operations are usually performed using a language like SQL, but NoSQL databases often use different query languages or APIs. This can make it challenging to switch from a traditional relational database to a NoSQL database.

There are many different NoSQL databases, but some of the most popular ones include MongoDB, Cassandra, and Couchbase. And each of these databases have different query languages.

In this blog, you will come to know about NoSQL Databases and CRUD Operations.. You will also see how to run NoSQL CRUD operations using MongoDB.

Prerequisites

• Understanding of databases

What are CRUD Operations?

Organizations have to keep track of customer data, accounts, payment information, and other records that require persistent storage. The basic operations performed on such data stored in databases are known as CRUD operations. CRUD stands for Create, Read, Update, and Delete.

A relational database has tables with columns and rows. Each row describes a single data point, such as an employee’s name, address, phone number, salary, and so on. Each column represents a category of information, such as the employee’s age, gender, marital status, and so forth. These data can be manipulated using the CRUD (Create, Read, Update, and Delete) operations in a database. These operations allow users to create records, read existing records, update existing records, and delete existing records. 

The operations are as follows:

• Create
• Read
• Update
• Delete

1) Create 

The Create operations enables users to insert new records into the database. It is same as the functioning of the INSERT function in SQL relational database application. Only an admin can add new attributes to the table. Whereas, a user can create rows and populate them with data corresponding to each attribute.

2) Read

Similar to the search function, Read enables users to look up particular records in the table and access their values. Users can look for keywords or filter the data based on customized criteria to find records. 

3) Update

The Update operation modifies existing records in the database. It is useful when an existing record in the database must be changed along with all the attribute values. You can update one or more existing records into the new record by using the updateOne() or updateMany() functions.

4) Delete

Users can delete values with the Delete operation to remove records that are no longer needed. Users can delete one or more records at a time by specifying the right functions i.e, deleteOne() or deleteMany(). 

What are NoSQL Databases?

NoSQL is a term used to describe a non-relational database. A NoSQL database does not use the traditional table-based relational database management system (RDBMS). It’s often used in Big Data applications because they can scale more easily and handle large amounts of data. They are often more scalable than relational databases. These databases can also offer improved performance as they are designed to be distributed; they can take advantage of parallel processing to speed up data access.

NoSQL databases can also be more flexible because they don’t have to adhere to the rigid table structure of an RDBMS. However, NoSQL databases can be more difficult to query and less reliable than relational databases. NoSQL databases are increasing in popularity as more and more organizations look to adopt them for their data storage needs. There are many benefits that NoSQL databases can offer, including scalability, improved performance, and easier management.

Getting Started with NoSQL CRUD Operations in MongoDB

Depending on your preferences and development environment, there are a few different ways to implement NoSQL CRUD operations. In this case, MongoDB, a powerful NoSQL database is used to showcase the implementation of CRUD Operations.

Before implementing the CRUD operations, you first need to connect to the MongoDB Server. For that, you need to open the Mongo Shell and connect it to a MongoDB database by using the following command.

ssh admin@your_server_ip

Then you need to connect a MongoDB user with privileges to write and read data.

After doing this, you can implement the following NoSQL CRUD Operations in MongoDB in a step-wise manner.

1) Creating Documents

The Create in the NoSQL CRUD Operations in MongoDB indicates the creation of a data document.

You can create a document in MongoDB with information about historical monuments, their name, geographical location, country, and city. You can follow the below code snippet for creating the document.

{
    "name": "The Pyramids of Giza",
    "city": "Giza",
    "country": "Egypt",
    "gps": {
        "lat": 29.976480,
        "lng": 31.131302
    }
}

The code is written in BSON, a binary format of JSON. The data is represented in the form of field: value pairs.

The two important commands to create documents in MongoDB are:

• insertOne()
• insertMany()

You need to run the following command to insert the above-created Document into Monuments, a new Collection with the insertOne() method:

db.monuments.insertOne(
  {
    "name": "The Pyramids of Giza",
    "city": "Giza",
    "country": "Egypt",
    "gps": {
      "lat": 29.976480,
      "lng": 31.131302
    }
  }
)

You can use the insertmany() command when you want to insert multiple inputs. Use the following command to insert multiple values in the Document.

db.monuments.insertMany([
  {"name": "The Valley of the Kings", "city": "Luxor", "country": "Egypt", "gps": { "lat": 25.746424, "lng": 32.605309 }},
  {"name": "Arc de Triomphe", "city": "Paris", "country": "France", "gps": { "lat": 48.873756, "lng": 2.294946 }},
  {"name": "The Great Wall of China", "city": "Huairou", "country": "China", "gps": { "lat": 40.431908, "lng": 116.570374 }},
  {"name": "The Eiffel Tower", "city": "Paris", "country": "France", "gps": { "lat": 48.858093, "lng": 2.294694 }},
  {"name": "The Statue of Liberty", "city": "New York", "country": "USA", "gps": { "lat": 40.689247, "lng": -74.044502 }}
])

2) Reading Documents

Now, you can query the database to retrieve the Document from the database and read its data. 

There are two methods to read data in MongoDB

• find()
• findOne()

You can use the following command to retrieve all the documents from a database:

db.monuments.find()

You can also give an objectId as an identifier to return only a specific document:

db.monuments.find({"country": "France"}).pretty()

3) Updating Documents

The Update in NoSQL CRUD Operations can be implemented in MongoDB by updating the Documents using the following two methods:

• updateOne()
• updateMany()

You can use it to update one or all Document(s) in the database. Use the following code to update Arc de Triomphe to Arc de Triomphe de l’Étoile, it’s full name. 

db.monuments.updateOne(
  { "name": "Arc de Triomphe" },
  {
    $set: { "name": "Arc de Triomphe de l'Étoile" }
  }
)

Similarly, updateMany() can be used to add more attributes to the Documents collection. 

4) Deleting Documents

The Delete in the NoSQL CRUD Operations can be implemented by deleting records from a MongoDB collection. The method to do this are as follows:

• deleteOne()
• deleteMany()

You can begin by removing the Arc de Triomphe de l’Étoile monument Document you modified previously:

db.monuments.deleteOne(
    { "name": "Arc de Triomphe de l'Étoile" }
)

Alternatively, you can delete Documents that have a common attribute. 

db.monuments.deleteMany(
  { "country": "France" }
)

This time, all the monuments in France, including The Eiffel Tower and Arc de Triomphe de l’Étoile will be removed. 

You can explore more about data replication in NoSQL Databases to get a better understanding of your NoSQL Data.

Conclusion

In this article, you learned about the CRUD operations and NoSQL databases. You also had an in-depth understanding of implementing the CRUD operations in MongoDB.

Now, you can move forward and use the COUNT() function to count the number of rows in a table according to your requirements.

It will take a lot of time to import and move data into your selected warehouse by using ETL for Data Analysis with MongoDB as your data source. When you consider how much money and resources are required to engage data engineers and analysts to make sense of this data, the issue becomes even more daunting.

However, with Hevo at your fingertips, you won’t have to worry about your MongoDB Data Replication demands. It will just take a few minutes to load your data into your chosen data warehouse.

Hevo’s strong integration with 150+ Data Sources (including 40+ Free Sources) like MongoDB, you can export data from your selected data sources and load it to the destination of your choice. It also assists you with reorganizing and enhancing your data so that it is ready for analysis. Now, you can readily save your time and focus on gaining insights and doing in-depth research on your data using BI solutions.

Sign up for a 14-day free trial and simplify your data integration process. Check out the pricing details to understand which plan fulfills all your business needs.

Frequently Asked Question