Comandos básicos do Redis
Tags: redis, tutorial, programming, braziliandevs
Published: 2023-02-16 05:11:33

### Tópicos:
1. Introdução
2. Comandos
    1. Buscando as chaves do banco:
    2. Inserindo valores em chaves
    3. Recuperando valores das chaves
    4. Removendo chaves
    5. Configurando tempo de exclusão das chaves
    6. Inserir e configurar o tempo de expiração
    7. Inspecionar expiração de uma chave
    8. Removendo tempo de expiração de uma chave

## Introdução

No Redis, "key" é o termo usado para se referir a uma chave que é usada para identificar e acessar um determinado valor armazenado no banco de dados. Cada valor armazenado no Redis é associado a uma chave, que é uma string.

As chaves são únicas no Redis e podem ser usadas para acessar os valores associados a elas de forma eficiente, sem a necessidade de percorrer todos os valores armazenados no banco de dados. As chaves são usadas para identificar valores em todas as estruturas de dados do Redis, como strings, listas, conjuntos, hashes e sorted sets.

As chaves no Redis têm algumas limitações. Primeiro, elas devem ser únicas em todo o banco de dados. Isso significa que, se você tentar definir uma chave que já existe, o valor anterior será substituído pelo novo valor. Além disso, as chaves podem ter um tamanho máximo de 512 MB.

É importante escolher nomes de chave significativos e que descrevam bem o valor que está sendo armazenado. Nomes de chaves bem escolhidos podem ajudar a tornar o código mais legível e facilitar a manutenção do banco de dados. Por exemplo, em um aplicativo web, você pode usar nomes de chave como "usuario:123" para armazenar informações de um usuário com ID 123 ou "carrinho:456" para armazenar o carrinho de compras de um cliente com ID 456.

Em resumo, no Redis, "key" é a string usada para identificar e acessar um determinado valor armazenado no banco de dados. As chaves são únicas e devem ser escolhidas de maneira significativa para facilitar a legibilidade e a manutenção do código.

## Comandos:

### Buscando as chaves do banco:

O comando **`KEYS`** e o comando **`SCAN`** do Redis são usados para recuperar as chaves armazenadas no banco de dados. A principal diferença entre eles é a forma como eles recuperam as chaves e o impacto que isso pode ter no desempenho do Redis.

O comando **`KEYS`** é uma operação de varredura que retorna todas as chaves que correspondem a um padrão especificado. Por exemplo, você pode usar o comando **`KEYS`** para encontrar todas as chaves que começam com a string "user:" em um banco de dados Redis:

```bash
KEYS user:*
```

Embora o comando **`KEYS`** seja útil para recuperar chaves com base em um padrão, ele pode ter um grande impacto no desempenho do Redis se usado em bancos de dados com muitas chaves. Isso ocorre porque o Redis executa a varredura de todas as chaves no banco de dados para encontrar as chaves correspondentes ao padrão, o que pode ser muito demorado.

Para contornar esse problema, o Redis fornece o comando **`SCAN`**, que é uma operação de varredura incremental que retorna um conjunto de chaves em lotes menores. O comando **`SCAN`** recebe um cursor de varredura e um padrão de correspondência, e retorna um conjunto de chaves que correspondem ao padrão e um novo cursor de varredura que pode ser usado para recuperar o próximo conjunto de chaves. Aqui está um exemplo de como usar o comando **`SCAN`** para recuperar todas as chaves que começam com a string "user:" em um banco de dados Redis:

```bash
SCAN 0 MATCH user:*
```

Neste exemplo, o comando **`SCAN`** começa com um cursor de varredura de valor 0 e um padrão de correspondência **`user:*`**. O Redis retorna um conjunto de chaves que correspondem ao padrão, juntamente com um novo cursor de varredura que pode ser usado para recuperar o próximo conjunto de chaves.

Em geral, é recomendável usar o comando **`SCAN`** em vez do comando **`KEYS`** sempre que possível, especialmente em bancos de dados com muitas chaves. O comando **`SCAN`** é menos oneroso para o desempenho do Redis porque executa a varredura de um conjunto menor de chaves a cada chamada e retorna um conjunto menor de chaves. Isso ajuda a reduzir a carga no servidor Redis e evita que ele fique indisponível devido a operações de varredura demoradas.

### Inserindo valores em chaves

O Redis possui vários comandos para inserir valores em chaves. Alguns dos comandos mais comuns são:

1. **`SET`**: O comando **`SET`** é usado para definir um valor para uma chave. Se a chave já existir, seu valor anterior será substituído. Se a chave não existir, uma nova chave será criada com o valor especificado. O comando **`SET`** também permite definir opções, como o tempo de expiração da chave.
    
    ```bash
    SET minha_chave "valor da chave"
    ```
    
    Este comando define o valor "valor da chave" para a chave "minha_chave". Se a chave já existir, seu valor anterior será substituído.
    
2. **`MSET`**: O comando **`MSET`** é usado para definir vários valores de uma vez. Ele aceita um número arbitrário de argumentos, cada um representando uma chave e seu valor correspondente.
    
    ```bash
    MSET chave1 "valor 1" chave2 "valor 2" chave3 "valor 3"
    ```
    
    Este comando define os valores "valor 1", "valor 2" e "valor 3" para as chaves "chave1", "chave2" e "chave3", respectivamente.
    
3. **`SETNX`**: O comando **`SETNX`** é usado para definir o valor de uma chave somente se a chave não existir. Se a chave já existir, o comando não faz nada.
    
    ```bash
    SETNX minha_chave "valor da chave"
    ```
    
    Este comando define o valor "valor da chave" para a chave "minha_chave" somente se a chave não existir. Se a chave já existir, o comando não faz nada.
    
4. **`MSETNX`**: O comando **`MSETNX`** é usado para definir vários valores de uma vez, mas somente se todas as chaves especificadas não existirem. Ele aceita um número arbitrário de argumentos, cada um representando uma chave e seu valor correspondente.
    
    ```bash
    MSETNX chave1 "valor 1" chave2 "valor 2" chave3 "valor 3"
    ```
    
    Este comando define os valores "valor 1", "valor 2" e "valor 3" para as chaves "chave1", "chave2" e "chave3", respectivamente, somente se todas as chaves especificadas não existirem.
    
5. **`SETEX`**: O comando **`SETEX`** é usado para definir um valor para uma chave com um tempo de expiração específico. Ele aceita três argumentos: a chave, o tempo de expiração em segundos e o valor.
    
    ```bash
    SETEX minha_chave 3600 "valor da chave"
    ```
    
    Este comando define o valor "valor da chave" para a chave "minha_chave" e define um tempo de expiração de 1 hora (3600 segundos).
    
6. **`PSETEX`**: O comando **`PSETEX`** é semelhante ao **`SETEX`**, mas o tempo de expiração é especificado em milissegundos em vez de segundos.
    
    ```bash
    PSETEX minha_chave 3600000 "valor da chave"
    ```
    
    Este comando define o valor "valor da chave" para a chave "minha_chave" e define um tempo de expiração de 1 hora (3600000 milissegundos).
    
7. **`APPEND`**: O comando **`APPEND`** é usado para anexar um valor a uma chave existente. Se a chave não existir, o comando criará uma nova chave com o valor especificado.
    
    ```bash
    APPEND minha_chave " valor adicional"
    ```
    
    Este comando anexa o valor " valor adicional" à chave "minha_chave". Se a chave não existir, o comando criará uma nova chave com o valor especificado.
    

### Recuperando valores das chaves

1. **`GET`**:
    
    ```bash
    GET minha_chave
    ```
    
    Este comando retorna o valor associado à chave "minha_chave".
    
2. **`MGET`**:
    
    ```bash
    MGET chave1 chave2 chave3
    ```
    
    Este comando retorna os valores associados às chaves "chave1", "chave2" e "chave3", respectivamente.
    
3. **`GETSET`**:
    
    ```bash
    GETSET minha_chave "novo valor"
    ```
    
    Este comando retorna o valor anterior associado à chave "minha_chave" e define o novo valor "novo valor" para a chave.
    
4. **`STRLEN`**:
    
    ```bash
    STRLEN minha_chave
    ```
    
    Este comando retorna o comprimento (em bytes) do valor associado à chave "minha_chave".
    
5. **`INCR`**:
    
    ```bash
    INCR minha_chave
    ```
    
    Este comando incrementa o valor associado à chave "minha_chave" em 1.
    
6. **`INCRBY`**:
    
    ```
    INCRBY minha_chave 5
    ```
    
    Este comando incrementa o valor associado à chave "minha_chave" em 5.
    
7. **`DECR`**:
    
    ```bash
    DECR minha_chave
    ```
    
    Este comando decrementa o valor associado à chave "minha_chave" em 1.
    
8. **`DECRBY`**:
    
    ```bash
    DECRBY minha_chave 5
    ```
    
    Este comando decrementa o valor associado à chave "minha_chave" em 5.
    
9. **`GETRANGE`**:
    
    ```bash
    GETRANGE minha_chave 0 4
    ```
    
    Este comando retorna a substring do valor associado à chave "minha_chave" que começa no índice 0 e termina no índice 4.
    
10. **`GETBIT`**:
    
    ```bash
    GETBIT minha_chave 0
    ```
    
    Este comando retorna o valor do bit na posição 0 do valor associado à chave "minha_chave".
    

### Removendo chaves

Os comandos **`DEL`** e **`UNLINK`** do Redis são usados para remover chaves do banco de dados. Ambos os comandos funcionam de maneira semelhante, mas há algumas diferenças importantes entre eles.

O comando **`DEL`** é usado para excluir uma ou mais chaves especificadas do banco de dados. Por exemplo, o comando **`DEL`** pode ser usado para excluir a chave "minha_chave" do banco de dados Redis:

```bash
DEL minha_chave
```

O comando **`DEL`** remove a chave e seu valor imediatamente do banco de dados.

Por outro lado, o comando **`UNLINK`** também é usado para excluir chaves do banco de dados, mas tem algumas diferenças importantes. O comando **`UNLINK`** é uma versão assíncrona do comando **`DEL`**. Em vez de excluir imediatamente as chaves, o comando **`UNLINK`** marca as chaves para exclusão e as remove em segundo plano.

Por exemplo, o comando **`UNLINK`** pode ser usado para excluir a chave "minha_chave" do banco de dados Redis:

```bash
UNLINK minha_chave
```

O comando **`UNLINK`** marca a chave "minha_chave" para exclusão e remove a chave em segundo plano. O comando **`UNLINK`** pode ser útil em situações em que você deseja excluir muitas chaves ao mesmo tempo, mas não deseja sobrecarregar o banco de dados com operações de exclusão síncronas. No entanto, é importante observar que as chaves marcadas para exclusão pelo comando **`UNLINK`** podem permanecer no banco de dados por algum tempo antes de serem efetivamente excluídas.

Em resumo, o comando **`DEL`** é usado para excluir chaves do banco de dados de forma síncrona, enquanto o comando **`UNLINK`** é usado para marcar chaves para exclusão em segundo plano e removê-las posteriormente. Se você precisar excluir chaves imediatamente do banco de dados, o comando **`DEL`** é a melhor escolha. No entanto, se você precisar excluir muitas chaves ao mesmo tempo e quiser evitar a sobrecarga do banco de dados com operações de exclusão síncronas, o comando **`UNLINK`** pode ser uma boa opção.

### Configurando tempo de exclusão das chaves

Os comandos **`EXPIRE`**, **`EXPIREAT`**, **`PEXPIRE`** e **`PEXPIREAT`** são usados para definir um tempo de expiração para uma chave no Redis. Eles permitem que você configure uma chave para ser automaticamente excluída do banco de dados após um determinado período de tempo.

O comando **`EXPIRE`** define o tempo de expiração em segundos a partir do momento em que o comando é executado. Por exemplo, o seguinte comando define a chave "minha_chave" para expirar em 60 segundos:

```bash
EXPIRE minha_chave 60
```

O comando **`EXPIREAT`** define o tempo de expiração como um carimbo de data/hora Unix (em segundos) a partir do momento em que o comando é executado. Por exemplo, o seguinte comando define a chave "minha_chave" para expirar às 10h30 do dia 17 de fevereiro de 2023:

```bash
EXPIREAT minha_chave 1645086600
```

O comando **`PEXPIRE`** é semelhante ao comando **`EXPIRE`**, mas define o tempo de expiração em milissegundos a partir do momento em que o comando é executado. Por exemplo, o seguinte comando define a chave "minha_chave" para expirar em 500 milissegundos (ou 0,5 segundos):

```bash
PEXPIRE minha_chave 500
```

O comando **`PEXPIREAT`** é semelhante ao comando **`EXPIREAT`**, mas define o tempo de expiração como um carimbo de data/hora Unix em milissegundos a partir do momento em que o comando é executado. Por exemplo, o seguinte comando define a chave "minha_chave" para expirar às 10h30 e 30 milissegundos do dia 17 de fevereiro de 2023:

```bash
PEXPIREAT minha_chave 1645086630000
```

Em resumo, os comandos **`EXPIRE`**, **`EXPIREAT`**, **`PEXPIRE`** e **`PEXPIREAT`** são usados para definir um tempo de expiração para uma chave no Redis. Cada um desses comandos oferece uma forma diferente de especificar o tempo de expiração, permitindo que você configure uma chave para ser automaticamente excluída do banco de dados após um determinado período de tempo.

### Inserir e configurar o tempo de expiração

É possível configurar o tempo de expiração de uma chave ao mesmo tempo em que a chave é inserida no Redis, usando o comando **`SET`** com o parâmetro opcional **`EX`** ou **`PX`**.

O parâmetro **`EX`** define o tempo de expiração em segundos, enquanto o parâmetro **`PX`** define o tempo de expiração em milissegundos. Por exemplo, para inserir a chave "minha_chave" com um valor "meu_valor" e um tempo de expiração de 60 segundos, você pode executar o seguinte comando:

```bash
SET minha_chave meu_valor EX 60
```

Da mesma forma, para definir um tempo de expiração de 500 milissegundos (ou 0,5 segundos), você pode usar o seguinte comando:

```
SET minha_chave meu_valor PX 500
```

Usar esses parâmetros no comando **`SET`** é útil quando você sabe que uma chave específica deve ser excluída automaticamente após um determinado período de tempo. É importante notar que o tempo de expiração definido dessa forma é uma propriedade da chave em si, e não da conexão do cliente que a inseriu, o que significa que a chave será excluída mesmo que a conexão do cliente seja encerrada antes que o tempo de expiração expire.

### Inspecionar expiração de uma chave

O Redis possui dois comandos para inspecionar a expiração de uma chave: **`TTL`** e **`PTTL`**.

O comando **`TTL`** **retorna o tempo em segundos** restantes para a expiração de uma chave.

```bash
TTL minha_chave
```

Se a chave "minha_chave" não tiver tempo de expiração definido, o comando retornará -1.

O comando **`PTTL`** é semelhante ao **`TTL`**, mas **retorna o** **tempo em milissegundos** restantes para a expiração de uma chave. Por exemplo, para obter o tempo restante em milissegundos para a expiração da chave "minha_chave", você pode executar o seguinte comando:

```bash
PTTL minha_chave
```

Para os dois comando `TLL` e `PTTL` se a chave não tiver tempo de expiração definido, o comando retorna -1. Se a chave não existir, o comando retorna -2.

### Removendo tempo de expiração de uma chave

O comando **`PERSIST`** é usado no Redis para remover a expiração de uma chave, ou seja, tornar uma chave permanente. Se uma chave tiver tempo de expiração definido, ela será excluída automaticamente pelo Redis após o tempo especificado ter decorrido. No entanto, se você deseja manter uma chave para sempre, pode usar o comando **`PERSIST`** para remover a expiração definida anteriormente.

Para remover a expiração de uma chave, você pode executar o seguinte comando:

```bash
PERSIST minha_chave
```

Esse comando removerá a expiração da chave "minha_chave", tornando-a permanente. Se a chave não tiver expiração definida anteriormente, o comando não fará nada.

É importante lembrar que o comando **`PERSIST`** não pode ser usado em chaves que não têm tempo de expiração definido. Além disso, assim como outros comandos do Redis, o comando **`PERSIST`** é atômico, o que significa que ele é executado como uma operação única e não pode ser interrompido no meio.