/ /

$convert (operador de expresión)

Definición

$convert: Convierte un valor a un tipo especificado.

Compatibilidad

Puedes usar $convert para implementaciones alojadas en los siguientes entornos:

MongoDB Atlas: El servicio totalmente gestionado para implementaciones de MongoDB en la nube

MongoDB Enterprise: La versión basada en suscripción y autogestionada de MongoDB
MongoDB Community: La versión de MongoDB con código fuente disponible, de uso gratuito y autogestionada.

Sintaxis

Cambiado en la versión 8.0.

{
   $convert:
      {
         input: <expression>,
         to: <type expression> || {
            type: <type expression>,
            subtype: <int>
         },
         format: <string>,
         onError: <expression>,
         onNull: <expression>
      }
}

El $convert procesa un documento con los siguientes campos:

Campo

Necesidad

Descripción

input

Requerido

El argumento puede ser cualquier expresión válida. Para más información sobre expresiones, consulte Expresiones.

A partir de MongoDB 8.1, puede establecer el campo to en binData si establece el campo input en uno de los siguientes tipos:

int
long
double

MongoDB también admite estos tipos numéricos como entrada al convertir un valor a binData.

to

Requerido

Especifica el tipo al que se convertirá la expresión input. Puede establecer to con uno de estos valores:

Un identificador de tipo de destino, ya sea de string o numérico. Consulte to.type.
Un objeto que contiene los campos to.type y to.subtype. Utilice este formato para convertir a binData y especificar un subtipo binData.

to.type

Obligatorio si se especifica to como objeto

El argumento puede ser cualquier expresión válida que se resuelva en uno de los siguientes identificadores numéricos o de cadena:

Identificador de cadena	Identificador numérico	notas
"double"	1	Para obtener más información sobre la conversión a doble, consulte Convertir a doble.
"string"	2	Para obtener más información sobre la conversión a cadena, consulte Convertir a cadena.
"binData"	5	Para obtener más información sobre la conversión a binData, consulte Convertir a BinData.
"objectId"	7	Para obtener más información sobre la conversión a objectId, consulte Convertir a ObjectId.
"bool"	8	Para obtener más información sobre la conversión a booleano, consulte Convertir a booleano.
"date"	9	Para obtener más información sobre la conversión a fecha, consulte Convertir a fecha.
"int"	16	Para obtener más información sobre la conversión a entero, consulte Convertir a entero.
"long"	18	Para obtener más información sobre la conversión a largo, consulte Convertir a largo.
"Decimal"	19	Para obtener más información sobre la conversión a decimal, consulte Convertir a decimal.

to.subtype

Opcional

Si to.type es binData, to.subtype especifica el subtipo binData al que se convertirá. Puede especificar uno de estos valores para to.subtype:

Número	Descripción
0	Subtipo binario genérico
1	Datos de funciones
2	Binario (antiguo)
3	UUID (antiguo)
4	UUID
5	MD5
6	Valor BSON cifrado
7	Datos de series de tiempo comprimidos Nuevo en la versión 5.2.
8	Datos sensibles, como una clave o un secreto. MongoDB no registra valores literales para datos binarios con subtipo 8. En cambio, MongoDB registra un valor de marcador de posición de `###`.
9	Datos vectoriales, que son arreglos densamente empaquetados de números del mismo tipo.
128	Datos personalizados

Predeterminado: 0 (subtipo binario genérico)

byteOrder

Opcional

Especifica el orden de bytes big-endian o little-endian para las conversiones entre binData y tipos numéricos. Si no se especifica, el orden de bytes predeterminado es little-endian.

format

Obligatorio al convertir hacia o desde binData y cadena

Especifica el formato de las conversiones entre binData y cadenas

base64
base64url
utf8
hex
uuid

Si format es uuid, to.subtype debe ser 4.

onError

Opcional

Valor que se devolverá si se detecta un error durante la conversión, incluidas las conversiones de tipos no compatibles. Los argumentos pueden ser cualquier expresión válida.

Si no se especifica, la operación genera un error al encontrar un error y se detiene.

onNull

Opcional

Valor que se devolverá si input es nulo o falta. Los argumentos pueden ser cualquier expresión válida.

Si no se especifica, $convert devuelve nulo si input está nulo o no está presente.

Además de, MongoDB proporciona los siguientes operadores de agregación como abreviatura cuando el comportamiento predeterminado "onError" y "onNull" es $convert aceptable:

Comportamiento

Las siguientes secciones describen cómo convertir valores a diferentes tipos.

Convertir a BinData

A partir de MongoDB 8.1, puede establecer el campo to en binData si establece el campo input en uno de los siguientes tipos:

int
long
double

A partir de MongoDB 8.1, $convert devuelve un error al intentar convertir entre diferentes subtipos de binData. En MongoDB 8.0, $convert devuelve el valor y el subtipo originales: no se realiza ninguna conversión. Las versiones de MongoDB anteriores a 8.0 no permiten la conversión de binData.

Convertir de tipos numéricos `binData` a:

Al convertir un tipo numérico a binData:

Un int se convierte en un 4byte binData.
Un long se convierte en un 8byte binData.
Un double se convierte en un 8byte binData.

El valor predeterminado del byteOrder en la salida numérica es "little", es decir, el byte menos significativo se coloca primero. Por el contrario, "big" coloca primero el byte más significativo.

Convertir long a binData:

db.t.insertOne({a: Long(42)})
db.t.aggregate([
    {
      $project: {
        convertedBD: {
          $convert: {
             input: Long(42),
             to: "binData",
        }
      },
    }
  }
])

{
  _id: ObjectId('67dda0195a99e592590143e8'),
  convertedBD: Binary.createFromBase64('KgAAAAAAAAA=', 0)
}

Convierte long a binData con ordenación de bytes big-endian:

db.t.insertOne({a: Long(42)})
db.t.aggregate([
    {
      $project: {
        convertedBD: {
          $convert: {
             input: Long(42),
             to: "binData",
             byteOrder: "big",
        }
      },
    }
  }
])

{
  _id: ObjectId('67ddb27c5a99e592590143ec'),
  convertedBD: Binary.createFromBase64('AAAAAAAAACo=', 0),
}

Convertir double a binData:

db.t.insertOne({a: Double(42.0)})
db.t.aggregate([
    {
      $project: {
        convertedBD: {
          $convert: {
             input: Double(42),
             to: "binData",
        }
      },
    }
  }
])

{
  _id: ObjectId('67ddb3cf5a99e592590143ee'),
  convertedBD: Binary.createFromBase64('AAAAAAAARUA=', 0)
}

Convertir int a binData:

db.t.insertOne({a: 42})
db.t.aggregate([
    {
      $project: {
        convertedBD: {
          $convert: {
             input: 42,
             to: "binData",
        }
      },
    }
  }
])

{
  _id: ObjectId('67ddb43a5a99e592590143ef'),
  convertedBD: Binary.createFromBase64('KgAAAA==', 0)
}

Convertir de cadena a BinData

MongoDB también admite conversiones entre binData y cadenas.

Los siguientes ejemplos demuestran cómo convertir cadenas a binData.

Ejemplo

Resultado

{
   input: "hn3uUsMxSE6S0cVkebjmfg==",
   to: {
      type: "binData",
      subtype: 0
   },
   format: "base64"
}

Binary.createFromBase64('hn3uUsMxSE6S0cVkebjmfg==', 0)

{
   input: "hn3uUsMxSE6S0cVkebjmfg==",
   to: "binData",
   format: "base64"
}

Binary.createFromBase64('hn3uUsMxSE6S0cVkebjmfg==', 0)

{
   input: "867dee52-c331-484e-92d1-c56479b8e67e",
   to: {
      type: "binData",
      subtype: 0
   },
   format: "base64"
}

Failed to parse BinData '867dee52-c331-484e-92d1-c56479b8e67e'
in $convert with no onError value: Input is not a valid base64
string.

{
   input: "hn3uUsMxSE6S0cVkebjmfg==",
   to: {
      type: "binData",
      subtype: 4
   },
   format: "base64"
}

Failed to parse BinData 'hn3uUsMxSE6S0cVkebjmfg==' in $convert
with no onError value: Input is not a valid base64 string.

{
   input: "867dee52-c331-484e-92d1-c56479b8e67e",
   to: {
      type: "binData",
      subtype: 4
   },
   format: "uuid"
}

UUID('867dee52-c331-484e-92d1-c56479b8e67e')

{
   input: "äöäöä",
   to: {
      type: "binData",
      subtype: 4
   },
   format: "uuid"
}

Failed to parse BinData 'äöäöä' in $convert with no onError
value: Input is not a valid UUID string.

{
   input: "867dee52-c331-484e-92d1-c56479b8e67e",
   to: { type: "binData" },
   format: "uuid"
}

Failed to parse BinData '867dee52-c331-484e-92d1-c56479b8e67e'
in $convert with no onError value: Only the UUID subtype (4)
is allowed with the 'uuid' format.

Nota

Convertir a booleano

La siguiente tabla enumera los tipos de entrada que se pueden convertir a un valor booleano:

Tipo de entrada	Comportamiento
Arreglo	Devuelve verdadero
Datos binarios	Devuelve verdadero
Booleano	No-op. Devuelve el valor booleano.
Código	Devuelve verdadero
fecha	Devuelve verdadero
Decimal	Returns true if not zero Return false if zero
Double	Returns true if not zero Return false if zero
entero	Returns true if not zero Return false if zero
JavaScript	Devuelve verdadero
Long	Returns true if not zero Return false if zero
MaxKey	Devuelve verdadero
MinKey	Devuelve verdadero
Nulo	Devuelve el valor especificado para la opción `onNull`. Por defecto, devuelve null.
Objeto	Devuelve verdadero
ObjectId	Devuelve verdadero
Expresión regular	Devuelve verdadero
String	Devuelve verdadero
Marca de tiempo	Devuelve verdadero

Para obtener más información sobre los tipos de datos en MongoDB, consulte Tipos BSON.

La siguiente tabla enumera algunos ejemplos de conversión a valores booleanos:

Ejemplo

Resultados

{ input: true, to: "bool" }

true

{ input: false, to: "bool" }

false

{ input: 1.99999, to: "bool" }

true

{ input: Decimal128( "5" ), to: "bool" }

true

{ input: Decimal128( "0" ), to: "bool" }

false

{ input: 100, to: "bool" }

true

{
   input: ISODate( "2018-03-26T04:38:28.044Z" ),
   to: "bool"
}

true

{ input: "hello", to: "bool" }

true

{ input: "false", to: "bool" }

true

{ input: "", to: "bool" }

true

{ input: null, to: "bool" }

nulo

Tip

$toBool

Convertir a entero

La siguiente tabla enumera los tipos de entrada que se pueden convertir a un número entero:

Tipo de entrada	Comportamiento
Booleano	Returns `0` for `false`. Returns `1` for `true`.
BinData	Devuelve el valor `binData` como un entero. `binData` se interpreta como un entero con signo, complemento a dos. La cantidad de bytes en el valor `binData` debe ser `1`, `2` o `4`. Si la longitud de `input` es inesperada, se genera un error. Puede controlar este comportamiento configurando `$convert.onError`.
Double	Retorna un valor truncado. El valor doble truncado debe estar dentro del valor mínimo y máximo de un entero. No se puede convertir un valor doble cuyo valor truncado sea menor que el valor entero mínimo o mayor que el valor entero máximo.
Decimal	Retorna un valor truncado. El valor decimal truncado debe estar dentro del valor mínimo y máximo de un número entero. No se puede convertir un valor decimal cuyo valor truncado sea menor que el valor entero mínimo o mayor que el valor entero máximo.
entero	No-op. Devuelve el valor entero.
Long	Devuelve el valor largo como un entero. El valor largo debe estar dentro del valor mínimo y máximo para un entero. No se puede convertir un valor largo que sea menor que el valor entero mínimo o mayor que el valor entero máximo.
String	Devuelve el valor numérico de la cadena como un entero. El valor de la cadena debe ser un ₁₀ entero base (por`"-5"` `"123456"`ejemplo,,) y estar dentro del valor mínimo y máximo para un entero. No se puede convertir un valor de cadena de un número flotante, decimal o no base (por ₁₀ `"-5.0"` `"0x6400"`ejemplo,,) o un valor que esté fuera del valor mínimo y máximo para un entero.

La siguiente tabla enumera algunos ejemplos de conversión a números enteros:

Ejemplo

Resultados

{ input: true, to: "int" }

{ input: false, to: "int" }

{ input: 1.99999, to: "int" }

{ input: Decimal128( "5.5000" ), to: "int" }

{
   input: Decimal128( "9223372036000.000" ),
   to: "int"
}

Error

{ input: Long( "5000" ), to: "int" }

5000

{ input: Long( "922337203600" ), to: "int" }

Error

{ input: "-2", to: "int" }

-2

{ input: "2.5", to: "int" }

Error

{ input: null, to: "int" }

nulo

{
   input: Binary(Buffer.from("00100000", "hex"), 0),
   to: "int",
   byteOrder: "big",
}

1048576

{
   input: Binary(Buffer.from("FFFFE796", "hex"), 0),
   to: "int",
}

-1763180545

{
   input: Binary(Buffer.from("001000000000000", "hex"), 0),
   to: "int",
   byteOrder: "big",
}

Error: No se pudo convertir BinData debido a una longitud no válida: 7

Tip

$toInt operador.

Convertir a decimal

La siguiente tabla enumera los tipos de entrada que se pueden convertir a decimal:

Tipo de entrada	Comportamiento
Booleano	Returns `Decimal128( "0" )` for `false`. Returns `Decimal128( "1" )` for `true`.
Double	Devuelve el valor doble como decimal.
Decimal	No-op. Devuelve el decimal.
entero	Devuelve el valor int como decimal.
Long	Devuelve el valor largo como decimal.
String	Devuelve el valor numérico de la cadena como decimal. El valor de la cadena debe ser un ₁₀ valor numérico base (por`"-5.5"` `"123456"`ejemplo,,). No se puede convertir un valor de cadena de un número que ₁₀ `"0x6400"` no sea base (por ejemplo,)
fecha	Devuelve el número de milisegundos desde la época que corresponde al valor de la fecha.

La siguiente tabla enumera algunos ejemplos de conversión a decimales:

Ejemplo

Resultados

{ input: true, to: "decimal" }

Decimal128("1")

{ input: false, to: "decimal" }

Decimal128("0")

{ input: 2.5, to: "decimal" }

Decimal128( "2.50000000000000" )

{ input: Int32( 5 ), to: "decimal" }

Decimal128("5")

{ input: Long( 10000 ), to: "decimal" }

Decimal128("10000")

{ input: "-5.5", to: "decimal" }

Decimal128("-5.5")

{
   input: ISODate( "2018-03-26T04:38:28.044Z" ),
   to: "decimal"
}

Decimal128("1522039108044")

Tip

$toDecimal

Convertir al doble

La siguiente tabla enumera los tipos de entrada que se pueden convertir a doble:

Tipo de entrada	Comportamiento
Booleano	Returns NumberDouble(0) for `false`. Returns NumberDouble(1) for `true`.
BinData	Devuelve el valor `binData` como un doble. `binData` se interpreta como un punto flotante de precisión simple o doble IEEE 754. El número de bytes en el valor `binData` debe ser `4` o `8`. Si la longitud de `input` es inesperada, se genera un error. Puede controlar este comportamiento configurando `$convert.onError`.
Double	No-op. Devuelve el doble.
Decimal	Devuelve el valor decimal como doble. El valor decimal debe estar dentro del valor mínimo y máximo para un doble. No se puede convertir un valor decimal cuyo valor sea menor que el valor doble mínimo o mayor que el valor doble máximo.
entero	Devuelve el valor int como doble.
Long	Devuelve el valor largo como doble.
String	Retorna el valor numérico de la string como un doble. El valor de cadena debe ser un valor numérico en base ₁₀ (ejemplo, `"-5.5"`, `"123456"`) y debe estar en el rango del valor mínimo al máximo para un double. No se puede convertir un valor de cadena de un número que ₁₀ `"0x6400"` no sea base (por ejemplo,) o un valor que esté fuera del valor mínimo y máximo para un doble.
fecha	Devuelve el número de milisegundos desde la época que corresponde al valor de la fecha.

La siguiente tabla enumera algunos ejemplos de conversión a doble:

Ejemplo

Resultados

{ input: true, to: "double" }

{ input: false, to: "double" }

{ input: 2.5, to: "double" }

2.5

{ input: Int32( 5 ), to: "double" }

{ input: Long( "10000" ), to: "double" }

10000

{ input: "-5.5", to: "double" }

-5.5

{ input: "5e10", to: "double" }

50000000000

{
   input: ISODate( "2018-03-26T04:38:28.044Z" ),
   to: "double"
}

1522039108044

{
   input: Binary(Buffer.from("04CCCCCD", "hex"), 0),
   to: "double",
   byteOrder: "big",
}

4.814824932714571e-36

{
   input: Binary(Buffer.from("0000", "hex"), 0),
   to: "double",
   byteOrder: "big",
}

Error: No se pudo convertir binData debido a una longitud no válida: 2

Tip

$toDouble

Convertir a largo

La siguiente tabla enumera los tipos de entrada que se pueden convertir a largo:

Tipo de entrada	Comportamiento
Booleano	Returns `0` for `false`. Returns `1` for `true`.
BinData	Devuelve el valor `binData` como un número largo. `binData` se interpreta como un entero con signo complementario a dos. El número de bytes en el valor `binData` debe ser `1`, `2`, `4` o `8`. Si la longitud de `input` es inesperada, se genera un error. Puede controlar este comportamiento configurando `$convert.onError`.
Double	Retorna un valor truncado. El valor doble truncado debe estar dentro del valor mínimo y máximo para un valor largo. No se puede convertir un valor doble cuyo valor truncado sea menor que el valor largo mínimo o mayor que el valor largo máximo.
Decimal	Retorna un valor truncado. El valor decimal truncado debe estar dentro del valor mínimo y máximo durante un largo. No se puede convertir un valor decimal cuyo valor truncado sea menor que el valor largo mínimo o mayor que el valor largo máximo.
entero	Devuelve el valor int como un largo.
Long	No opera. Devuelve el valor largo.
String	Devuelve el valor numérico de la cadena. El valor de la cadena debe tener una longitud base ₁₀ (por`"-5"` `"123456"`ejemplo,,) y estar dentro del valor mínimo y máximo de una cadena larga. No se puede convertir un valor de cadena de un número flotante, decimal o no base (por ₁₀ `"-5.0"` `"0x6400"`ejemplo,,) o un valor que esté fuera del valor mínimo y máximo para un largo.
fecha	Convierte la fecha en número de milisegundos desde la época.

La siguiente tabla enumera algunos ejemplos de conversión a largos:

Ejemplo

Resultados

{ input: true, to: "long" }

Largo("1")

{ input: false, to: "long"  }

Largo("0")

{ input: 2.5, to: "long"  }

Largo("2")

{ input: Decimal128( "5.5000" ), to: "long" }

Largo("5")

{
   input: Decimal128( "9223372036854775808.0" ),
   to: "long"
}

Error

{ input: Int32( 8 ), to: "long" }

Largo("8")

{
   input: ISODate( "2018-03-26T04:38:28.044Z" ),
   to: "long"
}

Long("1522039108044")

{ input: "-2", to: "long" }

Largo("-2")

{ input: "2.5", to: "long" }

Error

{ input: null, to: "long" }

nulo

{
   input: Binary(Buffer.from("001000000", "hex"), 0),
   to: "long",
   byteOrder: "big",
}

Largo("1048576")

Tip

$toLong

Convertir a fecha

La siguiente tabla enumera los tipos de entrada que se pueden convertir a una fecha:

Tipo de entrada	Comportamiento
Double	Devuelve una fecha que corresponde a la cantidad de milisegundos representados por el valor doble truncado. El número positivo corresponde al número de milisegundos desde el 1 de enero de 1970. El número negativo corresponde al número de milisegundos antes de enero 1, 1970.
Decimal	Devuelve una fecha que corresponde a la cantidad de milisegundos representados por el valor decimal truncado. El número positivo corresponde al número de milisegundos desde el 1 de enero de 1970. El número negativo corresponde al número de milisegundos antes de enero 1, 1970.
Long	Devuelve una fecha que corresponde a la cantidad de milisegundos representados por el valor largo. El número positivo corresponde al número de milisegundos desde el 1 de enero de 1970. El número negativo corresponde al número de milisegundos antes de enero 1, 1970.
String	Devuelve una fecha que corresponde a la string de fecha. La cadena debe ser una cadena de fecha válida, como por ejemplo: "2018-03-03" "2018-03-03T12:00:00Z" "2018-03-03T12:00:00+0500"
ObjectId	Devuelve una fecha que corresponde a la marca de tiempo del ObjectId.
Marca de tiempo	Devuelve una fecha que corresponde a la marca de tiempo.

La siguiente tabla enumera algunos ejemplos de conversión a fecha:

Ejemplo

Resultados

{
   input: 120000000000.5,
   to: "date"
}

FechaISO("1973-10-20T21:20:00.000Z")

{
   input: Decimal128( "1253372036000.50" ),
   to: "date"
}

FechaISO("2009-09-19T14:53:56.000Z")

{
   input: Long( "1100000000000" ),
   to: "date
}

FechaISO("2004-11-09T11:33:20.000Z")

{
   input:  Long( "-1100000000000" ),
   to: "date"
}

FechaISO("1935-02-22T12:26:40.000Z")

{
   input: ObjectId( "5ab9c3da31c2ab715d421285" ),
   to: "date"
}

FechaISO("2018-03-27T04:08:58.000Z")

{ input:  "2018-03-03", to: "date" }

ISODate("2018-03-03T00:00:00.000Z")

{
   input: "2018-03-20 11:00:06 +0500",
   to: "date"
}

FechaISO("2018-03-20T06:00:06.000Z")

{ input: "Friday", to: "date" }

Error

{
   input: Timestamp( { t: 1637688118, i: 1 } ),
   to: "date"
}

FechaISO("2021-11-23T17:21:58.000Z")

Tip

$toDate operador
$dateFromString

Convertir a ObjectId

La siguiente tabla enumera los tipos de entrada que se pueden convertir a un ObjectId:

Tipo de entrada	Comportamiento
String	Devuelve un ObjectId para la string hexadecimal de 24 caracteres. No se puede convertir un valor de cadena que no sea una cadena hexadecimal de longitud 24.

La siguiente tabla enumera algunos ejemplos de conversión a fecha:

Ejemplo

Resultados

{
   input: "5ab9cbfa31c2ab715d42129e",
   to: "objectId"
}

ObjectId("5ab9cbfa31c2ab715d42129e")

{
   input: "5ab9cbfa31c2ab715d42129",
   to: "objectId"
}

Error

Tip

$toObjectId operador.

Convertir a cadena

La siguiente tabla enumera los tipos de entrada que se pueden convertir en una cadena:

Tipo de entrada	Comportamiento
BinData	Devuelve el valor de datos binarios como una cadena.
Booleano	Devuelve el valor booleano como una cadena.
Double	Devuelve el valor doble como una cadena.
Decimal	Devuelve el valor decimal como una cadena.
entero	Devuelve el valor entero como una cadena.
Long	Devuelve el valor largo como una cadena.
ObjectId	Devuelve el valor de ObjectId como una cadena hexadecimal.
String	No-op. Devuelve el valor de la cadena.
fecha	Devuelve la fecha como una cadena.

La siguiente tabla enumera algunos ejemplos de conversión a string:

Ejemplo

Resultados

{ input: true, to: "string" }

"true"

{ input: false, to: "string" }

"FALSO"

{ input: 2.5, to: "string" }

"2.5"

{ input: Int32( 2 ), to: "string" }

"2"

{ input:  Long( 1000 ), to: "string" }

"1000"

{
   input: ObjectId( "5ab9c3da31c2ab715d421285" ),
   to: "string"
}

"5ab9c3da31c2ab715d421285"

{
   input:  ISODate( "2018-03-27T16:58:51.538Z" ),
   to: "string"
}

"2018-03-27T16:58:51.538Z"

{
   input: BinData(4, "hn3f"),
   to: "string",
   format: "base64"
}

'hn3f'

Tip

$toString operador
$dateToString

Ejemplo

Cree una colección orders con los siguientes documentos:

db.orders.insertMany( [
   { _id: 1, item: "apple", qty: 5, price: 10 },
   { _id: 2, item: "pie", qty: 10, price: Decimal128("20.0") },
   { _id: 3, item: "ice cream", qty: 2, price: "4.99" },
   { _id: 4, item: "almonds" },
   { _id: 5, item: "bananas", qty: 5000000000, price: Decimal128("1.25") }
] )

La siguiente operación de agregación en la colección orders convierte el price en decimal:

// Define stage to add convertedPrice and convertedQty fields with
//    the converted price and qty values.
// If price or qty values are missing, the conversion returns a
//    value of decimal value or int value of 0.
// If price or qty values cannot be converted, the conversion returns
//    a string
priceQtyConversionStage = {
   $addFields: {
      convertedPrice: { $convert:
         {
            input: "$price",
            to: "decimal",
            onError: "Error",
            onNull: Decimal128("0")
         } },
      convertedQty: { $convert:
         {
            input: "$qty",
            to: "int",
            onError:{ $concat:
               [
                  "Could not convert ",
                  { $toString:"$qty" },
                  " to type integer."
               ]
            },
         onNull: Int32("0")
      } },
   }
};
totalPriceCalculationStage = {
   $project: { totalPrice: {
     $switch: {
        branches: [
          { case:
             { $eq: [ { $type: "$convertedPrice" }, "string" ] },
             then: "NaN"
          },
          { case:
             { $eq: [ { $type: "$convertedQty" }, "string" ] },
             then: "NaN"
          },
        ],
        default: { $multiply: [ "$convertedPrice", "$convertedQty" ] }
     }
} } };
db.orders.aggregate( [
   priceQtyConversionStage,
   totalPriceCalculationStage
])

La operación devuelve los siguientes documentos:

{ _id: 1, totalPrice: Decimal128("50") },
{ _id: 2, totalPrice: Decimal128("200.0") },
{ _id: 3, totalPrice: Decimal128("9.98") },
{ _id: 4, totalPrice: Decimal128("0") },
{ _id: 5, totalPrice: 'NaN' }

Nota

Estos ejemplos utilizan. Los tipos mongosh mongo predeterminados son diferentes en el shell heredado.

Volver

$cond

$cos

Definición

Compatibilidad

Sintaxis

Comportamiento

Convertir a BinData

Convertir de tipos numéricos binData a:

Convertir de cadena a BinData

Nota

Convertir a booleano

Tip

Convertir a entero

Tip

Convertir a decimal

Tip

Convertir al doble

Tip

Convertir a largo

Tip

Convertir a fecha

Tip

Convertir a ObjectId

Tip

Convertir a cadena

Tip

Ejemplo

Nota

Convertir de tipos numéricos `binData` a: