Original subtitles

Querying for data in a database is one

of the most important operations that we have in databases.

And so, let's now take a look at a couple of query operators

in MongoDB, starting with some simple ones

and then moving on to some really complex queries.

And, to start, let's give ourselves some space here.

And so, you already know, the easiest way

to basically query for all the documents

in a certain collection is to just use find

without passing anything in there.

So, that's what we've been doing until this point.

And so, it gives us simply this result

with all the documents

that are in a certain collection basically

without any searching criteria.

But, now, let's say that we actually only want one tour

and we already know its name.

And so, we can search for that tour

using the name that we know.

And so, we us db.tours

and, again, find.

But, this time, we're gonna pass in a filter object.

So, again, we need an object here.

And so, you start to see now that in MongoDB,

really everything works with objects.

And, this will be even more prominent a bit later

in this lecture.

So, inside this object, we pass in the filter.

So, basically the search criteria

that we want to search for.

So, we simply set the name to the tour name

that we want to search for.

So, let's say The Forest Hiker.

And, that's actually it.

So, that is our search criteria or the search filter.

And, if we had returned now,

then we only get this one tour

where the name matches exactly the one that we passed in.

And, we could do, of course, the same for anything else.

For example, for the difficulty,

we could search for tours

that have an easy in difficulty.

So, difficulty and easy.

Close the object, close the function.

And so, we get all the tours where the difficulty is easy.

Right now, there is only one tour,

but if we had multiple tours with difficulty set

to easy, then, of course,

it would return all of these documents.

So, that is the easiest way

that we can search for documents.

Now, let's take it to the next level

by using some special query operators.

And, what I want to do is to search for tours

which have a price below 500.

And, the way it works is like this.

So, we always use db. The collection name .find.

And then, again, or filter object.

And so, remember, I want to search for prices,

so I say price.

And now, I want all the tours with a price below 500.

So, how do I do that?

Well, I need to use the less than operator

and it works like this.

We need to define yet a new object

where we set the lte property to 500,

then close that object,

and then close that first price object

and then close the function.

So, that looks very weird, I know,

but this is how we use query operators in MongoDB.

So, again, lte stands for less than

because that is what we're searching for.

Where the price is less than 500.

And, this special sign here is reserved in MongoDB

for its operators.

So, whenever you see this dollar sign here in MongoDB,

you know that it's a Mongo operator.

So, the weirdest part here is probably

that we have to do it inside a new object,

but if you think about it, it's actually really the only way

to specify that the price should not simply be 500,

but something else.

So, we have to set the price to something else than 500.

And, the best way really is

to just use another object in there.

So, that's exactly how MongoDB then works.

So, let's try this out now, hit return.

And, indeed, we get our two documents

where the price property is below 500.

Great, next up, let's actually search

for two search criteria at the same time.

So, what I want to do next is to search for documents

which have the price less or equal than 500,

which is what we had here already,

but also, at the same time, the rating greater

or equal to 4.8.

And so, that should then give us only this tour here.

So, only this one

because this is the only one which has the price below 500

and the rating equal or greater to 4.8.

So, it's 4.8 and so that one is the one

that should match our query.

So, let's clear it to take away some of the confusion.

Now, I want this result here

so that we can compare it with the next result.

And so, let's now write out the query that I just described.

So, find and, again, this one here is

gonna be just the same.

So, we want the price to be less or equal than 500.

Or, we could actually simply say less than 500.

So, lte is less than or equal and lt is simply less than.

So, this is the first part, the price less than 500.

And, at the same time, we want the rating

to be greater or equal to 4.8.

And, that's easy.

All we have to do is to specify a second field

in our filter object.

So, first, the price and now the rating.

So, we want the rating to be

and you can probably guess it,

greater than or equal 4.8.

Now, close this filter object and close the function.

So, let's test it out.

And, indeed, it gives us the result that we were expecting.

So, the only document where both the search criteria here

are true at the same time.

So, just to recap, when we want to search

for two criteria at the same time,

which basically is an and query,

so price less than 500, and rating greater

or equal to 4.8.

Well, the only thing that we have to do is

to specify two fields in the filter object.

And, I know this looks quite confusing.

I felt exactly the same when I was learning this stuff,

but I hope that you can still follow me

so that we can now actually take it even one level further.

So, here, we did an and query.

So, querying for documents where these two conditions

are both true, but now let's do an or query.

So, basically searching for all the documents

where either this part here is true

or this part is true.

So, db.tours.find

and let's close it here already

because this is gonna be an even more confusing one.

So, we want to do an or query and the way it works

with MongoDB operators is like this.

We say or and then here, we specify an array.

And, in this array, we will then put the two conditions

where we want one of them to be true.

So, again, I know this looks confusing,

but let's write it out now and I will then explain it again

when we're already doing that.

So, the first condition is the price should

be less than 500.

So, basically the same as before.

So, that is the first object.

So, all of this, so the first condition,

basically the first filter,

and then the second one.

So, the rating should be, just like before,

greater or equal than 4.8.

Close this one and close this one.

And so, that's actually already it.

So, again, to recap here, we start with the or operator

and the or operator accepts an array of conditions.

So, that's why we then create this array here

and this array will then contain one object

for each of our filters basically.

So, we want either this one to be true

or this one.

So, let's try to see what our results are gonna be.

And so, actually we get all of the three tours.

And so, let's analyze why that is.

So, the first one has a price less than 500.

And so, that's why it got included here.

It doesn't have the rating greater or equal to 4.8,

so it's just 4.7, but since we're doing an or query here,

only one of the conditions needs to be true.

And so, that's why this document here got selected

and is included in our output.

Next up, this one also has the price less or equal than 500

and also, at the same time, it has the rating great

or equal than 4.8.

And so, it got included actually

for both of them being true.

Then, the last one does not have the price less than 500,

but it does have the rating greater or equal to 4.8.

And so, again, one of the two conditions is true

and since we're doing an or query,

this tour also got included.

So, let's clear this and only one more,

which is gonna be kind of the same.

I'm simply gonna change from less than to greater than.

And, what I want you to do now is

to guess the output of this one based

on the previous result.

So, can you guess what the result will be?

So, let's take a look.

And so, now, indeed, we no longer have all three tours,

but only the second and the third one

because, remember, the first tour

had the price less than 500

and also the rating less than 4.8.

And so, none of the conditions were applying

and so it's no longer included.

Only the second and the third one,

which now has the price also not greater than 500,

but it has the rating of 4.8

and so it's still included.

And, the last one, of course, has everything true

and so, of course, it's also here.

Just one more thing that I wanted to show you here is

that besides our filter object, so this one,

we can also pass in an object for projection.

So, what projection means is that we simply want

to select some of the fields in the output.

So, let me show it to you and it's very simple.

All we have to do is, for example, say name equals to one.

So, what this means is that we only want the name

to be in the output and so that's why we set name to one.

All the others are not gonna appear in this case.

So, let me show that to you.

And, indeed, we only have the name

and no longer all these other properties.

And, this can be very useful in some cases.

The idea is, of course, also showing up,

but that's always there.

There's no way of removing that.

Okay, cool.

So, I think the main goal of this lecture is now achieved,

which was basically to get you familiar

with the way we query in MongoDB

and also show you these complex MongoDB operators

that we have here.

For some reason, I cannot select it,

but you know what I mean.

So, we have greater than,

we have or, and we really have a ton

of other operators still.

So, this is only the surface,

but throughout the rest of the course, you will, of course,

get to know a couple of other operators.

So, this is just to get you familiar,

get you started with querying in MongoDB.

And, I think in this lecture, we did that successfully.