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 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 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 int, long, double ou string dados de tipo que seriam convertidos a dados binários.
to
binData, int, long, double e string
Obrigatório
Especifica o tipo de dados para o qual o input é convertido. Você pode especificar para int, long, double, string ou binData.
byteOrder
pequeno, grande
Obrigatório

Especifica a ordem de bytes endian big ou little de binData entrada e saída. Se não for especificado, o padrão é ordenação de bytes little endian.

Observação

byteOrder opção especifica como interpretar binData de entrada ou saída , mas não controla a ordem de bytes interna de 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 linguagens 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 deverá ser 1, 2 ou 4. Se o valor de $convert.to for long, o valor binData input deverá 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 4-byte binData, um long se torna um 8-byte binData e um double se torna um 8-byte binData. Ao converter de binData para double, uma entrada 8bytes é interpretada como IEEE 754 ponto flutuante de precisão dupla e uma entrada 4bytes é interpretada como IEEE 754 flutuação de precisão única ponto. Como o MQL suporta apenas o ponto flutuante de precisão dupla, ele realiza a conversão sem perdas do valor de ponto flutuante de precisão única para a precisão dupla.

Convertendo binData para tipos numéricos:

$convert.to
int
long
double
Larguras permitidas (em bytes)
1, 2, 4
1, 2, 4, 8
4, 8
binData é interpretado como
número inteiro com sinal de complemento de dois
número inteiro com sinal de complemento de dois
ponto flutuante de precisão única ou precisão dupla IEEE 754

Convertendo 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 da 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 índice 0da 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 do binData só pode ser 4 ou 8 bytes quando == “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 um Int(42), Long(42) ou Duplo(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 Longo(42:

BinData(0x2A00 0000 0000 0000)

Voltar

expressão de agregação

Próximo

Aggregation Pipelines