Koncepcje potoków: etapy, operatory i wyrażenia

The aggregation pipeline is MongoDB's server-side data transformation engine. Instead of retrieving raw documents and processing them in application code, you define a sequence of stages that transform the data stream step by step—filtering, reshaping, grouping, computing, and sorting—all within the database engine. This keeps heavy computation close to the data and dramatically reduces what you send over the network.

Think of the pipeline as a conveyor belt: each document enters stage 1, is transformed (or filtered out), and the results flow into stage 2, then stage 3, and so on. At each stage, the set of documents can shrink (filtering), expand (unwind), or be completely replaced by computed summaries (group). Documents that fail a filter condition are dropped from the pipeline and never reach later stages.

The aggregation framework distinguishes between two kinds of operators: stage operators (prefixed with $) that define what a pipeline stage does—like $match, $group, $project—and expression operators (also prefixed with $) that compute values within a stage—like $sum, $avg, $concat. Stages are the building blocks; expressions are the calculations inside them.

Inside aggregation expressions, a string prefixed with $ is a field reference—it refers to the value of that field in the current document. Without the prefix, a string is treated as a literal value. This distinction is crucial: '$price' means 'the value of the price field' while 'price' means the literal string 'price'.

The aggregation pipeline provides system variables prefixed with $$ that give access to special values: $$ROOT refers to the entire current document, $$NOW is the current datetime (useful in $project for computed fields), $$CURRENT is the current document field path context, and $$REMOVE conditionally removes a field when assigned as a value.

MongoDB provides dozens of pipeline stages. The most essential ones to know are: $match (filter documents), $project (reshape/compute fields), $group (aggregate by key), $sort (order results), $limit and $skip (pagination), $lookup (join another collection), and $unwind (flatten arrays). Master these and you can express almost any analytical query.

MongoDB's query optimizer automatically reorders some pipeline stages for efficiency—for example, moving $match before $sort and $group when possible. However, you should always place $match as early as possible yourself: early filtering reduces the number of documents subsequent stages must process, and if $match is the first stage, MongoDB can use an index for it.

Arithmetic expressions let you compute new values from existing fields within a stage. The most common ones are: $add, $subtract, $multiply, $divide, $mod, and $abs. These operators work on field references, literals, or the result of other expressions—enabling complex calculations that previously required application-side processing.

Conditional expressions allow if/else logic inside aggregation stages. $cond evaluates a boolean expression and returns one of two values (like a ternary operator). $ifNull returns a fallback value when a field is null or missing. These are essential for handling optional fields and computing derived categories without modifying the stored data.

String operators let you manipulate text fields within the pipeline: $concat joins strings, $toUpper/$toLower change case, $trim/$ltrim/$rtrim strip whitespace, $substr extracts a substring, and $split splits on a delimiter. These are useful for normalising data during aggregation without needing to update the stored documents.

Date operators extract components from date fields for grouping and computation: $year, $month, $dayOfMonth, $hour, $minute, $dayOfWeek, and $dateToString. These are indispensable for time-series analytics like 'total orders per month' or 'average revenue by day of week'.

In this lesson you learned: pipeline stages transform a stream of documents sequentially, stage operators define what a stage does while expression operators compute values within stages, and $ prefixes field references while $$ prefixes system variables. Next up we focus on $match and $project, the filter and reshape workhorses.