Introduction to MongoDB - How to use Records and Values




Introduction to MongoDB - How to use Records and Values

Getting Set Up 

Kindly read the main aide in this series for more data about setting up MongoDB - Installation, Shell, and Database Engineering. 

Bulk Insertion 

That's right, you read that right. Like MySQL, you can likewise embed numerous records at a solitary point on schedule. A similar supplement() work takes protests as well as clusters as information. This time, we will be apathetic and make something straightforward for the following two records. 

db.students.insert([
  {
    name: "User1",
    degree: "Engineering",
    email: "user1@example.com"
  },
  {
    name: "User 2",
    degree: "Engineering",
    email: "user2@example.com",
    phone: ["2589636988"]
  }
]);

You can see that the above records are both unique. This leads us to the greatest benefit of Document Databases. You needn't bother with a fixed construction for the records and each record can be any legitimate JavaScript articulation. 

Evolving pattern "on the fly" is the greatest benefit of utilizing NoSQL. 

Presently, we should take a stab at executing the above embed inquiry on our data set. 

> db.students.insert(
...   [
...     {
...       "name": "User1",
...       "degree": "Engineering",
...       "email": "user1@example.com"
...     },
...     {
...       "name": "User 2",
...       "degree": "Engineering",
...       "email": "user2@example.com",
...       "phone": ["2589636988"]
...     },
...   ]
... );
BulkWriteResult({
    "writeErrors" : [ ],
    "writeConcernErrors" : [ ],
    "nInserted" : 2,
    "nUpserted" : 0,
    "nMatched" : 0,
    "nModified" : 0,
    "nRemoved" : 0,
    "upserted" : [ ]
})
>

You get the yield of the BulkWriteResult work, where it says nothing for mistakes and we have a check of '2' for the embedded records. How about we rapidly check our table substance by utilizing find() strategy. 

> db.students.find();
{ "_id" : ObjectId("592ebe7e8e61243307417cc4"), "name" : "Praveen Kumar", "degree" : "Cloud Computing", "email" : "praveen@example.com", "subjects" : [ { "name" : "Internet Networks", "prof" : "Prof. Awesome Blossom" }, { "name" : "Cloud Computing", "prof" : "Prof. Tech Ninja" }, { "name" : "Web Development", "prof" : "Prof. Chunky Monkey" } ], "phone" : [ "123456780", "9967728336", "7772844242" ] }
{ "_id" : ObjectId("592ed5818e61243307417cc5"), "name" : "User1", "degree" : "Engineering", "email" : "user1@example.com" }
{ "_id" : ObjectId("592ed5818e61243307417cc6"), "name" : "User 2", "degree" : "Engineering", "email" : "user2@example.com", "phone" : [ "2589636988" ] }
>

We got the three records and each has distinctive construction, which is extraordinary! Since there are an excessive number of fields, how about we make it pretty(): 

> db.students.find().pretty();
{
    "_id" : ObjectId("592ebe7e8e61243307417cc4"),
    "name" : "Praveen Kumar",
    "degree" : "Cloud Computing",
    "email" : "praveen@example.com",
    "subjects" : [
        {
            "name" : "Internet Networks",
            "prof" : "Prof. Awesome Blossom"
        },
        {
            "name" : "Cloud Computing",
            "prof" : "Prof. Tech Ninja"
        },
        {
            "name" : "Web Development",
            "prof" : "Prof. Chunky Monkey"
        }
    ],
    "phone" : [
        "123456780",
        "9967728336",
        "7772844242"
    ]
}
{
    "_id" : ObjectId("592ed5818e61243307417cc5"),
    "name" : "User1",
    "degree" : "Engineering",
    "email" : "user1@example.com"
}
{
    "_id" : ObjectId("592ed5818e61243307417cc6"),
    "name" : "User 2",
    "degree" : "Engineering",
    "email" : "user2@example.com",
    "phone" : [
        "2589636988"
    ]
}
>

Querying Records

For questioning or sifting the fields, we need to pass them as boundary objects in the find() work. One model will be, we should check whether I can get the record with Meaow: 

> db.students.find({"name" : "User 2"});
{ "_id" : ObjectId("592ed5818e61243307417cc6"), "name" : "User 2", "degree" : "Engineering", "email" : "user2@example.com", "phone" : [ "2589636988" ] }
>

Also, not surprisingly, our pretty() would return: 

> db.students.find({"name" : "User 2"}).pretty();
{
    "_id" : ObjectId("592ed5818e61243307417cc6"),
    "name" : "User 2",
    "degree" : "Engineering",
    "email" : "user2@example.com",
    "phone" : [
        "2589636988"
    ]
}
>

This additionally works for things inside exhibits. The find() technique claims matches of the qualities here. Here is one more model for coordinating with a number inside an exhibit: 

> db.students.find({"phone": "123456780"}).pretty();
{
    "_id" : ObjectId("592ebe7e8e61243307417cc4"),
    "name" : "Praveen Kumar",
    "degree" : "Cloud Computing",
    "email" : "praveen@example.com",
    "subjects" : [
        {
            "name" : "Internet Networks",
            "prof" : "Prof. Awesome Blossom"
        },
        {
            "name" : "Cloud Computing",
            "prof" : "Prof. Tech Ninja"
        },
        {
            "name" : "Web Development",
            "prof" : "Prof. Chunky Monkey"
        }
    ],
    "phone" : [
        "123456780",
        "9967728336",
        "7772844242"
    ]
}
>

The above order effectively distinguishes my record and shows it, despite the fact that 123456780 is just one of three numbers present. 

Updating Records 

The technique we use here is db.collection.update(). It takes up two boundaries and the principal boundary is an object of a key worth pair for a match that is available in the records. The following boundary is the substance that the principal boundary should be supplanted with. 

So how about we take a stab at something like this: 

db.students.update(
  { name: "Praveen Kumar" },
  {
    name: "Praveen Kumar",
    degree: "Cloud Computing MSc",
    email: "praveen@example.net",
    subjects: [
      {
        name: "Internet Networks",
        prof: "Prof. Awesome Blossom"
      },
      {
        name: "Cloud Computing",
        prof: "Prof. Tech Ninja"
      },
      {
        name: "Web Development",
        prof: "Prof. Chunky Monkey"
      }
    ],
    phone: ["123456780", "9967728336", "7772844242"]
  }
);
  • Note 1: You need to give the full article if there should be an occurrence of update work, since it makes a supplanting of the entire record with the subsequent boundary. In the event that we didn't set different qualities, it will simply have one record with only two of the things: the email and the degree. 
  • Note 2: Do not find by name, as I just did, assuming there is any chance of this happening. There might be numerous records coordinating with a similar boundary, so use something remarkable like _id. 

Attempting the abovementioned, we get: 

> db.students.update({"name": "Praveen Kumar"}, {
...   "name": "Praveen Kumar",
...   "degree": "Cloud Computing MSc",
...   "email": "praveen@example.net",
...   "subjects": [
...     {
...       "name": "Internet Networks",
...       "prof": "Prof. Awesome Blossom"
...     },
...     {
...       "name": "Cloud Computing",
...       "prof": "Prof. Tech Ninja"
...     },
...     {
...       "name": "Web Development",
...       "prof": "Prof. Chunky Monkey"
...     }
...   ],
...   "phone": ["123456780", "9967728336", "7772844242"]
... });
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
>

Presto! We should see the outcomes: 

{
  "nMatched": 1,
  "nUpserted": 0,
  "nModified": 1
}

It coordinated with one record and it changed it. There's none upserted (we'll cover this later). This implies that there's plausible that it may coordinate, however not update. How about we run a similar order again and see what occurs. 

Gracious dear! It shows a similar yield. Perhaps I was over-energetic. 

To perceive what has transformed, we could attempt to run the find() work alongside our pretty pretty() work. 

> db.students.find({"phone": "123456780"}).pretty();
{
    "_id" : ObjectId("592ebe7e8e61243307417cc4"),
    "name" : "Praveen Kumar",
    "degree" : "Cloud Computing MSc",
    "email" : "praveen@example.net",
    "subjects" : [
        {
            "name" : "Internet Networks",
            "prof" : "Prof. Awesome Blossom"
        },
        {
            "name" : "Cloud Computing",
            "prof" : "Prof. Tech Ninja"
        },
        {
            "name" : "Web Development",
            "prof" : "Prof. Chunky Monkey"
        }
    ],
    "phone" : [
        "123456780",
        "9967728336",
        "7772844242"
    ]
}
>

Utilizing '$set' 

It's a torment to add the entire record once more, just to transform one single worth. The uplifting news is, there's a way around that: utilizing the $set administrator. Let's assume we need to change my email to praveen@example.net. All that we require to do is: 

db.students.update(
  {
    name: "Praveen Kumar"
  },
  {
    $set: {
      email: "praveen@example.net"
    }
  }
);

Quick and painless! Presently how about we see the yield of the above order. 

> db.students.update({
...   "name": "Praveen Kumar"
... }, {
...   $set: {
...     "email" : "praveen@example.net"
...   }
... });
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
>

This $set is to some degree like our SQL's UPDATE inquiry. At the point when the question is terminated, it keeps the all around existing worth flawless and updates the particular fields. Like UPDATE, $set shows the number of columns the question has influenced. 

On the off chance that we see the above outcome, we can track down that the order has coordinated with one and adjusted one, yet not upserted any. On the off chance that we attempt to run a similar order once more, it will give the accompanying outcome: 

WriteResult({ nMatched: 1, nUpserted: 0, nModified: 0 });

Fantastic! Presently we know see that coordinated and altered have various tallies. This implies, regardless of whether you continue to send a similar order for update without the $set administrator, the adjustment continues to happen constantly, while the $set administrator gets it going just in case there are various qualities. 

Note: $set is more execution proficient, in case you are making a great deal of updates.

Increasing Numeric Values 

There's another administrator that helps us increase numeric qualities. Consider a record that has some numeric boundary, for example, a field called focuses. focuses are incredible on the grounds that they need to augment much of the time. Being apathetic, I will utilize the $set work:

db.students.update(
  {
    name: "Praveen Kumar"
  },
  {
    $set: {
      points: 15
    }
  }
);

Executing the above order, we get this: 

> db.students.update({
...   "name": "Praveen Kumar"
... }, {
...   $set: {
...     "points" : 15
...   }
... });
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
>

Also, checking in the event that it has been refreshed, we fire out the find() order and we get:

> db.students.find({"phone": "123456780"}).pretty();
{
    "_id" : ObjectId("592ebe7e8e61243307417cc4"),
    "name" : "Praveen Kumar",
    "degree" : "Cloud Computing MSc",
    "email" : "praveen@example.com",
    "subjects" : [
        {
            "name" : "Internet Networks",
            "prof" : "Prof. Awesome Blossom"
        },
        {
            "name" : "Cloud Computing",
            "prof" : "Prof. Tech Ninja"
        },
        {
            "name" : "Web Development",
            "prof" : "Prof. Chunky Monkey"
        }
    ],
    "phone" : [
        "123456780",
        "9967728336",
        "7772844242"
    ],
    "points" : 15
}
>

Fantastic. We have a focuses field in my record with a worth of 15. 

That whole cycle ought to be clear at this point. In the case of something is hazy, glance back at the past segment of the aide as well as shoot an inquiry for extra clearness. 

Continuing on, I complete this article, subsequently acquiring 5 additional focuses. This condition can be created with one little change: 

db.students.update(
  {
    name: "Praveen Kumar"
  },
  {
    $inc: {
      points: 5
    }
  }
);

As should be obvious, changing $set to $inc, has the effect. This is like utilizing the increased task administrator += in standard dialects, instead of the task administrator =. 
 

> db.students.update({
...   "name": "Praveen Kumar"
... }, {
...   $inc: {
...     "points" : 5
...   }
... });
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.students.find({"phone": "123456780"}).pretty();
{
    "_id" : ObjectId("592ebe7e8e61243307417cc4"),
    "name" : "Praveen Kumar",
    "degree" : "Cloud Computing MSc",
    "email" : "praveen@example.com",
    "subjects" : [
        {
            "name" : "Internet Networks",
            "prof" : "Prof. Awesome Blossom"
        },
        {
            "name" : "Cloud Computing",
            "prof" : "Prof. Tech Ninja"
        },
        {
            "name" : "Web Development",
            "prof" : "Prof. Chunky Monkey"
        }
    ],
    "phone" : [
        "123456780",
        "9967728336",
        "7772844242"
    ],
    "points" : 20
}
>

Goodness, that was a simple augmentation for me from 15 to 20. Obviously, utilizing $inc is an incredible method to increase numeric qualities.



Author Biography.

Lokesh Gupta
Lokesh Gupta

Overall 3+ years of experience as a Full Stack Developer with a demonstrated history of working in the information technology and services industry. I enjoy solving complex problems within budget and deadlines putting my skills on PHP, MySQL, Python, Codeigniter, Yii2, Laravel, AngularJS, ReactJS, NodeJS to best use. Through Knowledge of UML & visual modeling, application architecture design & business process modeling. Successfully delivered various projects, based on different technologies across the globe.

Join Our Newsletter.

Subscribe to CrowdforThink newsletter to get daily update directly deliver into your inbox.

CrowdforJobs is an advanced hiring platform based on artificial intelligence, enabling recruiters to hire top talent effortlessly.

CrowdforJobs

CrowdforApps brings to you the well researched list of the most successful and finest App development companies, Web software developers.

CrowdforApps

CrowdforGeeks is where lifelong learners come to learn the skills they need, to land the jobs they want, to build the lives they deserve.

CrowdforGeeks

CrowdforThink is a leading Indian media and information platform, known for its end-to-end coverage of the Indian startup ecosystem.

CrowdforThink
CFT

News & Blogs

Top Authors

Lamia Rochdi is the Marketing Manager at Bell Flavors & Fragrances EMEA. A successful family-...

Lamia Rochdi

Zakariya has recently joined the PakWheels team as a Content Marketing Executive, shortly after g...

Zakariya Usman

Hey, I am Suraj - a full-time blogger and a social media expert currently working on the Growth H...

Suraj Kumar

Overall 3+ years of experience as a Full Stack Developer with a demonstrated history of working i...

Lokesh Gupta
CFT

Our Client Says

WhatsApp Chat with Our Support Team