/ /

`$convert` Expressão (processamento de fluxos)

Definição

A expressão $convert converte tipos de dados binários. Isso pode ser usado para converter dados binários em cabeçalhos do Kafka.

$convert

Uma expressão $convert tem as seguintes formas de protótipo:

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

Sintaxe

O operador de agregação $convert converte entre tipos de dados, exceto para os tipos de dados binários oferecidos na versão do Atlas Stream Processing da expressão $convert.

A expressão $convert recebe um documento com os seguintes campos:

Campo	Valor	necessidade	Descrição
`input`	`binData`, `int`, `long`, `double` e `string`	Obrigatório	Dados binários que seriam convertidos em um tipo `int`, `long`, `double` ou `string`, ou um tipo de dados `int`, `long`, `double` ou `string` que seriam convertidos em dados binários.
`to`	`binData`, `int`, `long`, `double` e `string`	Obrigatório	Especifica o tipo de dados para o qual `input` é convertido. Você pode especificar como `int`, `long`, `double`, `string` ou `binData`.
`byteOrder`	little, big	Opcional	Especifica a ordenação de bytes no formato big-endian ou little-endian para entrada e saída de `binData`. Se não for especificado, o padrão é a ordenação de bytes little-endian. `byteOrder` especifica como interpretar a entrada ou saída `binData`, mas não controla a ordem de bytes interna dos tipos numéricos. A menos que você tenha um caso de uso específico para a ordem de bytes little-endian, use a ordem de bytes big-endian.
`format`	auto, base64, base64url, hex, uuid, utf8	Condicional	Especifica o formato para entrada e saída do `string`. Obrigatório quando `input` ou `to` é `string`. Os valores válidos são: `auto` : para conversões de `binData`para`string`, retorna uma string canônica UUID para subtipo binData UUID, caso contrário retorna base64. `base64` `base64url` `hex` `uuid` `utf8` O método assistente `$toString` utiliza `format: "auto"` por padrão. Use a expressão `$convert` com `format: "utf8"` para conversões UTF-8.

Comportamento

Se o valor de $convert.to for int, o valor binData input deve ser 1, 2 ou 4. Se o valor de $convert.to for long, o valor binData input deve ser 1, 2, 4 ou 8. Se o input tiver um comprimento inesperado, um erro será gerado. Você pode controlar esse comportamento configurando $convert.onError.

Ao converter para binData, um int se torna um binDatade 4-bytes, um long se torna um binDatade 8-bytes e um double se torna um binDatade 8-bytes. Ao fazer a conversão de binData para double, uma entrada 8-bytes é interpretada como ponto flutuante de precisão duplicada IEEE 754 e uma entrada de 4-bytes é interpretada como ponto flutuante de precisão única IEEE 754. Como o MQL suporta apenas ponto flutuante de precisão dupla, ele realiza uma conversão sem perdas do valor do ponto flutuante de precisão única em precisão dupla.

Convertendo binData em tipos numéricos:

$convert.to	`int`	`long`	`double`
Larguras permitidas (em bytes)	1, 2, 4	1, 2, 4, 8	4, 8
`binData` é interpretado como	complemento de dois inteiro assinado	complemento de dois inteiro assinado	IEEE 754 ponto flutuante de precisão simples ou dupla

Convertindo tipos numéricos em binData:

Entrada	`int`	`long`	`double`
Largura de saída (em bytes)	4	8	8

Exemplos

Nos exemplos a seguir, descrevemos binData usando notação binária, como:

BinData(0b00000000 00000010)

O byte mais à esquerda (00000000) corresponde ao endereço de memória mais baixo ou ao 0-ésimo índice do array de bytes. Da mesma forma, usamos notação hexadecimal como:

BinData(0x0100 000A)

O byte mais à esquerda (01) corresponde ao endereço de memória mais baixo ou ao 0º índice do array de bytes.

Os documentos a seguir são exemplo de expressões $convert que convertem valores nas notações BinData, int, long e 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: erro – o comprimento do binData só pode ser 1,2 ou 4 bytes quando to == "int".

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

Resultado: -3.2000000476837158203125

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

Resultado: erro – o comprimento de binData só pode ser 4 ou 8 bytes quando 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) // subtipo 0

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

Supondo que myNumericField seja Int (42), Long (42) ou Double (42.0)...

Resultado: BinData(0x2A00 0000)

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

Se a entrada for Int(42):

Resultado: BinData(0x2A00 0000)

Se a entrada for Long(42):

BinData(0x2A00 0000 0000 0000)

Voltar

Operadores de agregação

$currentDate

$convert Expressão (processamento de fluxos)

Definição

Sintaxe

Comportamento

Exemplos

`$convert` Expressão (processamento de fluxos)