Manipulando Hashes no Redis
Tags: redis, programming, braziliandevs, tutorial
Published: 2023-02-16 07:55:48

## Introdução

Os hashes são usados para armazenar pares de chave-valor, em que cada chave é exclusiva dentro do hash. Existem vários comandos disponíveis para manipulação de hashes no Redis.

## Comandos:

1. `HSET`: este comando é usado para definir um valor para uma chave dentro de um hash. Se a chave já existir no hash, o valor antigo será substituído pelo novo valor. Por exemplo, para definir um valor "João" para a chave "nome" no hash "cliente", você pode usar o comando:
    
    ```bash
    HSET cliente nome João
    ```
    
2. `HGET`: este comando é usado para recuperar o valor de uma chave dentro de um hash. Por exemplo, para obter o valor da chave "nome" no hash "cliente", você pode usar o comando:
    
    ```bash
    HGET cliente nome
    ```
    
3. `HGETALL`: este comando é usado para recuperar todos os pares de chave-valor dentro de um hash. Por exemplo, para obter todos os pares de chave-valor do hash "cliente", você pode usar o comando:
    
    ```bash
    HGETALL cliente
    ```
    
4. `HDEL`: este comando é usado para excluir uma chave dentro de um hash. Por exemplo, para excluir a chave "nome" do hash "cliente", você pode usar o comando:
    
    ```bash
    HDEL cliente nome
    ```
    
5. `HEXISTS`: este comando é usado para verificar se uma chave existe dentro de um hash. Por exemplo, para verificar se a chave "nome" existe no hash "cliente", você pode usar o comando:
    
    ```bash
    HEXISTS cliente nome
    ```
    
6. `HINCRBY`: este comando é usado para incrementar um valor numérico dentro de um hash. Por exemplo, para incrementar o valor da chave "idade" no hash "cliente" em 1, você pode usar o comando:
    
    ```bash
    HINCRBY cliente idade 1
    ```
    
7. `HMSET`: este comando é usado para definir vários pares de chave-valor dentro de um hash. Por exemplo, para definir os pares de chave-valor "nome=João" e "idade=30" no hash "cliente", você pode usar o comando:
    
    ```bash
    HMSET cliente nome João idade 30
    ```
    
8. `HKEYS`: este comando é usado para retornar todas as chaves dentro de um hash. Por exemplo, se você tem um hash chamado "produto" que armazena informações sobre um determinado produto, você pode usar o comando HKEYS para listar todas as chaves desse hash:
    
    ```bash
    HSET produto nome "iPhone"
    HSET produto preco 1000
    HSET produto fabricante "Apple"
    HKEYS produto
    
    Output:
    1) "nome"
    2) "preco"
    3) "fabricante"
    ```
    
9. `HVALS`: este comando é usado para retornar todos os valores dentro de um hash. Por exemplo, usando o mesmo hash "produto" do exemplo anterior, você pode usar o comando HVALS para listar todos os valores desse hash:
    
    ```bash
    HVALS produto
    
    Output:
    1) "iPhone"
    2) "1000"
    3) "Apple"
    ```
    
10. `HMGET`: este comando é usado para recuperar os valores de várias chaves dentro de um hash. Por exemplo, se você quiser obter os valores das chaves "nome" e "preco" do hash "produto", você pode usar o comando HMGET:
    
    ```bash
    HMGET produto nome preco
    
    Output:
    1) "iPhone"
    2) "1000"
    ```
    
11. `HLEN`: este comando é usado para retornar o número de campos (pares chave-valor) dentro de um hash. Por exemplo, para obter o número de campos do hash "produto", você pode usar o comando HLEN:
    
    ```bash
    HLEN produto
    
    Output:
    (integer) 3
    ```
    
12. `HSETNX`: este comando é usado para definir o valor de uma chave dentro de um hash somente se a chave não existir. Por exemplo, se você quiser definir o valor da chave "estoque" no hash "produto" como 50 somente se a chave "estoque" não existir, você pode usar o comando HSETNX:
    
    ```bash
    HSETNX produto estoque 50
    
    Output:
    (integer) 1
    ```
    
    Se a chave "estoque" já existir, o comando não terá efeito.
    
13. `HSTRLEN`: este comando é usado para obter o comprimento do valor de uma chave dentro de um hash. Por exemplo, para obter o comprimento do valor da chave "fabricante" no hash "produto", você pode usar o comando HSTRLEN:
    
    ```bash
    HSTRLEN produto fabricante
    
    Output:
    (integer) 5
    ```
    
14. `HSCAN`: é usado para iterar sobre todos os campos de um hash, retornando apenas um subconjunto de campos em cada chamada. Isso pode ser útil quando você precisa trabalhar com hashes muito grandes e deseja reduzir o impacto no desempenho do Redis.
    
    ```bash
    HSET produto nome "iPhone"
    HSET produto preco 1000
    HSET produto fabricante "Apple"
    HSET produto estoque 50
    
    HSCAN produto 0 COUNT 10
    
    Output:
    1) "0"
    2) 1) "nome"
       2) "iPhone"
       3) "preco"
       4) "1000"
       5) "fabricante"
       6) "Apple"
       7) "estoque"
       8) "50"
    ```
    
    O resultado é uma matriz com duas partes: a primeira parte é o próximo índice a ser usado na próxima chamada do comando HSCAN, e a segunda parte é uma lista de pares chave-valor, representando os campos que foram retornados.
    
    Observe que, se você precisar iterar sobre todos os campos de um hash, precisará continuar chamando o comando HSCAN até que ele retorne o índice 0 novamente, o que indica o fim do hash. Além disso, você pode usar o valor COUNT para ajustar a quantidade de dados retornados em cada chamada, com o objetivo de equilibrar o desempenho e a latência da sua aplicação.
    
    ## Os benefícios do hashes sobre strings com a modelagem adequada.
    
    1. No lado do desempenho, a maioria dos comandos para strings e hash tem a mesma complexidade.
    2. Acessar/atualizar/excluir campos json individuais em hashes é mais fácil quando comparado às strings. Você não precisa obter toda a string, decodificar, fazer alterações e configurá-la novamente. Você pode usar `HDEL`, `HSET` ou `HGET` para essas operações sem obter o objeto inteiro.
    3. Se o tamanho do seu objeto de string aumentar, você sofrerá com a rede e a largura de banda ao transferir (obter/definir) todo o objeto. Como consta na documentação: “A velocidade da RAM e a largura de banda da memória parecem menos críticas para o desempenho global, especialmente para objetos pequenos. Para objetos grandes (>10 KB), pode se tornar perceptível.”
    4. Os hashes são mais compatíveis com a memória do que a string.
    
    Por outro lado, dependendo do(s) seu(s) caso(s) de uso;
    
    1. `ziplist` é uma troca entre memória e CPU.
    2. Você não pode expirar parcialmente os campos de hash. Se você dividir em várias strings, você poderá, mas em hashes apenas a chave de nível superior pode expirar com todos os valores.