As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Visão geral do tipo de dados do JSON

ElastiCache suporta vários comandos Valkey e Redis OSS para trabalhar com o tipo de dados JSON. Veja a seguir uma visão geral do tipo de dados do JSON e uma lista detalhada dos comandos que são compatíveis.

Terminologia

Padrão compatível com JSON

O formato JSON é compatível com os padrão de intercâmbio de dados do JSON RFC 7159 e ECMA-404. O padrão UTF-8 Unicode é compatível com texto do JSON.

Elemento raiz

O elemento raiz pode ser de qualquer tipo de dados do JSON. Observe que na RFC 4627 anterior, somente objetos ou matrizes eram permitidos como valores raiz. Desde a atualização para o RFC 7159, a raiz de um documento JSON pode ser de qualquer tipo de dados do JSON.

Limite de tamanho de documentos

Os documentos JSON são armazenados internamente em um formato que é otimizado para rápido acesso e modificação. Esse formato normalmente resulta no consumo um pouco maior de memória do que a representação serializada equivalente do mesmo documento.

O consumo de memória por um único documento JSON é limitado a 64 MB, que é o tamanho da estrutura de dados na memória, não a string JSON. É possível verificar a quantidade de memória consumida por um documento JSON usando o comando JSON.DEBUG MEMORY.

JSON ACLs

Limite de profundidade de aninhamento

Quando um objeto ou matriz JSON tem um elemento que é outro objeto ou matriz JSON, diz-se que esse objeto interno ou matriz se “aninha” dentro do objeto ou matriz externa. O limite máximo de profundidade de aninhamento é 128. Qualquer tentativa de criar um documento que contenha uma profundidade de aninhamento maior que 128 será rejeitada com um erro.

Sintaxe de comando

A maioria dos comandos exige um nome de chave como primeiro argumento. Alguns comandos também têm um argumento path (caminho). O argumento path (caminho) será padronizado para a raiz se for opcional e não fornecido.

Notação:

Sintaxe de caminho

O JSON do Redis oferece suporte a dois tipos de sintaxes de path:

Se um caminho de consulta começar com '$', ele usará a sintaxe aprimorada. Caso contrário, a sintaxe restrita será usada.

Sintaxe aprimorada

Exemplos

Os exemplos a seguir têm como base o exemplo de dados XML de Goessner, que modificamos acrescentando campos adicionais.

{ "store": {
    "book": [ 
      { "category": "reference",
        "author": "Nigel Rees",
        "title": "Sayings of the Century",
        "price": 8.95,
        "in-stock": true,
        "sold": true
      },
      { "category": "fiction",
        "author": "Evelyn Waugh",
        "title": "Sword of Honour",
        "price": 12.99,
        "in-stock": false,
        "sold": true
      },
      { "category": "fiction",
        "author": "Herman Melville",
        "title": "Moby Dick",
        "isbn": "0-553-21311-3",
        "price": 8.99,
        "in-stock": true,
        "sold": false
      },
      { "category": "fiction",
        "author": "J. R. R. Tolkien",
        "title": "The Lord of the Rings",
        "isbn": "0-395-19395-8",
        "price": 22.99,
        "in-stock": false,
        "sold": false
      }
    ],
    "bicycle": {
      "color": "red",
      "price": 19.95,
      "in-stock": true,
      "sold": false
    }
  }
}

Exemplos adicionais de expressões de filtro:

127.0.0.1:6379> JSON.SET k1 . '{"books": [{"price":5,"sold":true,"in-stock":true,"title":"foo"}, {"price":15,"sold":false,"title":"abc"}]}'
OK
127.0.0.1:6379> JSON.GET k1 $.books[?(@.price>1&&@.price<20&&@.in-stock)]
"[{\"price\":5,\"sold\":true,\"in-stock\":true,\"title\":\"foo\"}]"
127.0.0.1:6379> JSON.GET k1 '$.books[?(@.price>1 && @.price<20 && @.in-stock)]'
"[{\"price\":5,\"sold\":true,\"in-stock\":true,\"title\":\"foo\"}]"
127.0.0.1:6379> JSON.GET k1 '$.books[?((@.price>1 && @.price<20) && (@.sold==false))]'
"[{\"price\":15,\"sold\":false,\"title\":\"abc\"}]"
127.0.0.1:6379> JSON.GET k1 '$.books[?(@.title == "abc")]'
[{"price":15,"sold":false,"title":"abc"}]

127.0.0.1:6379> JSON.SET k2 . '[1,2,3,4,5]'
127.0.0.1:6379> JSON.GET k2 $.*.[?(@>2)]
"[3,4,5]"
127.0.0.1:6379> JSON.GET k2 '$.*.[?(@ > 2)]'
"[3,4,5]"

127.0.0.1:6379> JSON.SET k3 . '[true,false,true,false,null,1,2,3,4]'
OK
127.0.0.1:6379> JSON.GET k3 $.*.[?(@==true)]
"[true,true]"
127.0.0.1:6379> JSON.GET k3 '$.*.[?(@ == true)]'
"[true,true]"
127.0.0.1:6379> JSON.GET k3 $.*.[?(@>1)]
"[2,3,4]"
127.0.0.1:6379> JSON.GET k3 '$.*.[?(@ > 1)]'
"[2,3,4]"

Sintaxe restrita

Exemplos

Prefixos de erro comuns

Cada mensagem de erro tem um prefixo. Veja a seguir uma lista de prefixos de erro comuns.

Métricas relacionadas ao JSON

As seguintes métricas de informações JSON são fornecidas:

Para consultar as métricas principais, execute o seguinte comando:

info json_core_metrics

Como, ElastiCache para Valkey e Redis, o OSS interage com o JSON

A seção a seguir descreve como, ElastiCache para Valkey e Redis, o OSS interage com o tipo de dados JSON.

Precedência do operador

Ao avaliar expressões condicionais para filtragem, &&s têm precedência primeiro e, em seguida, ||s são avaliadas, como é comum na maioria das linguagens. As operações dentro de parênteses são executadas primeiro.

Comportamento do limite máximo de aninhamento de caminho

O limite máximo de aninhamento de caminhos no ElastiCache Redis OSS é 128. Por isso, um valor como $.a.b.c.d... só pode atingir 128 níveis.

Processamento de valores numéricos

O JSON não tem tipos de dados separados para números inteiros e de ponto flutuante. Todos eles são chamados de números.

Representações numéricas:

Quando um número JSON é recebido na entrada, ele é convertido em uma das duas representações binárias internas: um valor inteiro com sinal de 64 bits ou um ponto flutuante de fluxo de precisão dupla de IEEE de 64 bits. A string original e toda a sua formatação não serão retidas. Dessa forma, quando um número é gerado como parte de uma resposta JSON, ele é convertido da representação binária interna para uma string imprimível que usa regras genéricas de formatação. Essas regras podem resultar em uma string diferente da que foi recebida.

Comandos aritméticos NUMINCRBY e NUMMULTBY:

Para obter uma lista detalhada dos comandos disponíveis, consulte Comandos compatíveis do Valkey e do Redis OSS.

Filtragem direta de matriz

ElastiCache para Valkey ou Redis, o OSS filtra objetos de matriz diretamente.

Para dados como [0,1,2,3,4,5,6] e uma consulta de caminho$[?(@<4)], ou dados como {"my_key":[0,1,2,3,4,5,6]} e uma consulta de caminho como$.my_key[?(@<4)], ElastiCache retornaria [1,2,3] em ambas as circunstâncias.

Comportamento de indexação de matriz

ElastiCache para Valkey ou Redis, o OSS permite índices positivos e negativos para matrizes. Para uma matriz de comprimento cinco, 0 consultaria o primeiro elemento, 1 o segundo, e assim por diante. Números negativos começam no fim da matriz, então -1 consultaria o quinto elemento, -2 o quarto elemento e assim por diante.

Para garantir um comportamento previsível para os clientes, ElastiCache não arredonda os índices de matriz para baixo ou para cima. Portanto, se você tiver uma matriz com um comprimento de 5, chamar o índice 5 ou superior, ou -6 ou inferior, não produziria um resultado.

Avaliação estrita da sintaxe

MemoryDB não permite caminhos JSON com sintaxe inválida, mesmo que um subconjunto do caminho contenha um caminho válido. Isso acontece para manter o comportamento correto para nossos clientes.