MongoDB: Comparison/Sort Order

When comparing values of different BSON types, MongoDB uses the following comparison order, from lowest to highest:

  1. MinKey (internal type)
  2. Null
  3. Numbers (ints, longs, doubles, decimals)
  4. Symbol, String
  5. Object
  6. Array
  7. BinData
  8. ObjectId
  9. Boolean
  10. Date
  11. Timestamp
  12. Regular Expression
  13. MaxKey (internal type)

Numeric Types

MongoDB treats some types as equivalent for comparison purposes. For instance, numeric types undergo conversion before comparison.


Binary Comparison

By default, MongoDB uses the simple binary comparison to compare strings.


Collation allows users to specify language-specific rules for string comparison, such as rules for lettercase and accent marks.

Collation specification has the following syntax:

{   locale: <string>,   caseLevel: <boolean>,   caseFirst: <string>,   strength: <int>,   numericOrdering: <boolean>,   alternate: <string>,   maxVariable: <string>,   backwards: <boolean>}

When specifying collation, the locale field is mandatory; all other collation fields are optional. For descriptions of the fields, see Collation Document.

If no collation is specified for the collection or for the operations, MongoDB uses the simple binary comparison used in prior versions for string comparisons.


In array comparisons:

  • A less-than comparison, or an ascending sort, compares the smallest elements of the array according to the BSON type sort order.
  • A greater-than comparison, or a descending sort, compares the largest elements of the array according to the reverse BSON type sort order.
  • When comparing a field whose value is a one element array (example, [ 1 ]) with non-array fields (example, 2), the comparison is for 1 and 2.
  • A comparison of an empty array (example, [ ]) considers the empty array as less than a null value or a missing field value.


MongoDB’s comparison of BSON objects uses the following order:

  1. Recursively compare key-value pairs in the order that they appear within the BSON object.
  2. Compare the field types. MongoDB uses the following comparison order for field types, from lowest to highest:
  3. MinKey (internal type)
  4. Null
  5. Numbers (ints, longs, doubles, decimals)
  6. Symbol, String
  7. Object
  8. Array
  9. BinData
  10. ObjectId
  11. Boolean
  12. Date
  13. Timestamp
  14. Regular Expression
  15. MaxKey (internal type)
  16. If the field types are equal, compare the key field names.
  17. If the key field names are equal, compare the field values.
  18. If the field values are equal, compare the next key/value pair (return to step 1). An object without further pairs is less than an object with further pairs.

Dates and Timestamps

Date objects sort before Timestamp objects.

Non-existent Fields

The comparison treats a non-existent field as if it were an empty BSON Object. As such, a sort on the a field in documents { } and { a: null } would treat the documents as equivalent in sort order.


MongoDB sorts BinData in the following order:

  1. First, the length or size of the data.
  2. Then, by the BSON one-byte subtype.
  3. Finally, by the data, performing a byte-by-byte comparison.



Consulting Engineer @ MongoDB

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store