The $ceil operator rounds a number up to the nearest integer in MongoDB aggregation pipelines. It is MongoDB’s version of Math.ceil() and is useful whenever partial values must count as a full unit.
Always toward +∞.
One expression inside $ceil.
Add computed fields easily.
ceil(-2.3) = -2
Billing, charts, counts.
Up vs down rounding.
In MongoDB’s aggregation framework, the $ceil operator returns the smallest integer greater than or equal to the input. For example, $ceil(23.5) returns 24, and $ceil(14.2) returns 15. Integers pass through unchanged: $ceil(5) returns 5.
Use $ceil when you need to always round up — like charging for a full shipping box when an order slightly exceeds capacity. For nearest-integer rounding, use $round instead.
The $ceil operator takes one numeric expression:
{ $ceil: <expression> }$ceil — rounds the expression up to the nearest integer.<expression> — can be a field path, a literal number, or another numeric expression.$project, $addFields, or $set.null, the result is null.All three round numbers, but in different directions:
$ceil: 24, $floor: 23, $round: 24$ceil: 24, $floor: 23, $round: 23$ceil: -2, $floor: -3, $round: -2| Question | Answer |
|---|---|
| Operator type | Aggregation expression operator (rounding) |
| Syntax | { $ceil: <expression> } |
| Direction | Up (toward +∞) |
| Output | Integer (or null) |
| Common stages | $project, $addFields, $set |
{
$ceil: 23.5
}Returns 24
{
$ceil: -2.3
}Returns -2
{
$ceil: 5
}Returns 5
{
$ceil: null
}Returns null
Round temperature readings up, handle negative values, and calculate billing units from partial quantities.
Use a temperatures collection and round readings up to whole numbers with $project.
Suppose you have a temperatures collection with decimal readings:
[
{ "_id": ObjectId("609c26812e9274a86871bc6a"), "location": "New York", "temperature": 23.5 },
{ "_id": ObjectId("609c26812e9274a86871bc6b"), "location": "Los Angeles", "temperature": 18.9 },
{ "_id": ObjectId("609c26812e9274a86871bc6c"), "location": "Chicago", "temperature": 14.2 }
]Round up temperature readings to the nearest integer:
db.temperatures.aggregate([
{
$project: {
location: 1,
temperature: 1,
roundedTemperature: { $ceil: "$temperature" }
}
}
])ceil(23.5) → 24.ceil(18.9) → 19.ceil(14.2) → 15.Handle negative numbers, calculate billing units, and compare rounding operators side by side.
$ceil rounds toward positive infinity, not away from zero:
db.readings.aggregate([
{
$project: {
value: 1,
ceiled: { $ceil: "$value" },
floored: { $floor: "$value" },
rounded: { $round: "$value" }
}
}
])
// value: -2.3 → ceiled: -2, floored: -3, rounded: -2
// value: -2.0 → ceiled: -2, floored: -2, rounded: -2
// value: 2.3 → ceiled: 3, floored: 2, rounded: 2For negatives, $ceil moves right on the number line toward zero. This surprises beginners who expect -2.3 to become -3 — that is $floor.
When items ship in boxes of 10, any partial box counts as a full box:
db.orders.aggregate([
{
$project: {
orderId: 1,
quantity: 1,
boxesNeeded: {
$ceil: { $divide: [ "$quantity", 10 ] }
}
}
}
])
// quantity: 25 → boxesNeeded: 3
// quantity: 30 → boxesNeeded: 3
// quantity: 31 → boxesNeeded: 4$divide gives a decimal. $ceil ensures you never under-count partial units — a classic pattern in logistics and billing pipelines.
See all three rounding operators on the same field:
db.samples.aggregate([
{
$project: {
price: 1,
ceilPrice: { $ceil: "$price" },
floorPrice: { $floor: "$price" },
roundPrice: { $round: "$price" }
}
}
])
// price: 19.99 → ceil: 20, floor: 19, round: 20
// price: 19.49 → ceil: 20, floor: 19, round: 19
// price: 19.00 → ceil: 19, floor: 19, round: 19Choose $ceil when you must never under-charge or under-allocate. Choose $floor to always round down, and $round for standard nearest-integer behavior.
$ceil WorksThe pipeline evaluates the input — a field like "$temperature" or a numeric expression.
MongoDB returns the smallest integer ≥ the input, moving toward positive infinity.
The integer is written to the field you define in $project or $addFields.
Use the rounded value for billing, reporting, or downstream calculations.
The $ceil operator is a straightforward rounding tool in MongoDB aggregation pipelines. It always rounds up toward positive infinity, which makes it ideal for billing, capacity planning, and any scenario where partial units must count as a full unit.
For beginners, remember: ceil(-2.3) = -2 (not -3), integers pass through unchanged, and pair with $divide for box-or-batch calculations.
$ceil when partial units must count as full units$divide for box/batch calculations$floor and $round before choosing$ifNull when needed$ceil rounds away from zero on negatives$ceil when nearest-integer rounding is enough$ceil with $round or $floor$ceil as a query filter outside expressionsceil(5.0) returns 5 unchanged$ceilUse these points when rounding numbers in MongoDB.
Toward +∞ always.
Purpose{ $ceil: expr }
ceil(-2.3) = -2.
Edge caseceil(qty / size).
PatternUp, not nearest.
ImportantMove on to $cmp for value comparison, or review $round for standard rounding.
5 people found this page helpful