Delete Everything in Redis

Last updated: January 8, 2024

Written by: Vivek Balasubramaniam

Reviewed by: Ashley Frieze

NoSQL

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

1. Overview

When caching in Redis, it can be useful to clear the whole cache when it becomes invalid.

In this short tutorial, we’ll learn how to delete all the keys present in Redis, both in specific databases and across all databases.

First, we’ll look at the command line. Then, we’ll see how to accomplish the same thing using the APIs and the Java client.

2. Running Redis

We’ll need an installation of Redis to work with. There are installation instructions for Mac and Linux in the Redis quickstart. It’s probably easier to run Redis in docker.

Let’s start a test Redis server:

docker run --name redis -p 6379:6379 -d redis:latest

And, we can run redis-cli to test that this server is working:

docker exec -it redis redis-cli

This drops us into the cli shell, where the command ping will test whether the server is up:

127.0.0.1:6379> ping
PONG

We exit the redis-cli with CTRL+C.

3. Redis Commands

Let’s start with the Redis commands to delete everything.

There are two major commands to delete the keys present in Redis: FLUSHDB and FLUSHALL. We can use the Redis CLI to execute these commands.

The FLUSHDB command deletes the keys in a database. And the FLUSHALL command deletes all keys in all databases.

We can execute these operations in a background thread using the ASYNC option. This is useful if the flush takes a long time, as making the command ASYNC stops it from blocking until it’s complete.

We should note that the ASYNC option is available from Redis 4.0.0.

4. Working with the Java Client

Now, let’s see how to use the Jedis Java client for deleting keys.

4.1. Dependencies

First, we’ll need to add the Maven dependency for Jedis:

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>5.0.2</version>
</dependency>

To make testing easier, let’s also use an embedded Redis server:

<dependency>
    <groupId>com.github.kstyrc</groupId>
    <artifactId>embedded-redis</artifactId>
    <version>0.6</version>
</dependency>

4.2. Starting an Embedded Redis

We’ll create an embedded Redis server to test with, by running it on an available port:

RedisServer redisServer = new RedisServer(port);
redisServer.start();

Our Jedis client is then created with localhost as the host name, and the same port:

Jedis jedis = new Jedis("localhost", port);

5. Flushing a Single Database

Let’s put some data into the database and check that it’s remembered:

String key = "key";
String value = "value";
jedis.set(key, value);
String received = jedis.get(key);
 
assertEquals(value, received);

Now let’s flush the database using the flushDB method:

jedis.flushDB();

assertNull(jedis.get(key));

As we can see, attempting to retrieve the value after flushing returns null.

6. Clearing All Databases

Redis provides multiple databases, which are numbered. We can add data to different databases by using the select command before we add our values:

jedis.select(0);
jedis.set("key1", "value1");
jedis.select(1);
jedis.set("key2", "value2");

We should now have one key in each of our two databases:

jedis.select(0);
assertEquals("value1", jedis.get("key1"));
assertNull(jedis.get("key2"));

jedis.select(1);
assertEquals("value2", jedis.get("key2"));
assertNull(jedis.get("key1"));

The flushDB method will only clear the current database. In order to clear all the databases, we use the flushAll method:

jedis.flushAll();

We can test that this has worked:

jedis.select(0);
 
assertNull(jedis.get("key1"));
assertNull(jedis.get("key2"));
 
jedis.select(1);
 
assertNull(jedis.get("key1"));
assertNull(jedis.get("key2"));

7. Time Complexity

Redis is a fast data store that scales well. However, flush operations can take longer when there is more data.

The time complexity of the FLUSHDB operation is O(N), where N is the number of keys in the database. If we use the FLUSHALL command, the time complexity is again O(N), but here, N is the number of keys in all databases.