/ /

`$convert` Expresión (Stream Processing)

Definición

La expresión $convert convierte tipos de datos binarios. Esto se puede utilizar para convertir datos binarios en los encabezados de Kafka.

$convert

Una expresión $convert tiene las siguientes formas prototipo:

{
  input: "$binDataField",
  to: <int, long, double>,
  byteOrder: "little"|"big"
}
{
  input: "$intLongOrDoubleField",
  to: "binData",
  byteOrder: "little"|"big"
}
{
  input: "$binDataField",
  to: "string",
  format: <base64, base64url, hex, uuid, utf8>
}
{
  input: "$stringField",
  to: "binData",
  format: <base64, base64url, hex, uuid, utf8>
}

Sintaxis

El operador de agregación $convert convierte entre tipos de datos, excepto los tipos de datos binarios que se ofrecen en la versión de Atlas Stream Processing de la expresión $convert.

La expresión $convert acepta un documento con los siguientes campos:

Campo	Valor	Necesidad	Descripción
`input`	`binData`, `int`, `long`, `double`, y `string`	Requerido	Datos binarios que se convertirían en un tipo `int`, `long`, `double`, o `string`, o un tipo de datos `int`, `long`, `double`, o `string` que se convertiría en datos binarios.
`to`	`binData`, `int`, `long`, `double`, y `string`	Requerido	Especifica el tipo de datos al que se convierte `input`. Puedes especificar `int`, `long`, `double`, `string` o `binData`.
`byteOrder`	pequeño, grande	Opcional	Especifica el orden de bytes big-endian o little-endian de `binData` entrada y salida. Si no se especifica, el orden de los bytes es little-endian por defecto. `byteOrder` la opción especifica cómo interpretar la `binData` de entrada o salida, pero no controla el orden interno de bytes de los tipos numéricos. A menos que tengas un caso de uso específico para el orden de bytes little-endian, utiliza el orden de bytes big-endian.
`format`	auto, base64, base64url, hex, uuid, utf8	Condicional	Especifica el formato para la entrada y salida de `string`. Se requiere cuando `input` o `to` está `string`. Los valores válidos son: `auto` Para conversiones de `binData`a`string`, devuelve una string canónica de UUID para binData de subtipo UUID; en caso contrario, devuelve base64. `base64` `base64url` `hex` `uuid` `utf8` El método asistente `$toString` utiliza `format: "auto"` de forma predeterminada. Usa la expresión `$convert` con `format: "utf8"` para conversiones UTF-8.

Comportamiento

Si el valor de $convert.to es int, el valor binData input debe ser 1, 2 o 4. Si el valor de $convert.to es long, el valor de binData input debe ser 1, 2, 4 o 8. Si input tiene una longitud inesperada, se genera un error. Puede controlar este comportamiento configurando $convert.onError.

Al convertir a binData, un int se convierte en un 4de bytes binData, un long se convierte en un 8de bytes binData, y un double se convierte en un 8de bytes binData. Al convertir de binData a double, una entrada de 8bytes se interpreta como punto flotante de doble precisión IEEE 754, y una entrada de 4bytes se interpreta como punto flotante de precisión simple IEEE 754. Dado que MQL solo soporta punto flotante de doble precisión, realiza una conversión sin pérdidas del valor de punto flotante de simple precisión a doble precisión.

Convertiendo binData a tipos numéricos:

$convert.to	`int`	`long`	`double`
Anchos permitidos (en bytes)	1, 2, 4	1, 2, 4, 8	4, 8
`binData` se interpreta como	entero con signo en complemento a dos	entero con signo en complemento a dos	IEEE 754 punto flotante de precisión simple o doble

Conversión de tipos numéricos a binData:

Entrada	`int`	`long`	`double`
Ancho de salida (en bytes)	4	8	8

Ejemplos

en los siguientes ejemplos, describimos binData utilizando notación binaria como:

BinData(0b00000000 00000010)

El byte más a la izquierda (00000000) corresponde a la dirección de memoria más baja, o al índice 0del arreglo de bytes. De manera similar, utilizamos notación hexadecimal como la siguiente:

BinData(0x0100 000A)

El byte más a la izquierda (01) corresponde a la dirección de memoria más baja o al índice 0del arreglo de bytes.

Los documentos siguientes son expresiones de $convert de ejemplo que convierten valores entre las notaciones BinData, int, long y double:

{
  $convert: {
    input: BinData(0b00000000 00000010),
    to: “int”,
    byteOrder: “big” }
}

Resultado: 2

{
  $convert: {
    input: BinData(0b00000001 00000000),
    to: “int”,
    byteOrder: “big” }
}

Resultado: 256

{
  $convert: {
    input: BinData(0b00000001 00000000),
    to: “int”,
    byteOrder: “little” }
}

Resultado: 1

{
  $convert: {
    input: BinData(0x0001 0000),
    to: “int”,
    byteOrder: “big” }
}

Resultado: 65536

{
  $convert: {
    input: BinData(0x0001 0000 0000 0000),
    to: “long”,
    byteOrder: “big” }
}

Resultado: 281474976710656

{
  $convert: {
    input: BinData(0xFFFE7960),
    to: “int”,
    byteOrder: “big” }
}

Resultado: -100000

{
  $convert: {
    input: BinData(0x0001 0000 0000 0000),
    to: “int”,
    byteOrder: “big” }
}

Resultado: Error: la longitud de binData solo puede ser 1,2 o 4 bytes cuando to == "int".

{
  $convert: {
    input: BinData(0xC04C CCCD),
    to: “double”,
    byteOrder: “big” }
}

Resultado: -3.2000000476837158203125

{
  $convert: {
    input: BinData(0x0000),
    to: “double”,
    byteOrder: “big” }
}

Resultado: Error: la longitud de binData solo puede ser 4 o 8 bytes cuando to == “double”

{
  $convert: {
    input: NumberLong(42),
    to: “binData”,
    byteOrder: “big” }
}

Resultado: BinData(0x0000 0000 0000 002A) // subtipo 0

{
  $convert: {
    input: NumberLong(42),
    to: “binData”,
    byteOrder: “little” }
}

Resultado: BinData(0x2A00 0000 0000 0000) // sub-tipo 0

{
  $convert: {
    input: { $toInt: “$myNumericField” },
    to: “binData”,
    byteOrder: “little” }
}

Suponiendo que myNumericField sea un Int(42), un Long(42) o un Double(42.0)...

Resultado: BinData(0x2A00 0000)

{
  $convert: {
    input: “$myIntOrLongField”,
    to: “binData”,
    byteOrder: “little” }
}

Si la entrada es Int(42):

Resultado: BinData(0x2A00 0000)

Si la entrada es Long(42):

BinData(0x2A00 0000 0000 0000)

Volver

Aggregation Operators

$currentDate

$convert Expresión (Stream Processing)

Definición

Sintaxis

Comportamiento

Ejemplos

`$convert` Expresión (Stream Processing)