Aggregation Structure and Syntax

Loading...

From the course by MongoDB Inc.

MongoDB Aggregation Framework

9 ratings

MongoDB Inc.

MongoDB Aggregation Framework

9 ratings

This course will teach you how to perform data analysis using MongoDB's powerful Aggregation Framework. You'll begin this course by building a foundation of essential aggregation knowledge. By understanding these features of the Aggregation Framework you will learn how to ask complex questions of your data. This will lay the groundwork for the remainder of the course where you'll dive deep and learn about schema design, relational data migrations, and machine learning with MongoDB. By the end of this course you'll understand how to best use MongoDB and its Aggregation Framework in your own data science workflow.

From the lesson

The Fundamentals of MongoDB Aggregation

In this module you'll learn the fundamentals of MongoDB's Aggregation Framework. This will cover basics like filtering and sorting, as well as how to transform array data, how to group documents together, how to join data, and how to traverse graph data.

Course Logistics and Prerequisites2:07

Aggregation Introduction4:20

The Concept of Pipelines2:04

Aggregation Structure and Syntax3:48

$match: Filtering Documents3:21

Using $project5:58

Using Expressions3:14

Cursor Like Methods Stages: Part 15:03

Cursor Like Methods Stages: Part 25:15

The $group Stage5:56

Using Accumulator Expressions5:14

The $lookup Stage4:25

$graphLookup Stage6:21

Meet the Instructors

Nathan Leniz
Curriculum Engineer
Education
Kirby Kohlmorgen
Senior Curriculum Engineer
Education

Let's take a few minutes talk about the structure and syntax the aggregation framework.

The aggregation framework has a simple and reliable structure and repeatable syntax.

Pipelines may contain one or more stages.

Each stage is adjacent object of key-value pairs with only a few exceptions,

we can have as many stages as we like.

Additionally, options may be passed in.

For example, specifying whether to allow disk use for large aggregations or to build

the explained plane of the aggregation to see whether it is

using indexes or the server optimize the pipeline.

Let's take a look at a very simple but very real pipeline and discuss the syntax.

Here we have a mash stage that checks whether the atmospheric composition

contains oxygen or not and if the mean temperature falls within this range.

Then, we have a project stage that reshapes the document and calculates the new value.

More on this in a moment.

Lastly, this is our options object.

Each stage is composed of either operators or expressions.

As we continue through the course,

you'll be introduced to many of these.

Make sure you bookmark the aggregation pipeline

quick reference pages link below this video.

Throughout the course, we'll be using the terms operator and expression.

And it's vitally and quickly access the documentation for these.

So what's an operator?

For this course, when we say operators,

we mean either query operators or aggregation stages.

In this example, "$match" and "$project" are aggregation operators,

and "$in", "$gte", and "$lte" are query operators.

As a general rule,

operators always appear in the key position of a document.

"$match" is a little special and we'll learn about it later.

What's an expression? Expressions act a lot like functions,

we provide arguments and they provide a computed output.

And just like functions,

expressions can be composed to form powerful new data transformations.

MongoDB provides expressions for working with them

producing values from many types of values.

In the project stage,

"$gt" is an expression and its arguments are supplied in this array.

This "$numberOfMoons" surrounded by

the quotes is also an expression that you'll learn about in a moment.

An easy way to remember how to use expressions is

they will always appear in a value position.

Let's run this now to see the output.

Here we see the result of the calculated field.

It looks like Earth is the only planet that has oxygen as

a relatively comfortable temperature and it does indeed have moons.

One more important thing to cover.

We may encounter syntax like this.

The first is a field path expression,

is used to access the value of a field in the document,

like number of moons in the first example.

The second, with two dollar signs followed by an uppercase word,

is a system-level variable.

"$current" refers to the current document and you

can find the meaning of others on the quick reference page.

The last with two dollar signs followed by lowercase word is a user variable.

Some expressions let us temporarily bind a value to a name or

provide us a special name to access some data. And there we go.

The aggregation framework structure and syntax.

We highly recommend using nattered that has bracket matching

while constructing your pipelines to make noticing errors easier.

There's just a few things to remember.

Pipelines are always an array of one or more stages.

Stages are composed of one or more aggregation operators or expressions.

Expressions may take a single argument or

an array of arguments. See you in the next lesson.

Explore our Catalog

Join for free and get personalized recommendations, updates and offers.

Coursera provides universal access to the world’s best education, partnering with top universities and organizations to offer courses online.

© 2018 Coursera Inc. All rights reserved.

Download on the App Store

Get it on Google Play