$group

Loading...

Del curso dictado por Johns Hopkins University

Ruby on Rails Web Services and Integration with MongoDB

287 calificaciones

Johns Hopkins University

Ruby on Rails Web Services and Integration with MongoDB

287 calificaciones

Curso 3 de 6 en SpecializationRuby on Rails Web Development

In this course, we will explore MongoDB, a very popular NoSQL database and Web Services concepts and integrate them both with Ruby on Rails. MongoDB is a used to handle documents with a pre-defined schema which will give the developers an ability to store, process and use data using it’s rich API. The modules will go in-depth from installation to CRUD operations, aggregation, indexing, GridFS and various other topics where we continuously integrate MongoDB with RailsRuby. We will be covering the interface to MongoDB using the Mongo Ruby API and the Mongoid ORM framework (the MongoDB access counterpart to RDBMS/ActiveRecord within Rails). The last portion of the course will focus on Web Services with emphasis on REST, its architectural style and integration of Web Services with Rails. Core concepts of Web Services like request/response, filters, data representation (XML/JSON), web linking and best practices will covered in depth. This course is ideal for students and professionals who have some programming experience and a working knowledge of databases.

De la lección

Aggregation Framework, Performance, and Advanced MongoDB

In this module, we’re going to explore the fundamentals of the Aggregation framework in MongoDB. We will work on examples where you will process data records and return computed results. You will learn about and get to work on hands-on examples where you will be grouping values from multiple documents and performing a variety of operations on the grouped data to get a single result. We will look at a number of aggregation commands and paging. We will explore some advanced concepts like full text search, GridFS, Geospatial API, and wrap up the module with detailed demonstrations of all the capabilities presented in this module.

Welcome to Module 2: Aggregation Framework, Performance, and Advanced MongoDB3:40

Introduction to Aggregation7:39

Conoce a los instructores

Kiran Chittargi
Adjunct Professor, Graduate Computer Science
Whiting School of Engineering

[MUSIC]

Hello and welcome back.

In this lecture, we will talk about a group operator.

Now, the group is similar to GROUP BY in RDBMS.

So really all it does is, it groups the documents by some specified expression.

So, we'll look at some examples of how you can pass this expression, and

group the documents based on those conditions.

Now, there are the two ways of output documents that you can get out of this,

which is the output documents contain an _id field,

which actually contains that distinct group by key.

Well, what do we mean by this?

I think the best way to understand this is to see an example.

So the output of the document that we get based on a call that we make will have

an id and the value of that is gonna be the documents that have been grouped by.

The other open document that could potentially come out of

this is some computed fields.

So you might have done some average, some minimum, some maximum, and

that could be the output potentially of the column.

So, very helpful and you will see some examples of how you can actually

I get some really good data based on this.

So, the commands that go hand and

hand with group as part of the pipeline processing rate, I mean down the pipeline

would be things like sum, average, max, min, push, addToSet.

Now, the first four are obvious.

You get the sum, the average, the max, and min, and

we run all of these commands with some examples.

Now, push and addToSet are slightly different, and

might be new to many of you listening in here.

So we will look at what push and addToSet basically look like with some examples,

but we'll also look at the first four, which are fairly straightforward.

And we have some good data, like population and

all that, that we can use to get the appropriate of data we are looking for.

So what is sum, what does the sum command look like.

Well, sum returns a sum of each group.

So whatever group, or

rather whatever field that you want to do the sum operation on,

can be a hash that goes into the group query.

So here, we are returning the id, which is going to be the state attribute or

the state variable and we will show the sum of all the population for

that state, right?

So again, very hand and we're limiting the data to five.

Let's run this example, and see what we get..

So, let's put the command, so there is our db[:zips].find.aggregate group.

So, we do the state.

So, we should see state coming back as the id, right id equal to the variable state.

So, we have Washington, Hawaii, and all that and then we have

the population which is the sum of the population that is coming back here.

So that's exactly what, so the population is what you see is what you get.

That's the field we're displaying on the screen,

and the pop is the actual population in the database.

That's the key, that's the variable in the document, so

that's what we're getting back.

So that's the population of each of those states, and we are limiting that to five.

Let's do the population next.

I just cleared the screen.

So let's go and do the next command,

which is finding the average population using the average operator.

So, we do the db[:zips].find.aggregate group id by state, so

we still want to display the id, and

we are using a new field to display on the screen called average population.

And we take advantage of this command, avg average, and

then we use the population field in the document, and that's what we get.

So, we get the average population of Washington is 10,055, and so on.

So that's the average population of each of those states.

So next, let's do the max and min.

So, let's go and do the the max here.

So this is actually going and doing the maximum population, and

then that's getting assigned to the variable max_zip.

So we are again going and looking at hey, which field,

which of the zip code in the database, remember that's the id,

so which of the zip code has the maximum population for a given state.

So Washington for example, has that as the max.

So again, helpful, very handy.

You can take the API, I mean the support that we get with these commands,

and then fetch the data as part of the aggregation framework, and then give it to

the client so the client doesn't have to do a lot of processing at the code level.

You can get the data directly using the cell.

Let's also do minimum, which is similar to the previous example.

So min is again identical, so this will come back with minimum zip node.

Surprisingly, we do have some data here.

And again, this could just be the data that we imported, but

the logic is working, so some of the cities in Hawaii have no population.

May not be true, just maybe the data we have.

It doesn't matter, but the point is it went in and fetched the data for

us that has the minimum.

So, min to 0 is obviously the minimum.

So it goes from 0,

and then starts picking up the next city that has the lowest population.

So, in Washington we found one city that has two, and

these cities have the lowest population, obviously which is zero.

But that's how you pull the data using the min.

Now, let's look at the push.

Now, push is slightly different.

Now, what push does is, it returns an array of all values that

result from applying an expression to each document in a group

of documents that share the same group by key.

Now that's a lot of words, and obviously very confusing, but

really all it means is this.

So, I mean the zip codes are unique of course meaning one city has one zip code,

but there could be a case where the city is so big that you have to break it

apart into two zip codes saying, hey, this part of the city has this zip code and

the second part of the city is a different zip code.

Now, that's exactly what push is trying to do.

It's basically saying, hey, if you find a city with two different zip codes,

then simply display that as an array, because it's the same city,

it's in the same state, then simply, remember it's city and state.

If it's the same city in the same state, but if it has two different zip codes,

simply show that as an array as a part of your display.

So let's go, and run this command.

Now I'm displaying 15, so if you increase the number, you will find more cities, but

if you keep it to five or three, you may not get the data you were looking for.

So, let's go and run this command, and see what we get.

Okay, so let's look at this command.

So we are actually going and doing the same thing, but

here is the important thing.

We are actually doing push of the id.

You should remember the id is actually the zip code.

So, if you basically find multiple zip codes for

a given city, then just push that.

Just push that, apply the push command, and display the value.

And so that's exactly what happens when you run that, and

if you look at this one little data here, one document that we have, so

this city, that belongs to this state.

So it's Ketchikan state, so I hope I'm pronouncing that correct,

that has two zip codes, so you're basically displaying this as an array,

as part of the display that is coming back, and that's what push does.

So it's actually combining, and displaying it as an array.

So again it all depends, if you want to display this as two different documents in

your web application, then you will have to do something else which we'll look at.

But if you're trying to display this as in, hey,

this city has multiple zip codes, then you can do it using the push command.

Let's look at addToSet.

Now, addToSet is well, kind of opposite of what we did with first,

similar to what we did, kind of opposite.

So, what addToSet does is it'll actually return an array of all the unique

values that result from this applying of expression.

So basically if you look at these two examples, so the first one will basically

come back with every single state where you have this duplicate zip code problem,

whereas the second example will just give you the unique set of state,

so you might see hundreds of data coming back here, whereas here, you will get

just one distinct or one addToSet will come back with a unique value.

So for example, let's take some state called California.

California could have like ten cities which have multiple zip codes.

So you will see California come up ten times.

So each state will come up multiple times, assuming they have duplicate values.

Whereas addToSet will say, oh, I'm just going to show once California, and

the other state would come up one time.

So I think the best way to understand this is to look at an example, and

then we'll do the first one with push and then we'll replace that with addToSet,

and see how different the results come back.

So let's go, and do it first.

So this the command I'm going to do push state,

so as you can see, there's a whole bunch of data coming back.

So this state has so many cities and so many zip codes, and

all the duplicate values are coming back.

Now, we can take the exact same command, and we'll apply addToSet,

and this will filter out all the duplicate and will come back with one unique state.

So let me clear this screen, and we'll put the other command here.

So this is addToSet, and now we should only get the unique.

So we get each of these states, pretty much the same data that we looked at in

the previous example are coming back.

Now, another important thing to remember is the order of the element,

in addToSet is unspecified,

it's not very stable whereas with push it's very stable, and ordered.

So, that is something to take away from addToSet versus push.

So, you will see it come back in a completely unstable or

a different order whereas, push comes up in the same stable order, as we call it.

So just to summarize, the group will group

the document by some specified expression, and

outputs to the next stage a document for each distinct grouping.

So that's kind of a good way to define it, and summarize it.

And again remember, it's all about aggregation.

You're sending the data across the quote unquote pipeline, and

the data is slowly getting filtered and filtered and filtered,

and you'll apply all of these things and then send it back

to the client in a certain way that the client is expecting the data.

We'll go into match which is again a very good aggregation operator, and

we'll see some examples with that in the next lecture.

Thank you.

Explora nuestro catálogo

Inscríbete de manera gratuita y obtén recomendaciones personalizadas, actualizaciones y ofertas.

Coursera brinda acceso universal a la mejor educación del mundo, al asociarse con las mejores universidades y organizaciones, para ofrecer cursos en línea.

© 2018 Coursera Inc. Todos los derechos reservados.

Descargar en la App Store

Consíguelo en Google Play