{
   name: 'pivot',
   index: ['column_1', 'column_2'],
   column_to_pivot: 'column_3'
   value_column: 'column_4'
   agg_function: 'sum' # 'mean' by default
}

{
  $group:
    _id:
      column_1: "$column_1"
      column_2: "$column_2"
      column_3: "$column_3"
    column_4: $sum: "$column_4" # first we perform the aggregation ('$mean' by default), with the _id including the column to pivot
}
{
  $group:
    _id:
      column_1: "$_id.column_1"
      column_2: "$_id.column_2"
    array:
      $addToSet:
        column_3: "$_id.column_3"
        column_4: "$column_4" # then we group with with index columns as _id and we push documents as an array of sets including a column for the column to pivot and a column for the corresponding value
}
{
  $project:
    tmp_object:
      $arrayToObject:
        $zip:
          inputs: ["$array.column_3", "$array.column_4"] # then we project a tmp key to get an object from the array of couples [column_to_pivot, corresponding_value]
}
{
  $addFields:
    "tmp_object.column_1": "$_id.column_1"
    "tmp_object.column_2": "$_id.column_2" # Then we include back in every document created in the previous step the index columns (still accessible in the _id object as we did not explicitly specified '_id: 0' in the previous step)
}
{
  $replaceRoot:
    newRoot: "$tmp_object" # then we replace the root of the document tree to get our columns ready for our needed table-like format !
}
]

{
   name: 'rename',
   oldname: 'foo',
   newname: 'bar'
}
{
   name: 'rename',
   oldname: 'old',
   newname: 'new'
}

{
  $project:
    <all other columns>: 1
    bar: "$foo"
    new: "$old"
}

 {
      name: 'group',
      on: ['dimension1', "dimension2"]
      aggregations: [
        {
           name: "sum_value1" # default name: '<function>_<column>'
           column: "value1"
           agg_function: 'sum'
        }
        {
           name: "avg_value2"
           column: "value2"
           agg_function: 'avg'
        }
        {
           name: "MIN"
           column: "value3"
           agg_function: 'min'
        }
        {
           name: "MAX"
           column: "value4"
           agg_function: 'max'
        }
        {
           name: "count_value5"
           column: "value5"
           agg_function: 'count'
        }
        {
           name: "value6"
           column: "value6"
           agg_function: 'first'
        }
        {
           name: "value7"
           column: "value7"
           agg_function: 'last'
        }
      ]
  }

query: [
  $group:
    _id: 
      dimension1: "$dimension1"
      dimension2: "$dimension2"
    sum_value1:
      $sum: '$value1'
    avg_value2:
      $avg: '$value2'
    MIN:
      $min: "$value3"
    MAX:
      $max: "$value4"
    count_value5:
      $sum: 1 # Careful here: there is no '$count' operator, we '$sum' a series of 1 to count
    value6:
      $first: "$value6"
    value7:
      $last: "$value7"
,
  $project:
    dimension1: "$_id.dimension1"
    dimension2: "$_id.dimension2"
    sum_value1: 1
    avg_value2: 1
    MIN: 1
    MAX: 1
    count_value5: 1
    value6: 1
    value7: 1
]

 {
      name: 'group',
      on: ['dimension1']
      dimensions: [
        {
           name: "sum_value1"
           column: "value1"
           agg_function: 'sum'
        }
      ]
  }

query: [
  $group:
    _id: 
      dimension1: "$dimension1" # not "_id: '$dimension'" as it may be possible but we want to keep the approach as generic as possible so we use a "levelled" definition of "_id" as it generalises to grouping on several dimensions
    sum_value1:
      $sum: '$value1'
,
  $project:
    dimension1: "$_id.dimension1"
    sum_value1: 1
]

 {
      name: 'group',
      on: ['dimension1', 'dimension2']
      aggregations: [
        {
           name: "count_distinct_client"
           column: "client"
           agg_function: 'count_distinct'
        }
      ]
  }

query: [
  $group:
    _id: 
      dimension1: "$dimension1"
      dimension2: "$dimension2"
      client: "$client" # This first '$group' builds unique groups and therefore make every client unique in every combination of dimension1 x dimension2 x client
,
  $group:
    _id: 
      dimension1: "$_id.dimension1"
      dimension2: "$_id.dimension2"
    count_distinct_client:
      $sum: 1 # Count the the unique groups and therefore the clients for every combination of dimension1 x dimension2
,
  $project:
    dimension1: "$_id.dimension1"
    dimension2: "$_id.dimension2"
    count_distinct_client: 1
]

 {
      name: 'group',
      on: ['dimension1', 'dimension2']
      aggregations: [
        {
           name: "sum_value"
           column: "value"
           agg_function: 'sum'
        }
        {
           name: "count_distinct_client"
           column: "client"
           agg_function: 'count_distinct'
        }
      ]
  }

query: [
  $group:
    _id: 
      dimension1: "$dimension1"
      dimension2: "$dimension2"
      client: "$client"
    array_detail:
      $push: '$$ROOT' # To keep track of the details and be able to perform every aggregation, we push every document ('$$ROOT' is a mongo variable similar to a cursor representing the current document being read) in arrays, with one array per group of [dimensions + the column for which we need to get the number of unique values]
,
$group:
    _id: 
      dimension1: "$_id.dimension1"
      dimension2: "$_id.dimension2"
    client:
      $sum: 1 # here we count the unique clients as there are unique as per the group _id definition of the previous step
    array_group:
      $push: '$$ROOT' # Same thing here than in the step above: we need to keep track of every document to then be able to perform the other aggregations (see steps below)
,
  $unwind: '$array_group' # The unwind step "destructure" the array to get a root document per document found in the array => in tabular terms, we get 1 row per document found in the array
,
  $project:
    dimension1: "$_id.dimension1"
    dimension2: "$_id.dimension2"
    client: 1
    array: "$array_group.array_detail" # We get the array with the most granular level of documents here to unwind it in the following step to get a row per document
,
  $unwind: "$array"
,
  $group:
    _id:
    dimension1: "$dimension1"
    dimension2: "$dimension2"
    sum_value:
      $sum: "$array.value" # Now we can perform the other aggregations based on the most granular level
    count_distinct_client:
      $first: "$client" # And we need to keep the first value of count distinct found per group as this value was duplicated after the '$unwind' operations
,
  $project:
    dimension1: "$_id.dimension1"
    dimension2: "$_id.dimension2"
    sum_value: 1
    count_distinct_client: 1
]

 {
      name: 'group',
      on: ['dimension1', "dimension2"]
      aggregations: [
        {
           name: "sum_value1" # default name: '<function>_<column>'
           column: "value1"
           agg_function: 'sum'
        }
        {
           name: "my_name"
           column: "value1"
           agg_function: 'count'
        }
      ]
  }

query: [
  $group:
    _id: 
      dimension1: "$dimension1"
      dimension2: "$dimension2"
    sum_value1:
      $sum: '$value1'
    count_value1:
      $count: '$value1'
,
  $project:
    dimension1: "$_id.dimension1"
    dimension2: "$_id.dimension2"
    sum_value1: 1
    my_name: 1
]

[
  {
      name: 'domain',
      domain: 'focus_media_campaigns_levers_objectives'
  }
  {
      name: 'filter',
      column: 'period',
      value: "Monthly View"
      operator: 'eq'
  }
  {
      name: 'filter',
      column: 'period',
      value: ["2017", "2018"]
      operator: 'in'
  }
  {
      name: 'group',
      dimensions: ['day', "Campaign name"]
      measures: [
        {
           column: "Clicks"
           agg_function: 'avg'
        }
        {
           column: "Budget"
           agg_function: 'sum'
        }
        {
           column: "Impressions"
           agg_function: 'sum'
        }
      ]
  }
  {
     name: 'new_column_formula',
     new_column_name: 'CPM'
     formula: "[Budget] / [Impressions] * 1000"
  }
  {
    name: 'unpivot'
    id: ["day", "campaign"]
    value: ["Budget", "Impressions", "CPM"]
    dropna: true
  }
]

query: [
  $match:
    domain: "focus_media_campaigns_levers_objectives"
    period: 'Monthly View'
    year: $in: ["2017", "2018"]
,
  $group:
    _id: 
      day: "$day"
      campaign: "$Campaign name"
    Clicks:
      $avg: '$Clicks'
    Budget:
      $sum: '$Budget'
    Impressions:
      $sum: "$Impressions"
,
  $project:
    day: "$_id.day"
    campaign: "$_id.campaign"
    Clicks: 1
    Budget: 1
    Impressions: 1
    CPM:
      $multiply: [ $divide: [ "$Budget", "$Impressions"] , 1000 ]
]
postprocess: [
  melt:
    id: ["day", "campaign"]
    value: ["Budget", "Impressions", "CPM"]
    dropna: true
]

query: [
  ...
,
  # Derived from our group step
  $project:
    day: "$_id.day"
    campaign: "$_id.campaign"
    Clicks: 1
    Budget: 1
    Impressions: 1
,
  # Derived from our formula step
  $project:
    CPM:
      $multiply: [ $divide: [ "$Budget", "$Impressions"] , 1000 ]
]
...

{
   name: 'fillna',
   column: "foo"
   value: "bar"
}

{
  $project:
    <all other columns>: 1
    foo: $cond: [{$eq: ["$foo", null]}, "bar", "$foo"]
}

{
   name: 'argmax',
   groups: ['foo'],
   column: 'bar' # column in which to search for the max value
}

{
  $group:
    _id:
      foo: "$foo"
    array:
      $push: "$$ROOT"
    value_to_compare: $max: "$bar" # $min for argmin
}
{
  $unwind: "$array"
}
{
  $project:
    value_to_compare: 1
    <all_other_columns>: "$array.<all_other_columns> # We want to keep all columns
}
  $redact: # shortcut operator to avoid to firstly create a boolean column via $project and then filter on 'true' rows via $match
    $cond: [
      {
        $eq: ["$foo", "$value_to_compare"]
      }
      "$$KEEP"
      "$$PRUNE" # Magic happens here with the mongo variable "$$KEEP" (for... keeping rows matching the condition) and "$$PRUNE" (for excluding rows not matching the condition)
    ]
]

{
   name: 'argmin',
   column: 'bar'
}

{
  $group:
    _id: null
    array:
      $push: "$$ROOT"
    value_to_compare: $min: "$bar"
}
{
  $unwind: "$array"
}
{
  $project:
    value_to_compare: 1
    <all_other_columns>: "$array.<all_other_columns> # We want to keep all columns
}
  $redact: # shortcut operator to avoid to firstly create a boolean column via $project and then filter on 'true' rows via $match
    $cond: [
      {
        $eq: ["$foo", "$value_to_compare"]
      }
      "$$KEEP"
      "$$PRUNE" # Magic happens here with the mongo variable "$$KEEP" (for... keeping rows matching the condition) and "$$PRUNE" (for excluding rows not matching the condition)
    ]
]

{
    name: 'unpivot'
    keep: ["MARCHE", "CANAL"]
    unpivot: ["NB_CLIENTS_TOTAL", "NB_ROWS"]
    unpivot_column_name: "KPI"
    value_column_name: "VALUE"
    dropna: true # default
}

{
  $project:
    MARCHE: "$MARCHE"
    CANAL: "$CANAL"
    dimensions:
      $objectToArray: {
        NB_CLIENTS_TOTAL: "$NB_CLIENTS_TOTAL"
        NB_ROWS: "$NB_ROWS"
      }
}
{
  $unwind: "$dimensions"
}
{
  $project:
    MARCHE: 1
    CANAL: 1
    KPI: "$dimensions.k"
    VALUE: "$dimensions.v"
}
{
  $match:
    VALUE: $ne: null # dropna here
}

{
    name: 'unpivot'
    keep: ["MARCHE", "CANAL"]
    unpivot: ["NB_CLIENTS_TOTAL", "NB_ROWS"]
    unpivot_column_name: "KPI"
    value_column_name: "VALUE"
    dropna: false
}

{
  $project:
    MARCHE: "$MARCHE"
    CANAL: "$CANAL"
    dimensions:
      $objectToArray: {
        NB_CLIENTS_TOTAL: "$NB_CLIENTS_TOTAL"
        NB_ROWS: "$NB_ROWS"
      }
}
{
  $unwind: "$dimensions"
}
{
  $project:
    MARCHE: 1
    CANAL: 1
    KPI: "$dimensions.k"
    VALUE: "$dimensions.v"
}

{
   name: 'formula'
   new_column: 'new_col' # new_column can be an existing column to be updated with the formula result
   formula: '(column_1 + column_2) / column_3 - column_4 * 100'
}

{
  $project:
    <all other columns>: 1
    new_col:
      $subtract: [
        {
          $divide: [
            {
              $add: [
                "$column_1"
                "$column_2"
              ]
            }
            "$column_3"
          ]
        }
        {
          $multiply: [
            "$column_4"
            100
           ]
        }
      ]
}

{
  name: 'top',
  groups: ['foo']
  value: 'bar',
  sort: 'desc' # or 'asc'
  limit: 10
}

{
  $sort:
    bar: -1 # or 1 when 'asc'
}
{
  $group:
    _id:
      foo: "$foo"
    array:
      $push: "$$ROOT"
{
{
  $project:
    top_elems: $slice: ["$array", 10]
}
  $unwind: "$top_elems"
}
{
  $project:
    <all_columns>: "$top_elems.<all_columns>" # We want to keep all columns
}
]

{
  name: 'top',
  value: 'bar',
  sort: 'desc' # or 'asc'
  limit: 10
}

{
  $sort:
    bar: -1 # or 1 when 'asc'
}
{
  $group:
    _id: null
    array:
      $push: "$$ROOT"
{
{
  $project:
    top_elems: $slice: ["$array", 10]
}
  $unwind: "$top_elems"
}
{
  $project:
    <all_columns>: "$top_elems.<all_columns>" # We want to keep all columns
}
]

{
   name: 'percentage'
   new_column: 'new_col'
   column: 'bar'
   group: ['foo']
}

{
  $group:
    _id:
      foo: "$foo"
    array:
      $push: "$$ROOT"
    total_denum: $sum: "$bar"
}
{
  $unwind: "$array"
}
{
  $project:
    new_col: $cond: [$eq: ["$total_denum", 0], null, $divide: ["$array.bar", "$total_denum"]] # we need to explicitely manage the case where '$total_denum' is null otherwise the query may just fail
    <all_other_columns>: "$array.<all_other_columns>"
}

{
   name: 'percentage'
   column: 'bar'
}

{
  $group:
    _id: null
    array:
      $push: "$$ROOT"
    total_denum: $sum: "$bar"
}
{
  $unwind: "$array"
}
{
  $project:
    bar: $cond: [$eq: ["$total_denum", 0], null, $divide: ["$array.bar", "$total_denum"]] # we need to explicitely manage the case where '$total_denum' is null otherwise the query may just fail
    <all_other_columns>: "$array.<all_other_columns>"
}

{
  name: 'filter',
  and: [
    {
      column: 'column_1'
      value: ['foo', 'bar']
      operator: 'in'
    }
    {
      column: 'column_2'
      value: ['toucan', 'toco']
      operator: 'nin'
    }
    {
      or: [
        {
          column: 'column_3'
          value: 'toto'
          operator: 'eq'
        }
        {
          and: [
           {
              column: 'column_4'
              value: 42
              operator: 'lte'
           }
           {
              column: 'column_4'
              value: 0
              operator: 'gt'
           }
          ]
        }
      ]
    }
  ]
}

{
  $match:
    column_1: $in: ["foo", "bar"]
    column_2: $nin: ["toucan", "toco"] # an 'and' between conditions on different columns does not need an explicit '$and' operator
    $or: [
      {
        column_3: $eq: "toto" # '$eq' is optional as it is implicit in Mongo
      }
      {
        $and: [ # an 'and' between conditions on the same column do need an explicit '$and' operator
          {
             column_4: $lte: 42
          }
          {
             column_4: $gt: 0
          }
        ]
      }
    ]
}

{
   name: 'replace',
   search_column: "column_1"
   new_column: "column_1" # inplace by default
   oldvalue: 'foo'
   newvalue: 'bar'
}
{
   name: 'replace',
   search_column: "column_1"
   new_column: "column_1" # inplace by default
   oldvalue: 'old',
   newvalue: 'new'
}

{
  $project:
    <all other columns>: 1
    column_1: $cond: [{$eq: ["$column_1", "foo"]}, "bar", "$column_1"] # No, there is not a more elegant way of doing it in he mongo aggregation pipeline :) But it does have the advantage to work for any data type
}
{
  # We need a distinct step for the second replace (if we decide that it is more readable than nested $cond in one step...). We cannot merge the $project steps as they would include non unique keys as we want the replacement to be performed inplace, so only one replacement would be retained by Mongo.
  $project:
    <all other columns>: 1
    column_1: $cond: [{$eq: ["$column_1", "old"]}, "new", "$column_1"]
}

{
   name: 'replace',
   search_column: "column_1"
   new_column: "new_column"
   oldvalue: 'foo'
   newvalue: 'bar'
}
{
   name: 'replace',
   search_column: "new_column"
   oldvalue: 'old',
   newvalue: 'new'
}

{
  $project:
    <all other columns>: 1
    column_1: 1 # We do want to keep the source column
    new_column: $cond: [{$eq: ["$column_1", "foo"]}, "bar", "$column_1"]
}
{
  # We need a distinct step for the second replace (if we decide that it is more readable than nested $cond in one step...). We cannot merge the $project steps as they would include non unique keys as we want the replacement to be performed inplace, so only one replacement would be retained by Mongo.
  $project:
    <all other columns>: 1
    column_1: 1 # We do want to keep the source column
    new_column: $cond: [{$eq: ["$new_column", "old"]}, "new", "$column_1"] # Here we base our replacement on the 'new_column' from step 1
}

{
   name: 'replace',
   search_column: "column_1"
   new_column: "column_1" # inplace by default
   oldvalue: 'foo'
   newvalue: 'bar'
}
{
   name: 'replace',
   search_column: "column_2"
   new_column: "new_column"
   oldvalue: 'old',
   newvalue: 'new'
}

{
  $project:
    <all other columns>: 1
    column_2: 1
    column_1: $cond: [{$eq: ["$column_1", "foo"]}, "bar", "$column_1"]
    new_column: $cond: [{$eq: ["$column_2", "old"]}, "new", "$column_1"]
}

{
   name: 'sort',
   columns: ["foo"]
   order: ["asc"] # 'asc' by default
}

{
  $sort:
    foo: 1
}

{
   name: 'sort',
   columns: ["foo", "bar"]
   order: ["asc", "desc"]
}

{
  $sort:
    foo: 1
    bar: -1
}