[MUSIC]

Hello and welcome back.

In this lecture, we will go into the aggregation framework.

But before we jump into aggregation, let's do a quick mapping between

the SQL commands and the commands we have in Mongo.

So just like the way we have the commands like where, group by,

select, order by, limit, sum and count right,

which are probably the most common commands that you would use in a SQL.

Well Mongo has pretty much the same equivalent commands, so to speak.

Where, for example, where would be a match,

group by would be a group, limit and then sum and count and so on.

So to give you an example, if you have your typical select count

star as count from zips, right, if this was your SQL command.

In Mongo you would do something like this where you would say db[:zips].find and

then aggregate and then you would pass a hash.

Where you would do,

you would use a count just like the count you have in SQL, right?

So for example, SUM in this example we would do sum in Mongo.

So as I said you have a good mapping for all the major, or all the common

key words in RDBMS with Mongo and that's exactly the point of this lecture.

Where we will look at a whole bunch of example, in fact in this lesson, we look

at multiple examples of where we will do examples with all of these keywords, okay?

So what is an aggregation framework?

Well, so the aggregation is nothing but

operations that process data records and return computed results.

So the key here is these are operations that process the data and

return the computed result.

So a command that'll go get the data, do some kind of an operation like max, min,

limit, sort, and then gives you a filtered data based on what you are, looking for.

So it's a wide variety of operations, match, group, unwind, sum, max, min.

So again, we'll see a bunch of these in a few minutes.

So again, what is the advantage?

So basically, as you can see, it simplifies the application code.

So you don't have to get hundreds and

thousands of documents into your application and

then start filtering in your Ruby on Rails or Java or whatever the language is.

Instead, while getting the data, you can filter off the data that you don't need.

Now there is a term called pipeline or aggregation pipeline.

So, as the word tells you, it's a pipeline meaning so

as you go down the line, so to speak you can filter off the data.

Meaning you can use multiple operations and

filter off the data one after the other.

So, you start 10,000 documents in a collection,

you apply one filter, reduce it down to 3,000, then make it 1,000,

and then just a dozen by the time you hit the end of this pipeline.

So it's filters, that operate like queries.

And you can do grouping and sorting and all kinds of things.

And the whole idea behind this is to return calculated documents,

meaning you want to apply some kind of a filter, apply some kind of a query and

get a subset of the larger dataset.

.So let's look at a realistic example here.

This is from the Mongos website, a pretty nice example.

A realistic example that happens all the time on orders like Amazon and

eBay and so on.

So what we have here is a list of orders.

And we have hundreds and thousands of orders let's say.

But in this example we have four.

If you notice, three of these are same customer, A123, A123, and A123.

And this one is a different customer.

And they all have some kind of an amount how much they have spent on some order.

And also there are some kind of a status.

Status equal to a, a, and then status equal to d and a and so on.

So this query is basically saying, hey go to the orders and

give me all documents in the collection that have a status equal to a.

So from these four or from hundreds and thousands, you will get a subset.

So in this example, we will get one, two and three, right, 123, 123 and B212.

And once you get that, the second line is saying,

now start grouping them such that group them by customer ID, right?

So, these two are same, meaning same customer ID so that becomes one,

and this one stays the same, and you also want to sum the amount.

So go and add the amount as your using them, from you know two to

one in this example, it will automatically add these two based on this dollar sum.

And it becomes 500 plus 250 and 750.

So the whole idea here is that you start with thousands of records and

then you filter it based on status equal to a.

And then you filter back into

just showing the based on the custom ID and their total.

Now applying the same concept to our zips example.

And this is actually Ruby syntax.

The previous example, by the way, was just a regular Mongo syntax.

But here what we're trying to do is,

the goal is to get the population of New York State, right?

So, there are a bunch of cities in New York and you want to

get population of each of those cities, add the total, and then display the total.

That's exactly what is happening.

Match, so aggregate, match, state, New York.

So out of hundreds of, well out of,

we have 29,000 documents in this collection, right?

And each of these document belongs to a state.

So if all the states we have are give me only the states that have New York.

So we get city1 New York population, latitude and

longitude remember the syntax.

So then we get city2 and city3 and so on.

And then next we do a grouping based on, of course New York, and

then population we do a summation of the dollar population.

So in this example, and I just made up an example, but

we have a population of 1,000, the city has 2,000, this has 3,000, and so on.

But then eventually this is the actual number that you get is the total of

all the population of all the cities will end up being 17990402, right.

So again, from all the hundreds of thousands of documents that you have you

filter it down to the ones which have state equal to New York.

And then you display the population of the New York.

So just to summarize, aggregation is a powerful concept in Mongo,

and the whole idea is to process data and return customized result.

And document transformations that modify the form of the output document,

that is a good way to summarize aggregation.

So what is next?

We'll look at $project, and $project is similar to select.

So we should be able to select or

filter off that we don't need as part of our aggregations query.

Okay, thank you.

Introduction to Aggregation

Ruby on Rails Web Service 及其与 MongoDB 的整合

与讲师见面