Tipos de datos

Igualdad y orden de clasificación

Los valores del tipo Decimal128 se comparan y ordenan con otros tipos numéricos según su valor numérico real. Los valores numéricos del tipo Double basado en binario generalmente tienen representaciones aproximadas de valores basados en decimales y pueden no ser exactamente iguales a sus representaciones decimales.

Fecha de devolución como string

Para devolver la fecha como un string, utilice el método Date(), como en el siguiente ejemplo:

var myDateString = Date();

Para imprimir el valor de la variable, escriba el nombre de la variable en el Shell, como en el siguiente ejemplo:

myDateString

El resultado es el valor de myDateString:

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

Para verificar el tipo, utilice el operador typeof, como en el siguiente ejemplo:

typeof myDateString

La operación devuelve string.

Fecha de devolución

mongosh envuelve objetos de tipo Date con el asistente ISODate; sin embargo, los objetos siguen siendo del tipo Date.

El siguiente ejemplo utiliza tanto el constructor new Date() como el constructor ISODate() para devolver objetos Date.

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

También puede usar el operador new con el constructor ISODate().

Para imprimir el valor de la variable, escriba el nombre de la variable en el Shell, como en el siguiente ejemplo:

myDate

El resultado es el valor Date de myDate envuelto en el asistente ISODate():

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

Para verificar el tipo:

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

La operación devuelve true.

Tipos numéricos

Considere la colección 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 tabla muestra los resultados del comando db.types.find( <QUERY> ) para el <QUERY> correspondiente. Los nombres de tipo y alias se proporcionan en la página de BSON types.

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

La query { "value": 1.01 } busca implícitamente la representación Double de 1.01. El documento _id: 4 es un Decimal128, por lo tanto, no se selecciona.

Sin embargo, tenga en cuenta que { "value": 1 } devuelve tanto tipos Int32 como Long.

Coherencia de tipos numéricos por defecto

Considere la colección typeExample. Esta colección consta de dos documentos idénticos, { "a": 1 }. El primer documento fue creado en el shell mongo heredado, y el segundo documento fue creado en mongosh.

Podemos utilizar el operador $type en un pipeline de agregación para ver el tipo que se asignó en cada shell.

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

En el primer documento, creado en el shell mongo heredado, el valor se almacenó como double. En el documento mongosh, el valor se almacenó como tipo int.

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

Añadir una marca de tiempo a un nuevo documento

Utiliza Timestamp() sin parámetros para insertar varios documentos usando la configuración por defecto:

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

Ejecuta db.flights.find({}) para ver las marcas de tiempo. Observa que, aunque las tres entradas fueron selladas en el mismo segundo, el intervalo se incrementó en cada una.

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

Cree una marca de tiempo personalizada

Utiliza parámetros personalizados para insertar múltiples documentos con un Timestamp específico.

Esta operación inserta tres documentos en la colección flights y utiliza el valor de UNIX epoch 1627811580 para establecer los tiempos ts a las 9:53 GMT el 1 de agosto de 2021.

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

Los documentos resultantes se ven así:

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

Comprobación de tipos con $type()

El operador del query $type acepta un alias de string o un código numérico correspondiente al tipo de dato. Consulte BSON Types para obtener una lista de tipos de datos BSON y sus códigos numéricos correspondientes.

Por ejemplo, estas verificaciones para el tipo Decimal128 son equivalentes:

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

Comprobación de tipos con un constructor

Examine el objeto constructor para determinar su tipo. Por ejemplo, la salida de db.collection.find() es un Cursor.

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