MongoDB $pow Operator

What You’ll Learn

The $pow operator raises a number to an exponent in MongoDB aggregation pipelines. It computes base^exponent — useful for squaring dimensions, cubing edges, compound growth, and any power-based math.

Definition and Usage

In MongoDB’s aggregation framework, the $pow operator returns base raised to the exponent. For example, { $pow: [ 2, 3 ] } returns 8 (2³), and { $pow: [ "$radius", 2 ] } squares the radius field.

Like $multiply and $divide, $pow is an aggregation expression operator. Use it inside $project, $addFields, or nested expressions — not as a standalone query filter.

📝 Syntax

The $pow operator takes an array of exactly two expressions:

{ $pow: [ <number>, <exponent> ] }

Syntax Rules

• First operand — the base (number to raise).
• Second operand — the exponent (power).
• Array required — always wrap both operands in square brackets.
• Operands can be field paths ("$radius"), literals (2), or nested expressions.
• Use inside stages like $project, $addFields, or $set.
• If either operand is null, the result is null.
• Exponent 0 returns 1 (except for 0^0, which MongoDB treats as 1).

Examples Gallery

Square dimensions for area, cube edges for volume, compute circle area with πr², and model compound growth.

db.samples.aggregate([
  {
    $project: {
      result: { $pow: [ 2, 3 ] }
    }
  }
])

// result: 8

{ "result": 8 }

[
  { "_id": 1, "name": "Square A",  "side": 5,  "radius": null },
  { "_id": 2, "name": "Square B",  "side": 10, "radius": null },
  { "_id": 3, "name": "Circle C",  "side": null, "radius": 3 },
  { "_id": 4, "name": "Cube D",    "edge": 4 }
]

db.shapes.aggregate([
  {
    $match: { side: { $ne: null } }
  },
  {
    $project: {
      name: 1,
      side: 1,
      area: { $pow: [ "$side", 2 ] }
    }
  }
])

{ "name": "Square A", "side": 5,  "area": 25 }
{ "name": "Square B", "side": 10, "area": 100 }

db.shapes.aggregate([
  {
    $match: { radius: { $ne: null } }
  },
  {
    $project: {
      name: 1,
      radius: 1,
      area: {
        $multiply: [
          3.14159,
          { $pow: [ "$radius", 2 ] }
        ]
      }
    }
  }
])

db.shapes.aggregate([
  {
    $project: {
      name: 1,
      edge: 1,
      volume: { $pow: [ "$edge", 3 ] }
    }
  }
])

// edge: 4 → volume: 64

db.investments.aggregate([
  {
    $project: {
      principal: 1,
      rate: 1,
      years: 1,
      futureValue: {
        $multiply: [
          "$principal",
          {
            $pow: [
              { $add: [ 1, "$rate" ] },
              "$years"
            ]
          }
        ]
      }
    }
  }
])

// principal: 1000, rate: 0.05, years: 3
// futureValue: 1000 × 1.05³ ≈ 1157.63

db.samples.aggregate([
  {
    $project: {
      value: 1,
      rootPow:  { $pow: [ "$value", 0.5 ] },
      rootSqrt: { $sqrt: "$value" }
    }
  }
])

// Both return the square root of value

🚀 Use Cases

• Geometry — compute area (side², r²) and volume (edge³) from dimensions.
• Compound growth — model investment or population growth with (1 + rate)^t.
• Distance metrics — square differences before summing in Euclidean distance formulas.
• Scientific scaling — apply power-law transformations to sensor or lab data.

💡 Best Practices