Tipos de dados

Igualdade e ordem de classificação

Os valores do tipo Decimal128 são comparados e classificados com outros tipos numéricos com base em seu valor numérico real. Os valores numéricos do tipo Double com base binária geralmente têm representações aproximadas dos valores com base decimal e podem não ser exatamente iguais às suas representações decimais.

Data de retorno como uma cadeia de caracteres

Para retornar a data como uma string, utilize o método Date(), como no seguinte exemplo:

var myDateString = Date();

Para imprimir o valor da variável, digite o nome da variável no shell, conforme a seguir:

myDateString

O resultado é o valor de myDateString:

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

Para verificar o tipo, utilize o operador typeof, como no seguinte:

typeof myDateString

A operação retorna string.

Data de devolução

mongosh agrupa objetos do tipo Date com o auxiliar ISODate ; entretanto, os objetos permanecem do tipo Date.

O exemplo seguinte utiliza o construtor new Date() e o construtor ISODate() para retornar objetos Date.

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

Você também pode utilizar o operador new com o construtor ISODate().

Para imprimir o valor da variável, digite o nome da variável no shell, conforme a seguir:

myDate

O resultado é o valor Date de myDate envolto no auxiliar ISODate():

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

Para verificar o tipo:

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

A operação retorna true.

Tipos Numéricos

Considere a collection types:

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

Esta tabela mostra os resultados do comando db.types.find( <QUERY> ) para o <QUERY> correspondente. Os nomes de tipo e aliases são fornecidos na página de tipos de BSON .

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

A query { "value": 1.01 } pesquisa implicitamente a representação Double do 1.01. O documento _id: 4 é Decimal128, portanto não está selecionado.

Observe, no entanto, que { "value": 1 } retorna os tipos Int32 e Long.

Consistência de tipo numérico padrão

Considere a coleção typeExample. Esta coleção consiste em dois documentos idênticos, { "a": 1 }. O primeiro documento foi criado na shell legada de mongo, o segundo documento foi criado em mongosh.

Podemos usar o operador $type em um pipeline de agregação para ver o tipo atribuído em cada shell.

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

No primeiro documento, criado na shell mongo legada, o valor foi armazenado como double. No documento mongosh o valor foi armazenado como tipo int.

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

Timestamp de um novo documento

Use Timestamp() sem parâmetros para inserir vários documentos usando as configurações padrão:

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

Execute db.flights.find({}) para ver os timestamps. Observe que, embora todas as três entradas tenham sido marcadas no mesmo segundo, o intervalo foi incrementado em cada uma delas.

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

Criar um timestamp personalizado

Use parâmetros personalizados para inserir vários documentos com um Timestamp específico.

Esta operação insere três documento na coleção flights e usa o valor de Era UNIX 1627811580 para definir os horários de ts para 9:53 GMT em 1 agosto de 2021.

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

Os documentos resultantes têm a seguinte aparência:

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

Digite Verificando com $type()

O operador de query $type aceita um alias de string ou um código numérico correspondente ao tipo de dados. Consulte Tipos BSON para obter uma lista de tipos de dados BSON e seus códigos numéricos correspondentes.

Por exemplo, estas verificações para o tipo Decimal128 são equivalentes:

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

Digite Verificando com um Construtor

Examine o objeto constructor para determinar o tipo. Por exemplo, a saída de db.collection.find() é um Cursor.

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