/ /

Aggregation Operators

Docs Home

Desarrollo

Atlas Stream Processing

Aggregation Operators

Docs Home

Desarrollo

Atlas Stream Processing

Aggregation Operators

`$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

La $convert el operador de agregación convierte entre tipos de datos excepto por 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`	base64, base64url, hex, uuid, utf8	Requerido	Especifica un argumento de formato de nivel superior de entrada y salida de `string`. Por defecto, el método asistente `$toString` no interpreta `binData` como datos utf-8. Por defecto se establece en `base64`. Debe usar la expresión $convert para las conversiones de 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(a) int se convierte en un(a) binData de 4bytes, un(a) long se convierte en un(a) binData de 8bytes, y un(a) double se convierte en un(a) binData de 8bytes. Cuando se convierte de binData a double, una entrada de 8bytes se interpreta como un número de punto flotante de doble precisión IEEE 754, y una entrada de 4bytes se interpreta como un número de punto flotante de precisión simple IEEE 754. Desde MQL solo admite aritmética de punto flotante de doble precisión, y realiza una conversión sin pérdida de valores de punto flotante de precisión simple a precisión doble.

Convertiendo binData a tipos numéricos:

$convertir.a	`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 de 4 o 8 bytes cuando == “double”.

{
  $convert: {
    input: true,
    to: “binData” }
}

Resultado: BinData(0x01) // subtipo 0

{
  $convert: {
    input: false,
    to: “binData” }
}

Resultado: BinData(0x00) // subtipo 0

{
  $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) // subtipo 0

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

Suponiendo que myNumericField es un Int(42), Long(42) o 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):

Datos binarios (0x2A00 0000 0000 0000)

Volver

Aggregation Operators

$currentDate