パイプラインの概念：ステージ、演算子、式

// A simple aggregation pipeline
db.orders.aggregate([
  { $match: { status: 'completed' } },   // stage 1: filter
  { $group: { _id: '$userId', total: { $sum: '$amount' } } },  // stage 2: group
  { $sort: { total: -1 } },             // stage 3: sort
  { $limit: 10 }                        // stage 4: take top 10
]);

// Data flow visualization:
// Input: 10,000 orders
// Stage 1 ($match: status='completed'):  8,000 docs
// Stage 2 ($group by userId):            1,200 docs (one per user)
// Stage 3 ($sort by total DESC):         1,200 docs (reordered)
// Stage 4 ($limit 10):                      10 docs
// Output to client: 10 docs

db.sales.aggregate([
  // $group is a STAGE operator
  { $group: {
    _id: '$region',
    // $sum and $avg are EXPRESSION operators (accumulators here)
    totalRevenue: { $sum: '$amount' },
    avgOrder: { $avg: '$amount' },
    // $concat is an expression operator
    label: { $concat: ['Region: ', '$region'] }
  }}
]);

db.products.aggregate([
  { $project: {
    name: 1,
    // '$price' references the 'price' field value
    discountedPrice: { $multiply: ['$price', 0.9] },
    // 'price' without $ is a literal string
    label: 'price',  // all docs get the string 'price', not the field value
    // $$ROOT is a special variable for the whole document
    original: '$$ROOT'
  }}
]);

db.orders.aggregate([
  { $project: {
    _id: 1,
    orderDate: 1,
    daysOld: {
      $divide: [
        { $subtract: ['$$NOW', '$orderDate'] },  // $$NOW = current time
        1000 * 60 * 60 * 24  // convert ms to days
      ]
    },
    // Conditionally remove a field:
    sensitiveField: { $cond: { if: '$isAdmin', then: '$secret', else: '$$REMOVE' } }
  }}
]);

// Quick reference of the most-used stages:
// $match   - { $match: { field: condition } }
// $project - { $project: { keep: 1, drop: 0, computed: expr } }
// $group   - { $group: { _id: '$field', agg: { $sum: '$val' } } }
// $sort    - { $sort: { field: 1 or -1 } }
// $limit   - { $limit: N }
// $skip    - { $skip: N }
// $lookup  - { $lookup: { from, localField, foreignField, as } }
// $unwind  - { $unwind: '$arrayField' }

// BAD: expensive group before filter
db.orders.aggregate([
  { $group: { _id: '$userId', total: { $sum: '$amount' } } },
  { $match: { total: { $gt: 1000 } } }  // too late to use index
]);

// GOOD: filter first, then group
db.orders.aggregate([
  { $match: { status: 'completed', createdAt: { $gte: thisYear } } },
  { $group: { _id: '$userId', total: { $sum: '$amount' } } },
  { $match: { total: { $gt: 1000 } } }
]);

db.invoices.aggregate([
  { $project: {
    subtotal: '$subtotal',
    taxAmount: { $multiply: ['$subtotal', 0.08] },  // 8% tax
    total: { $add: ['$subtotal', { $multiply: ['$subtotal', 0.08] }] },
    discount: { $subtract: ['$listPrice', '$salePrice'] },
    margin: { $divide: [{ $subtract: ['$price', '$cost'] }, '$price'] }
  }}
]);

db.products.aggregate([
  { $project: {
    name: 1,
    price: 1,
    // Ternary: label products as budget or premium
    tier: {
      $cond: {
        if: { $lt: ['$price', 100] },
        then: 'budget',
        else: 'premium'
      }
    },
    // Fallback for missing description
    description: { $ifNull: ['$description', 'No description available'] }
  }}
]);

db.users.aggregate([
  { $project: {
    // Combine first and last name
    fullName: { $concat: ['$firstName', ' ', '$lastName'] },
    // Normalise email to lowercase
    emailNorm: { $toLower: '$email' },
    // Extract domain from email
    domain: {
      $arrayElemAt: [{ $split: ['$email', '@'] }, 1]
    }
  }}
]);

// Group orders by year and month
db.orders.aggregate([
  { $group: {
    _id: {
      year: { $year: '$createdAt' },
      month: { $month: '$createdAt' }
    },
    count: { $sum: 1 },
    revenue: { $sum: '$amount' }
  }},
  { $sort: { '_id.year': 1, '_id.month': 1 } }
]);