$type

Definition

• $type
• $type selects documents where the value of thefield is an instance of the specified BSON type(s).Querying by data type is useful when dealing with highlyunstructured data where data types are not predictable.

A $type expression for a single BSON type hasthe following syntax:

Changed in version 3.2.

{ field: { $type: <BSON type> } }

You can specify either the number or alias for the BSONtype

The $type expression can also accept an array of BSONtypes and has the following syntax:

{ field: { $type: [ <BSON type1> , <BSON type2>, ... ] } }

The above query will match documents where the field value isany of the listed types. The types specified in the array can beeither numeric or string aliases.

See Querying by Multiple Data Type for an example.

Available Types describes the BSON types andtheir corresponding numeric and string aliases.

See also

If you wish to obtain the BSON type returnedby an operator expressionrather than filtering documents by their BSON type, use the$type aggregation operator.

Behavior

$type returns documents where the BSON type of the fieldmatches the BSON type passed to $type.

Arrays

For documents where field is an array, $type returnsdocuments in which at least one array element matches a type passed to$type.

Querying for the Array BSON Type

With MongoDB 3.6 and later, querying for $type: "array" returnsdocuments where the field itself is an array. Prior to MongoDB 3.6,$type: "array" returned documents where the field is an arraycontaining at least one element of type array. For example, giventhe following documents:

{ "data" : [ "values", [ "values" ] ] }
{ "data" : [ "values" ] }

With MongoDB 3.6 and later, the queryfind( {"data" : { $type : "array" } } ) returns both documents.Prior to MongoDB 3.6, the query returns only the first document.

Available Types

Starting in MongoDB 3.2, $type operator accepts string aliasesfor the BSON types in addition to the numbers corresponding to the BSONtypes. Previous versions only accepted the numbers corresponding to theBSON type. [1]

$type supports the number alias, which will match against thefollowing BSON types:

• double
• 32-bit integer
• 64-bit integer
• decimal

For examples, see Examples.

MinKey and MaxKey

MinKey and MaxKeyare used in comparison operations and exist primarily for internal use.For all possible BSON element values, MinKey will always be thesmallest value while MaxKey will always be the greatest value.

Querying for minKey or maxKey with $typewill only return fields that matchthe special MinKey or MaxKey values.

Suppose that the data collection has two documentswith MinKey and MaxKey:

{ "_id" : 1, x : { "$minKey" : 1 } }
{ "_id" : 2, y : { "$maxKey" : 1 } }

The following query will return the document with _id: 1:

db.data.find( { x: { $type: "minKey" } } )

The following query will return the document with _id: 2:

db.data.find( { y: { $type: "maxKey" } } )

Examples

Querying by Data Type

The addressBook contains addresses and zipcodes, wherezipCode has string, int, double, and longvalues:

db.addressBook.insertMany(
   [
      { "_id" : 1, address : "2030 Martian Way", zipCode : "90698345" },
      { "_id" : 2, address: "156 Lunar Place", zipCode : 43339374 },
      { "_id" : 3, address : "2324 Pluto Place", zipCode: NumberLong(3921412) },
      { "_id" : 4, address : "55 Saturn Ring" , zipCode : NumberInt(88602117) },
      { "_id" : 5, address : "104 Venus Drive", zipCode : ["834847278", "1893289032"]}
   ]
)

The following queries return all documents where zipCode is theBSON type string or is an array containing an element ofthe specified type:

db.addressBook.find( { "zipCode" : { $type : 2 } } );
db.addressBook.find( { "zipCode" : { $type : "string" } } );

These queries return:

{ "_id" : 1, "address" : "2030 Martian Way", "zipCode" : "90698345" }
{ "_id" : 5, address : "104 Venus Drive", zipCOde : ["834847278", "1893289032"]}

The following queries return all documents where zipCode is theBSON type double or is an array containing an element ofthe specified type:

db.addressBook.find( { "zipCode" : { $type : 1 } } )
db.addressBook.find( { "zipCode" : { $type : "double" } } )

These queries return:

{ "_id" : 2, "address" : "156 Lunar Place", "zip" : 43339374 }

The following query uses the number alias to return documents wherezipCode is the BSON type double, int, or longor is an array containing an element of the specified types:

db.addressBook.find( { "zipCode" : { $type : "number" } } )

These queries return:

{ "_id" : 2, address : "156 Lunar Place", zipCode : 43339374 }
{ "_id" : 3, address : "2324 Pluto Place", zipCode: NumberLong(3921412) }
{ "_id" : 4, address : "55 Saturn Ring" , zipCode : 88602117 }

Querying by Multiple Data Type

The grades collection contains names and averages, whereclassAverage has string, int, and double values:

db.grades.insertMany(
   [
      { "_id" : 1, name : "Alice King" , classAverage : 87.333333333333333 },
      { "_id" : 2, name : "Bob Jenkins", classAverage : "83.52" },
      { "_id" : 3, name : "Cathy Hart", classAverage: "94.06" },
      { "_id" : 4, name : "Drew Williams" , classAverage : 93 }
   ]
)

The following queries return all documents where classAverage is theBSON type string or double or is an array containingan element of the specified types. The first query uses numeric aliaseswhile the second query uses string aliases.

db.grades.find( { "classAverage" : { $type : [ 2 , 1 ] } } );
db.grades.find( { "classAverage" : { $type : [ "string" , "double" ] } } );

These queries return the following documents:

{ "_id" : 1, name : "Alice King" , classAverage : 87.333333333333333 }
{ "_id" : 2, name : "Bob Jenkins", classAverage : "83.52" }
{ "_id" : 3, name : "Cathy Hart", classAverage: "94.06" }

Querying by MinKey and MaxKey

The restaurants collection uses minKey for any grade that is afailing grade:

{
   "_id": 1,
   "address": {
      "building": "230",
      "coord": [ -73.996089, 40.675018 ],
      "street": "Huntington St",
      "zipcode": "11231"
   },
   "borough": "Brooklyn",
   "cuisine": "Bakery",
   "grades": [
      { "date": new Date(1393804800000), "grade": "C", "score": 15 },
      { "date": new Date(1378857600000), "grade": "C", "score": 16 },
      { "date": new Date(1358985600000), "grade": MinKey(), "score": 30 },
      { "date": new Date(1322006400000), "grade": "C", "score": 15 }
   ],
   "name": "Dirty Dan's Donuts",
   "restaurant_id": "30075445"
}

And maxKey for any grade that is the highest passing grade:

{
   "_id": 2,
   "address": {
      "building": "1166",
      "coord": [ -73.955184, 40.738589 ],
      "street": "Manhattan Ave",
      "zipcode": "11222"
   },
   "borough": "Brooklyn",
   "cuisine": "Bakery",
   "grades": [
      { "date": new Date(1393804800000), "grade": MaxKey(), "score": 2 },
      { "date": new Date(1378857600000), "grade": "B", "score": 6 },
      { "date": new Date(1358985600000), "grade": MaxKey(), "score": 3 },
      { "date": new Date(1322006400000), "grade": "B", "score": 5 }
   ],
   "name": "Dainty Daisey's Donuts",
   "restaurant_id": "30075449"
}

The following query returns any restaurant whose grades.grade fieldcontains minKey or is an array containing an element ofthe specified type:

db.restaurants.find(
   { "grades.grade" : { $type : "minKey" } }
)

This returns

{
   "_id" : 1,
   "address" : {
      "building" : "230",
      "coord" : [ -73.996089, 40.675018 ],
      "street" : "Huntington St",
      "zipcode" : "11231"
   },
   "borough" : "Brooklyn",
   "cuisine" : "Bakery",
   "grades" : [
      { "date" : ISODate("2014-03-03T00:00:00Z"), "grade" : "C", "score" : 15 },
      { "date" : ISODate("2013-09-11T00:00:00Z"), "grade" : "C", "score" : 16 },
      { "date" : ISODate("2013-01-24T00:00:00Z"), "grade" : { "$minKey" : 1 }, "score" : 30 },
      { "date" : ISODate("2011-11-23T00:00:00Z"), "grade" : "C", "score" : 15 }
   ],
   "name" : "Dirty Dan's Donuts",
   "restaurant_id" : "30075445"
}

The following query returns any restaurant whose grades.grade fieldcontains maxKey or is an array containing an element ofthe specified type:

db.restaurants.find(
   { "grades.grade" : { $type : "maxKey" } }
)

This returns

{
   "_id" : 2,
   "address" : {
      "building" : "1166",
      "coord" : [ -73.955184, 40.738589 ],
      "street" : "Manhattan Ave",
      "zipcode" : "11222"
   },
   "borough" : "Brooklyn",
   "cuisine" : "Bakery",
   "grades" : [
      { "date" : ISODate("2014-03-03T00:00:00Z"), "grade" : { "$maxKey" : 1 }, "score" : 2 },
      { "date" : ISODate("2013-09-11T00:00:00Z"), "grade" : "B", "score" : 6 },
      { "date" : ISODate("2013-01-24T00:00:00Z"), "grade" : { "$maxKey" : 1 }, "score" : 3 },
      { "date" : ISODate("2011-11-23T00:00:00Z"), "grade" : "B", "score" : 5 }
   ],
   "name" : "Dainty Daisey's Donuts",
   "restaurant_id" : "30075449"
}

Querying by Array Type

A collection named SensorReading contains the following documents:

{
   "_id": 1,
   "readings": [
      25,
      23,
      [ "Warn: High Temp!", 55 ],
      [ "ERROR: SYSTEM SHUTDOWN!", 66 ]
   ]
},
{
   "_id": 2,
   "readings": [
      25,
      25,
      24,
      23
   ]
},
{
   "_id": 3,
   "readings": [
      22,
      24,
      []
   ]
},
{
   "_id": 4,
   "readings": []
},
{
   "_id": 5,
   "readings": 24
}

The following query returns any document in which the readingsfield is an array, empty or non-empty.

db.SensorReading.find( { "readings" : { $type: "array" } } )

The above query returns the following documents:

{
   "_id": 1,
   "readings": [
      25,
      23,
      [ "Warn: High Temp!", 55 ],
      [ "ERROR: SYSTEM SHUTDOWN!", 66 ]
   ]
},
{
   "_id": 2,
   "readings": [
      25,
      25,
      24,
      23
   ]
},
{
   "_id": 3,
   "readings": [
      22,
      24,
      []
   ]
},
{
   "_id": 4,
   "readings": []
}

In the documents with _id : 1, _id : 2, _id : 3, and_id : 4, the readings field is an array.

Additional Information

• Query for Null or Missing Fields
• db.collection.find()
• BSON Types.