Menu Docs
Página inicial do Docs
/
MongoDB Atlas
/
Atlas Stream Processing
/
expressão de agregação

$convert

Nesta página

  • Definição
  • Sintaxe
  • Comportamento
  • Exemplos

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
Obrigatório

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.

Observação

byteOrder a opção especifica como interpretar a entrada ou saída binData, mas não controla a ordem de bytes interna dos tipos numéricos. O MongoDB sugere que você use a ordem big endian, que é a ordem padrão para conversões numéricas para bytes no ecossistema Kafka, Java e Python.

format
base64, base64url, hex, uuid, utf8
Obrigatório

Especifica um argumento de formato de nível superior de string entrada e saída.

Observação

O método assistente $toString não interpreta binData como dados utf-8 por padrão. O padrão é base64. Você deve usar a expressão $convert 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: 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” }
}

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

expressão de agregação

Próximo

Aggregation Pipelines