Data Types

Equality and Sort Order

Values of the Decimal128 type are compared and sorted with other numeric types based on their actual numeric value. Numeric values of the binary-based Double type generally have approximate representations of decimal-based values and may not be exactly equal to their decimal representations.

Return Date as a String

To return the date as a string, use the Date() method, as in the following example:

var myDateString = Date();

To print the value of the variable, type the variable name in the shell, as in the following:

myDateString

The result is the value of myDateString:

Wed Dec 19 2012 01:03:25 GMT-0500 (EST)

To verify the type, use the typeof operator, as in the following:

typeof myDateString

The operation returns string.

Return Date

mongosh wraps objects of Date type with the ISODate helper; however, the objects remain of type Date.

The following example uses both the new Date() constructor and the ISODate() constructor to return Date objects.

var myDate = new Date();
var myDateInitUsingISODateWrapper = ISODate();

You can use the new operator with the ISODate() constructor as well.

To print the value of the variable, type the variable name in the shell, as in the following:

myDate

The result is the Date value of myDate wrapped in the ISODate() helper:

ISODate("2012-12-19T06:01:17.171Z")

To verify the type:

var myDate = ISODate("2021-03-21T06:00:00.171Z")
Object.prototype.toString.call(myDate) === "[object Date]"

The operation returns true.

Numeric Types

Consider the types collection:

{ _id: 1, value: 1, expectedType: 'Int32' },
{ _id: 2, value: Long("1"), expectedType: 'Long' },
{ _id: 3, value: 1.01, expectedType: 'Double' },
{ _id: 4, value: Decimal128("1.01"), expectedType: 'Decimal128' },
{ _id: 5, value: 3200000001, expectedType: 'Double' }

This table shows the results of the db.types.find( <QUERY> ) command for the corresponding <QUERY>. The type names and aliases are given on the BSON types page.

{
   "value":
      {
         $type: "int"
      }
}

{
   _id: 1,
   value: 1,
   expectedType: 'Int32'
}

{
   "value":
      {
         $type: "long"
      }
}

{
   _id: 2,
   value: Long("1"),
   expectedType: 'Long'
}

{
   "value":
      {
         $type: "decimal"
      }
}

{
   _id: 4,
   value: Decimal128("1"),
   expectedType: 'Decimal128'
}

{
   "value":
      {
         $type: "double"
      }
}

{
   _id: 3,
   value: 1.01,
   expectedType: 'Double'
}
{
   _id: 5,
   value: 3200000001,
   expectedType: 'Double'
}

{
   "value":
      {
         $type: "number"
      }
}

{
    _id: 1,
    value: 1,
    expectedType: 'Int32'
}
{
    _id: 2,
    value: Long("1"),
    expectedType: 'Long'
}
{
    _id: 3,
    value: 1.01,
    expectedType: 'Double'
}
{
    _id: 4,
    value: Decimal128("1.01"),
    expectedType: 'Decimal128'
}
{
    _id: 5,
    value: 3200000001,
    expectedType: 'Double'
}

{
    "value": 1.01
}

{
    _id: 3,
    value: 1.01,
    expectedType: 'Double'
}

{
    "value": 1
}

{
    _id: 1,
    value: 1,
    expectedType: 'Int32'
}
{
    _id: 2,
    value: Long("1"),
    expectedType: 'Long'
}

The query { "value": 1.01 } implicitly searches for the Double representation of 1.01. Document _id: 4 is a Decimal128 so it is not selected.

Note, however, that { "value": 1 } returns both Int32 and Long types.

Default Numeric Type Consistency

Consider the typeExample collection. This collection consists of two identical documents, { "a": 1 }. The first document was created in the legacy mongo shell, the second document was created in mongosh.

We can use the $type operator in an aggregation pipeline to see the type that was assigned in each shell.

db.typeExample.aggregate(
  [
    {
       $project:
         {
           "valueType":
             {
               "$type": "$a"
             },
           "_id": 0
         }
    }
  ]
)

In the first document, created in the legacy mongo shell, the value was stored as a double. In the mongosh document the value was stored as type int.

[
  {
     valueType: 'double'  // inserted in legacy mongo shell
  },
  {
     valueType: 'int'     // inserted in mongosh
  }
]

Timestamp a New Document

Use Timestamp() without parameters to insert multiple documents using the default settings:

db.flights.insertMany(
   [
      { arrival: "true", ts: Timestamp() },
      { arrival: "true", ts: Timestamp() },
      { arrival: "true", ts: Timestamp() }
   ]
)

Run db.flights.find({}) to see the timestamps. Notice that even though all three entries were stamped in the same second, the interval was incremented on each one.

[
   {
      _id: ObjectId("6114216907d84f5370391919"),
      arrival: 'true',
      ts: Timestamp({ t: 1628709225, i: 1 })
   },
   {
      _id: ObjectId("6114216907d84f537039191a"),
      arrival: 'true',
      ts: Timestamp({ t: 1628709225, i: 2 })
   },
   {
      _id: ObjectId("6114216907d84f537039191b"),
      arrival: 'true',
      ts: Timestamp({ t: 1628709225, i: 3 })
   }
]

Create a Custom Timestamp

Use custom parameters to insert multiple documents with a specific Timestamp.

This operation inserts three documents into the flights collection and uses the UNIX epoch value 1627811580 to set the ts times to 9:53 GMT on August 1, 2021.

db.flights.insertMany(
   [
      { arrival: "true", ts: Timestamp(1627811580, 10) },
      { arrival: "true", ts: Timestamp(1627811580, 20) },
      { arrival: "true", ts: Timestamp(1627811580, 30) }
   ]
)

The resulting documents look like this:

[
   {
      _id: ObjectId("6123d8315e6bba6f61a1031c"),
      arrival: 'true',
      ts: Timestamp({ t: 1627811580, i: 10 })
   },
   {
      _id: ObjectId("6123d8315e6bba6f61a1031d"),
      arrival: 'true',
      ts: Timestamp({ t: 1627811580, i: 20 })
   },
   {
      _id: ObjectId("6123d8315e6bba6f61a1031e"),
      arrival: 'true',
      ts: Timestamp({ t: 1627811580, i: 30 })
   }
]

Type Checking with $type()

The $type query operator accepts either a string alias or a numeric code corresponding to the data type. See BSON Types for a list of BSON data types and their corresponding numeric codes.

For example, these checks for the Decimal128 type are equivalent:

db.types.find( { "value": { $type: "decimal" } } )
db.types.find( { "value": { $type: 19 } } )

Type Checking with a Constructor

Examine the object constructor to determine the type. For example, the output of db.collection.find() is a Cursor.

var findResults = db.housing.find({"multiUnit": true} )
findResults.constructor.name     // Returns the type