MongoDB $sortArray Operator

Example 1 — Sample Data

Imagine one player named Alice with four quiz scores, and one order with three products. We save them in players and orders.

db.players.insertOne({
  _id: 1,
  name: "Alice",
  scores: [85, 92, 78, 95]
});

db.orders.insertOne({
  _id: 1,
  orderId: "A100",
  items: [
    { name: "Keyboard", price: 80 },
    { name: "Cable", price: 10 },
    { name: "Mouse", price: 25 }
  ]
});

How the Data Is Stored in MongoDB

After the inserts, MongoDB keeps one document in each collection. Run find() to see them:

db.players.find()
db.orders.find()

// players
[
  {
    _id: 1,
    name: "Alice",
    scores: [85, 92, 78, 95]
  }
]

// orders
[
  {
    _id: 1,
    orderId: "A100",
    items: [
      { name: "Keyboard", price: 80 },
      { name: "Cable", price: 10 },
      { name: "Mouse", price: 25 }
    ]
  }
]

Read those documents like this:

Alice scores (as stored):
  [85, 92, 78, 95]

After sortBy: -1 (highest first):
  [95, 92, 85, 78]

Order items (as stored):
  Keyboard $80 → Cable $10 → Mouse $25

After sortBy: { price: 1 } (cheapest first):
  Cable $10 → Mouse $25 → Keyboard $80

How It Works

1. Insert once. insertOne adds Alice to players and the order to orders.
2. Arrays stay as written. Scores and items keep their original order until we sort them.
3. find() shows the same shape. What you inserted is what you get back—ready for $sortArray next.

Example 2 — Sort Scores Descending

Goal: return Alice’s scores from highest to lowest using sortBy: -1.

db.players.aggregate([
  {
    $addFields: {
      scoresSorted: {
        $sortArray: {
          input: "$scores",
          sortBy: -1
        }
      }
    }
  }
]);

{
  _id: 1,
  name: "Alice",
  scores: [85, 92, 78, 95],
  scoresSorted: [95, 92, 85, 78]
}

How It Works

1. Read the stored array. MongoDB already has scores: [85, 92, 78, 95] from Example 1.
2. Set direction. sortBy: -1 means larger numbers come first.
3. Build a new array. $sortArray returns [95, 92, 85, 78] without changing the original scores field in the database.
4. Keep all fields. $addFields adds scoresSorted next to the original data.

Example 3 — Sort Items by Price

Same idea for an array of documents: pass a field map in sortBy so the cheapest item comes first.

db.orders.aggregate([
  {
    $addFields: {
      itemsByPrice: {
        $sortArray: {
          input: "$items",
          sortBy: { price: 1 }
        }
      }
    }
  }
]);

{
  _id: 1,
  orderId: "A100",
  items: [
    { name: "Keyboard", price: 80 },
    { name: "Cable", price: 10 },
    { name: "Mouse", price: 25 }
  ],
  itemsByPrice: [
    { name: "Cable", price: 10 },
    { name: "Mouse", price: 25 },
    { name: "Keyboard", price: 80 }
  ]
}

How It Works

1. Same stored order. Still using the three line items from Example 1.
2. Sort by a field. sortBy: { price: 1 } compares each item’s price ascending.
3. Whole documents move together. Name and price stay paired—Cable ($10) becomes first.
4. Easy check. Cheapest → mid → most expensive: 10, 25, 80.