$type

Nesta página

Definição

Compatibilidade
Sintaxe
Comportamento
Exemplos
Query por tipo de array
Informações adicionais

Definição

$type: $type seleciona documentos onde o valor do field é uma instância do(s) tipo(s) deBSON especificado(s). A query por tipo de dados é útil ao lidar com dados altamente não estruturados onde os tipos de dados não são previsíveis.

Compatibilidade

Você pode utilizar o $type para implantações hospedadas nos seguintes ambientes:

MongoDB Atlas: o serviço totalmente gerenciado para implantações do MongoDB na nuvem

MongoDB Enterprise: a versão autogerenciada e baseada em assinatura do MongoDB
MongoDB Community: uma versão com código disponível, de uso gratuito e autogerenciada do MongoDB

Sintaxe

Uma expressão $type para um único tipo de BSON tem a seguinte sintaxe:

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

Você pode especificar o número ou o apelido do tipo BSON.

A expressão $type também pode aceitar um array de tipos de BSON e tem a seguinte sintaxe:

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

A query acima corresponde a documentos em que o valor field é qualquer um dos tipos listados. Os tipos especificados no array podem ser apelidos numéricos ou de string.

Consulte Query por vários tipos de dados para ver um exemplo.

Tipos disponíveis descreve os tipos de BSON e seus apelidos numéricos e de string correspondentes.

Dica

Veja também:

$isNumber - verifica se o argumento é um número.
$type (Aggregation) - retorna o tipo de BSON do argumento.

Comportamento

$type retorna documentos em que o tipo de BSON do field corresponde ao tipo de BSON passado para $type.

arrays

Para documentos em que field é uma array, $type retorna documentos nos quais pelo menos um elemento de array corresponde a um tipo passado para $type.

Queries de $type: "array" retornam documentos onde o próprio campo é uma array.

Tipos disponíveis

O operador $type aceita apelidos de string para os tipos de BSON, além dos números correspondentes aos tipos de BSON. [1]

Tipo	Número	Alias	Notas
Double	1	"double"
String	2	"string"
Objeto	3	"objeto"
Array	4	"array"
Dados binários	5	"binData"
Indefinido	6	" indefinido "	Obsoleto.
ObjectId	7	"objectId"
Boolean	8	"bool"
Data	9	"data"
Zero	10	"nulo"
Expressão regular	11	"regex"
DBPointer	12	"dbPointer"	Obsoleto.
JavaScript	13	"javascript"
Símbolo	14	"símbolo"	Obsoleto.
Inteiro de bits	16	"int"
Timestamp	17	" carimbo de data/hora "
Inteiro de 64 bits	18	"long"
Decimal128	19	"decimal"
Min key	-1	"minKey"
Tecla máxima	127	"maxKey"

$type suporta o alias number, que corresponde aos seguintes tipos de BSON:

Por exemplo, consulte Exemplos.

[1]	Os usuários não podem mais utilizar o filtro de query `$type: 0` como sinônimo de `$exists:false`. Para consultar campos nulos ou ausentes, consulte Query para campos nulos ou ausentes.

Dica

Veja também:

$isNumber

MinKey e MaxKey

MinKey e MaxKey são usados em operações de comparação e existem principalmente para uso interno. Para todos os valores de elemento BSON possíveis, MinKey é sempre o menor valor, enquanto MaxKey é sempre o maior valor.

Consultar minKey ou maxKey com $type retorna apenas campos que correspondem aos valores especiais MinKey ou MaxKey.

Suponha que a collection data tenha dois documentos com MinKey e MaxKey:

db.data.insertMany( [
   { _id : 1, x : { "$minKey" : 1 } },
   { _id : 2, y : { "$maxKey" : 1 } }
] )

A query abaixo retorna o documento com _id: 1:

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

A query abaixo retorna o documento com _id: 2:

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

Exemplos

Query por tipo de dados

addressBook contém endereços e códigos postais, onde zipCode tem valores de string, int, double e long:

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"] }
] )

As queries a seguir retornam todos os documentos em que zipCode é o tipo de BSON string ou é uma array que contém um elemento do tipo especificado:

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

Essas queries retornam:

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

As queries a seguir retornam todos os documentos em que zipCode é o tipo de BSON double ou é uma array que contém um elemento do tipo especificado:

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

Essas queries retornam:

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

A query a seguir usa o apelido number para retornar documentos em que zipCode é o tipo de BSON double, int ou long ou é uma array que contém um elemento dos tipos especificados:

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

Essas queries retornam:

{ _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 }

Query por vários tipos de dados

A collection grades contém nomes e médias, onde classAverage tem valores string, int e double:

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 : NumberInt("93") }
] )

As queries a seguir retornam todos os documentos em que classAverage é o tipo de BSON string ou double ou é uma array que contém um elemento dos tipos especificados. A primeira query utiliza apelidos numéricos, enquanto a segunda query utiliza apelidos de string.

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

Essas queries retornam os seguintes documentos:

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

Query por MinKey e MaxKey

A collection restaurants usa minKey para qualquer nota que seja reprovada:

db.restaurants.insertOne( [
   {
      _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"
   }
] )

E maxKey para qualquer nota que seja a nota mais alta para passar:

db.restaurants.insertOne( [
   {
      _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"
   }
] )

A seguinte query retorna qualquer restaurante cujo campo grades.grade contém minKey ou é uma array contendo um elemento do tipo especificado:

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

Isso retorna os seguintes resultados:

{
   _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"
}

A seguinte query retorna qualquer restaurante cujo campo grades.grade contém maxKey ou é uma array contendo um elemento do tipo especificado:

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

Isso retorna os seguintes resultados:

{
   _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"
}

Query por tipo de array

Uma coleção chamada sensorReading contém os seguintes documentos:

db.sensorReading.insertMany( [
   { _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 }
] )

A query a seguir retorna qualquer documento em que o campo readings seja uma array, vazia ou não vazia.

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

A query acima retorna os seguintes documentos:

{
   _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 : []
}

Nos documentos com _id : 1, _id : 2, _id : 3 e _id : 4, o campo readings é uma array.

Informações adicionais

Voltar

$exists

Consulta de avaliação