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.
First, we'll need to add the Maven dependency for Jedis:
<dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>3.3.0</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:
RedisService redisServer = new RedisServer(port);
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:
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:
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.
In this article, we saw how to run Redis and the redis-cli in Docker, and how to use the Jedis client for Java with an embedded Redis server.
We saw how to keep data in different Redis databases and how to use the flush commands to clear one or more of them.
As always, the source code for this article is available over on GitHub.