DEV Community: Dipayan Sanyal

Read Operation - I / MongoDB

Dipayan Sanyal — Mon, 23 Nov 2020 14:32:29 +0000

Query Operator -- Comparision

db.<collection>.find({runtime: {$eq: 60}}) == db.<collection>.find({runtime: 60})
The above is an equality operator. Without the comparison, it just works fine.

db.<collection>.find({runtime: {$ne: 60}})
db.<collection>.find({runtime: {$gt: 60}})
db.<collection>.find({runtime: {$lt: 60}})
The above is a non equality operator. Respectively, greater than, lesser than. For other operators, have a look here.

In case we have to query embedded documents, we have to use the dot notation within inverted commas, otherwise the dot notation will not be accepted and understood. Lets take a doc for example,

{
    "rating" : {
        "average" : 3
        "channels" : ["CBS", "NBC", "Fox"]
    }
}

The query would be ...
db.<collection>.find({"rating.average" : 3})
We can use other operators as well with this type of querying.

For arrays (if embedded, similar dot notation would be used..), the querying has a trick. If we want to match just one of the string in the array set,
db.<collection>.find({"rating.channels": "CBS"})
If we intend to match the entire array, then we have to set and look for the entire array..,
db.<collection>.find({"rating.channels": ["CBS", "NBC", "Fox"]})

db.<collection>.find({"runtime": {$in: [30, 42]}})
The $in operator takes in an array of values but does not look for an array. It matches for discrete values in the dataset and will only return those that matched. Just opposite to this is the $nin, which will return values but the ones specified in the array.

=============================

Query Operator -- Logical

$or || $nor

The $or operator works exactly like how logically it should. Its just the syntax we have to keep in mind.

db.movies.find({$or: [{"rating.average": {$lt: 5}}, {"rating.average": {$gt: 9.3}}]})

Essentially we write the $or in the beginning of the query and use array to conjugately search for all the conditions. The $nor operator has a similar syntax and returns exactly what $or returns.

db.movies.find({$nor: [{"rating.average": {$lt: 5}}, {"rating.average": {$gt: 9.3}}]})

$and

The $and operator works similarly.

db.movies.find({$and: [{genres: "Horror"}, {genres: "Drama"}]}) db.movies.find({$and: [{genres: "Horror"}, {"rating.average": {$gt: 8}}]})

Again, it conjugates the different conditions and returns a matching result.

$not

You may assume the $not operator works like $ne, and you are correct. Although we can write the query as follows,

db.movies.find({runtime: {$not: {$eq: 60}}}) is the same as db.movies.find({runtime: {$ne : 60}})

=============================

Query Operator -- Elements

$exists

Lets say in our collection we wanna find all persons who have a 'age' field..
db.users.find({age: {$exists : true}})
db.users.find({age: {$exists : true, $ne : null}})

The strange way of passing two operators at the sametime is because mongodb implicitly uses and to concatenates values separated by comma. It uses "AND" implicitly.

$type

All kind of types in mongodbo official webpage.
However it works pretty straight forward.
db.users.find({phone: {$type : "double"}})

since the shell is written in JS, passing double or number would behave the same way in most cases.

We can also use type a bit differently to check for multiple types.
db.users.find({phone: {$type : ["double", "string"]}})

=============================

Query Operator -- Arrays

Lets say we have a collection as follows :

{
    "hobbies": [
            {
                "title" : "Sports",
                "freq" : 3
            },
            {
                "title" : "Yoga",
                "freq" : 4
            }
        ]
},
{
    "hobbies": [1,2,3]
},
{
    "hobbies": ['Cooking', 'Soccer']
},
{
    "hobbies": ['Soccer', 'Cooking']
},
{
    "hobbies": [
            {
                "title" : "Yoga",
                "freq" : 3
            },
            {
                "title" : "Cooking",
                "freq" : 5
            }
        ]
}

In order to find a person with hobby as Sports, we have to write the following query :
db.<collection>.find({"hobbies.title" : "Sports"})

Although we treat the array of embedded docs as single embedded doc, but eventually the above query will look for title field in all of the embedded docs and match it to "Sports"..

$size

Now in order to find the result with the maximum number of hobbies, we could write a query that looks like this..

db.<collection>.find({hobbies : {$size : 3}})

This will essentially return the document/s where the hobbies array has length: 3. By the way this is a strict quality and mongo db currently do not support for comparision.

$all

In order to find a document that contains multiple fields/values in an array, we can use the following query:
db.<collection>.find({hobbies: ['Cooking', 'Yoga']})

This would work, in the way that the query will be looking for the exact match. It would return the 3rd document from the above collection. But should we want documents that contain the above information in any order we must write the following query:
db.<collection>.find({hobbies: {$all: ['Cooking', 'Yoga']}})

$elemMatch

Now, when our array field is an array of documents, and we are looking for specific sets of field in that array of documents, then we use $elemMatch. In the above example if we use the following query it would not work as expected :
db.<collection>.find({$and: {"hobbies.title": "Yoga", "hobbies.freq": {$gt : 4}}})

This would actually return the last document, even though there is no one doing Yoga at a freq of 4. This happens because mongodb is trying to find the document where the above condition exists, maybe not together, but definitely there. You see Cooking has a frequency of 5.

But in order to make the query work perfectly fine, we use $elemMatch
db.<collection>.find({hobbies : {$elemMatch: {"title": "Yoga", "freq": {$gt: 4}}}})
The above will return nothing.

But the below will return the last document..
db.<collection>.find({hobbies : {$elemMatch: {"title": "Yoga", "freq": {$gte: 4}}}})

Why? If you get the answer, write in the comments.

Javascript -- Array and useful methods

Dipayan Sanyal — Sat, 21 Nov 2020 08:24:58 +0000

join() method joins an arrow using a delimiter.

arr = [1,2,3,4];
var a = arr.join(' '); // a = 1234;

join() method acts like the toString() except we can specify the delimiter.

*pop() deletes the last element in the array *
// returns the value that was popped.
*push() pushes an element in the last grid of the array *
// returns the new length of the array.

*shift() removes the first element in the array *
// returns the removed value.
*unshift() pushes an element in the first grid of the array *
// returns the new length of the array.

splice(position, number of elements, new elements);
splice helps in deleting elements of the array and sending out the same array not a copy.

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.splice(2, 0, "Lemon", "Kiwi");
//returns [ Banana,Orange,Lemon,Kiwiz,Apple,Mango ]

fruits.splice(2,2, "Pom", "Straw");
//returns [ Banana,Orange,Pom,Straw,Apple,Mango ]

fruits.splice(2,2);
//returns [ Banana, Orange, Apple, Mango ]

The concat() method creates a new array by merging (concatenating) existing arrays:

var myGirls = ["Cecilie", "Lone"];
var myBoys = ["Emil", "Tobias", "Linus"];
var myChildren = myGirls.concat(myBoys); 
// concatenates (joins) myGirls and myBoys

The concat() method also takes string as arguments. We can also use two arrays in the argument to concat three arrays.

The slice() method slices out a piece of an array into a new array.
This example slices out a part of an array starting from array element 1 ("Orange"):

var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
var citrus = fruits.slice(1);
// returns [“Orange”, “Lemon”, “Apple”, “Mango”];

It is important to understand that this method returns a new array!
The slice() method can take 2 arguments like slice(1,3)
The method then selects elements from the start argument, and up to (but not including) the end argument.

var citrus = fruits.slice(1,3); // returns [“Orange”, “Lemon”]

The sort() method sorts an array alphabetically. The reverse() method reverses the element in an array.
However, by default sort() method sorts values as strings. So, in order to sort numbers we have to use compare function. Let’s use an example.

var points = [20, 30, 10 4, 70, 44];
points.sort(); 
// returns [ 10,20,30,4,44,70 ] since the problem is 2 comes after 1 and so on.

So using compare functions we can solve this problem.

var points = [20, 30, 10 4, 70, 44];
points.sort(function(a,b) {return a-b}); // ascending order.
// here two elements are pitted against each other. If the result //is negative, a is sorted before b, and if result is positive //then b is sorted before a.
var points = [40, 100, 1, 5, 25, 10];
points.sort(function(a, b){return 0.5 - Math.random()});
// sorts randomly

Sorting object arrays.

var cars = [
    {type: ‘Volvo’, year:2016},
    {type: ‘BMW’, year:2018},
    {type: ‘Merc’, year: 2019}
];
cars.sort((a,b) => a.year - b.year);

Write Operation / MongoDB

Dipayan Sanyal — Sat, 21 Nov 2020 08:13:08 +0000

db.<collection>.insert([{},{}], {ordered:false})

If we set ordered to false, then inserting a set of documents (some of with same id as previously inserted docs) will not completely bring the insertion functionality to a halt. It would rather look for other documents as well hoping to find new ids to insert.

db.<collection>.insert([{},{}], {w:1, j: undefined})

w simply means to write. And the number indicates to how many instances, in case we are using multiple instances on one server, we want this write to be acknowledged. w : 1 is the default and it says hey the mongodb server should have accepted that write. The storage engine is aware of it and will eventually write it to the disk. This basically acts like an acknowledgement; after the write is successful, the server sends out an acknowledgement.
If w: 0 , then the write is superfast, but you dont receive any acknowledgement if the write was successful..

The j stands for the journal.The journal is a separate to-do file used by the storage engine to write on before actually writing it to the disk. This ensures security if the server fails writing to the disk in case of a failure. Writing to the journal has less overhead because it simply stores the query.

The above will only be done if we set j : true.

There is also the option of wtimeout, which indicates a timeout during the write operation.. Say you have a network failure in the event of a write, the wtimeout gives the option to hold on to the query till the network reconnects. This also is a security feature, that ensures a smooth write operation.

db.<collection>.insert([{},{}], {w: 1, j: true, wtimeout: 100})