How do I delete everything in Redis?

Question

I want to delete all keys. I want everything wiped out and give me a blank database.

Is there a way to do this in Redis client?

Isogamete

I wonder why del * doesn't work. It returns 0. – Mustache

@Mustache del * deletes the key named "*". (Only some commands accept glob patterns, because it's very slow to check a pattern against all keys in a database with many keys.) – Tonietonight

Answer 1

With redis-cli:

• FLUSHDB – Deletes all keys from the connection's current database.
• FLUSHALL – Deletes all keys from all databases on current host.

For example, in your shell:

redis-cli flushall

Colonize

When i try the above i get the following error (error) LOADING Redis is loading the dataset in memory. Can you specify why? – Razzledazzle

@Ramswaroop - you restarted Redis and it is currently loading data from persistent storage. While this process (loading) is active, you can't manipulate the DB. Either wait for it to finish, or configure Redis w/o persistence and restart it (it will start empty so you won't need to do FLUSHALL once it is up). – Appolonia

that my Friend DID the trick, forgot about redis, clearing out the cache and now schema:update works. – Desideratum

@Neo if you don't have a redis client library in C#, you can simply run that command, like so: (new Process { StartInfo = new ProcessStartInfo { FileName = "redis-cli", Arguments = "flushall", CreateNoWindow = true }}).start(); – Adorne

Use the -h flag to specify a redis server location – Uvarovite

And the -p flag to specify the port if it is not the standard 6379 – Inhere

I am running redis as cluster mode (redis-cli --cluster create 127.0.0.1:7000 127.0.0.1:7001 127.0.0.1:7002 127.0.0.1:7003 127.0.0.1:7004 127.0.0.1:7005 --cluster-replicas 1) and I am using redis-clustr node package. flushall is not deleting all keys. But let = keys = client.keys("*"); client.del(keys) is working fine. – Tetralogy

This flushes data, yes, but, when restarting redis, the data re-appears. Seems like its loaded from disk on every start. Removing the file "dump.rdb" clears the cached data. – Carillo

Answer 2

Heads up that FLUSHALL may be overkill. FLUSHDB is the one to flush a database only. FLUSHALL will wipe out the entire server. As in every database on the server. Since the question was about flushing a database I think this is an important enough distinction to merit a separate answer.

Shrub

+1 from me, i thought this was the better answer actually. Granted, the OP's Question says "wipe everything out" but that is followed by "give me a blank database"--regardless of what he actually meant, i think the distinction you made is useful, to say the least. – Wolgast

Answer 3

Answers so far are absolutely correct; they delete all keys.

However, if you also want to delete all Lua scripts from the Redis instance, you should follow it by:

SCRIPT FLUSH

The OP asks two questions; this completes the second question (everything wiped).

Cleek

If you are running the server yourself, the quickest way to wipe everything is to kill the server and restart it (found this out accidentally) – Compete

Answer 4

FLUSHALL Remove all keys from all databases

FLUSHDB Remove all keys from the current database

SCRIPT FLUSH Remove all the scripts from the script cache.

Susanasusanetta

Answer 5

you can use flushall in your terminal

redis-cli> flushall

Wizened

Answer 6

If you're using the redis-rb gem then you can simply call:

your_redis_client.flushdb

Raconteur

Answer 7

This method worked for me - delete everything of current connected Database on your Jedis cluster.

public static void resetRedis() {
    jedisCluster = RedisManager.getJedis(); // your JedisCluster instance

    for (JedisPool pool : jedisCluster.getClusterNodes().values()) {

        try (Jedis jedis = pool.getResource()) {
            jedis.flushAll();
        }
        catch (Exception ex){
            System.out.println(ex.getMessage());
        }
    }

}

Activator

Answer 8

One more option from my side:

In our production and pre-production databases there are thousands of keys. Time to time we need to delete some keys (by some mask), modify by some criteria etc. Of course, there is no way to do it manually from CLI, especially having sharding (512 logical dbs in each physical).

For this purpose I write java client tool that does all this work. In case of keys deletion the utility can be very simple, only one class there:

public class DataCleaner {

    public static void main(String args[]) {
        String keyPattern = args[0];
        String host = args[1];
        int port = Integer.valueOf(args[2]);
        int dbIndex = Integer.valueOf(args[3]);

        Jedis jedis = new Jedis(host, port);

        int deletedKeysNumber = 0;
        if(dbIndex >= 0){
            deletedKeysNumber += deleteDataFromDB(jedis, keyPattern, dbIndex);
        } else {
            int dbSize = Integer.valueOf(jedis.configGet("databases").get(1));
            for(int i = 0; i < dbSize; i++){
                deletedKeysNumber += deleteDataFromDB(jedis, keyPattern, i);
            }
        }

        if(deletedKeysNumber == 0) {
            System.out.println("There is no keys with key pattern: " + keyPattern + " was found in database with host: " + host);
        }
    }

    private static int deleteDataFromDB(Jedis jedis, String keyPattern, int dbIndex) {
        jedis.select(dbIndex);
        Set<String> keys = jedis.keys(keyPattern);
        for(String key : keys){
            jedis.del(key);
            System.out.println("The key: " + key + " has been deleted from database index: " + dbIndex);
        }

        return keys.size();
    }

}

Writing such kind of tools I find very easy and spend no more then 5-10 min.

Caldeira

Answer 9

Use FLUSHALL ASYNC if using (Redis 4.0.0 or greater) else FLUSHALL.

https://redis.io/commands/flushall

Note: Everything before executing FLUSHALL ASYNC will be evicted. The changes made during executing FLUSHALL ASYNC will remain unaffected.

Staub

Answer 10

Open redis-cli and type:

FLUSHALL

Joktan

Although your post might answer the question, it lacks some documentation. Please edit your answer and provide those. – Davidoff

Answer 11

FLUSHALL Deletes all the Keys of All exisiting databases . FOr Redis version > 4.0 , FLUSHALL ASYNC is supported which runs in a background thread wjthout blocking the server https://redis.io/commands/flushall

FLUSHDB - Deletes all the keys in the selected Database . https://redis.io/commands/flushdb

The time complexity to perform the operations will be O(N) where N being the number of keys in the database.

The Response from the redis will be a simple string "OK"

Comma

Answer 12

You can use FLUSHALL which will delete all keys from your every database. Where as FLUSHDB will delete all keys from our current database.

Openhanded

Answer 13

1. Stop Redis instance.
2. Delete RDB file.
3. Start Redis instance.

Caldeira

In my experience, if you have persistence, you should indeed follow this procedure + also delete any .aof file + issue redis-cli flushall, to really remove everything. – Lovato

Answer 14

redis-cli -h <host> -p <port> flushall

It will remove all data from client connected(with host and port)

Priddy

Answer 15

After you start the Redis-server using:service redis-server start --port 8000 or redis-server.

Use redis-cli -p 8000 to connect to the server as a client in a different terminal.

You can use either

1. FLUSHDB - Delete all the keys of the currently selected DB. This command never fails. The time-complexity for this operation is O(N), N being the number of keys in the database.
2. FLUSHALL - Delete all the keys of all the existing databases, not just the currently selected one. This command never fails. The time-complexity for this operation is O(N), N being the number of keys in all existing databases.

Check the documentation for ASYNC option for both.

If you are using Redis through its python interface, use these two functions for the same functionality:

def flushall(self):
    "Delete all keys in all databases on the current host"
    return self.execute_command('FLUSHALL')

and

def flushdb(self):
    "Delete all keys in the current database"
    return self.execute_command('FLUSHDB')

Pedigo

Answer 16

i think sometimes stop the redis-server and delete rdb，aof files。 make sure there’s no data can be reloading. then start the redis-server,now it's new and empty.

Jarv

Answer 17

You can use FLUSHDB

e.g

List databases:

127.0.0.1:6379> info keyspace
# Keyspace

List keys

127.0.0.1:6379> keys *
(empty list or set)

Add one value to a key

127.0.0.1:6379> lpush key1 1
(integer) 1
127.0.0.1:6379> keys *
1) "key1"
127.0.0.1:6379> info keyspace
# Keyspace
db0:keys=1,expires=0,avg_ttl=0

Create other key with two values

127.0.0.1:6379> lpush key2 1
(integer) 1
127.0.0.1:6379> lpush key2 2
(integer) 2
127.0.0.1:6379> keys *
1) "key1"
2) "key2"
127.0.0.1:6379> info keyspace
# Keyspace
db0:keys=2,expires=0,avg_ttl=0

List all values in key2

127.0.0.1:6379> lrange key2 0 -1
1) "2"
2) "1"

Do FLUSHDB

127.0.0.1:6379> flushdb
OK

List keys and databases

127.0.0.1:6379> keys *
(empty list or set)
127.0.0.1:6379> info keyspace
# Keyspace

Territoriality

keys * command is an expensive command. don't run this command on a production redis server – Tipsy

Answer 18

This works for me: redis-cli KEYS \* | xargs --max-procs=16 -L 100 redis-cli DEL

It list all Keys in redis, then pass using xargs to redis-cli DEL, using max 100 Keys per command, but running 16 command at time, very fast and useful when there is not FLUSHDB or FLUSHALL due to security reasons, for example when using Redis from Bitnami in Docker or Kubernetes. Also, it doesn't require any additional programming language and it just one line.

Bradwell

KEYS is a dangerous command in a large database. Firstly, it can be very slow. Secondly, the list of keys can be a hugh amount of data to transfer to the client. – Tonietonight

@ViktorSöderqvist Slow: Yes. Some MB to transfer to the client: Yes. Dangerous? I don't think so. This is the solution when there is not full access to Redis – Bradwell

Well, KEYS can affect the performance of your application, but if you're going to delete all keys anyway, that's not an issue. It is flagged as @dangerous (see COMMAND INFO KEYS). – Tonietonight

A great solution. It's worth noting, however, that in certain applications it can lead to inconsistent states during script execution, as it's not an atomic operation like FLUSHDB. For the vast majority, I think this wouldn't be a problem, but for the other cases, it's better to be cautious. – Ergotism

Answer 19

I know there are two ways to clear the Redis database.

• FLUSHALL Remove all keys from all databases;

  # redis-cli flushall
  

• FLUSHDB Remove all keys from the current database

  # redis-cli -p 6000 select 0
  # redis-cli flushdb
  

This operation is quite dangerous, please make sure to exclude the production environment configuration before the operation.

Bud

Answer 20

Your questions seems to be about deleting entire keys in a database. In this case you should try:

1. Connect to redis. You can use the command redis-cli (if running on port 6379), else you will have to specify the port number also.
2. Select your database (command select {Index})
3. Execute the command flushdb

If you want to flush keys in all databases, then you should try flushall.

Heterozygous

Answer 21

you can use following approach in python

def redis_clear_cache(self):

    try:
        redis_keys = self.redis_client.keys('*')
    except Exception as e:
        # print('redis_client.keys() raised exception => ' + str(e))
        return 1

    try:
        if len(redis_keys) != 0:
            self.redis_client.delete(*redis_keys)
    except Exception as e:
        # print('redis_client.delete() raised exception => ' + str(e))
        return 1

    # print("cleared cache")
    return 0

Beaune

Answer 22

If you want to clear redis in windows: find redis-cli in

C:\Program Files\Redis and run FLUSHALL command.

Inexplicable

Answer 23

For anyone wondering how to do this in C# it's the same as the answer provided for Python for this same question.

I am using StackExchange.Redis v2.2.88 for a dot net (core) 5 project. I only need to clear my keys for integration testing and I have no purpose to do this in production.

I checked what is available in intellisense and I don't see a stock way to do this with the existing API. I imagine this is intentional and by design. Luckily the API does expose an Execute method.

I tested this by doing the following:

1. Opened up a command window. I am using docker, so I did it through docker.

2. Type in redis-cli which starts the CLI

3. Type in KEYS * and it shows me all of my keys so I can verify they exist before and after executing the following code below:

   //Don't abuse this, use with caution var cache = ConnectionMultiplexer.Connect( new ConfigurationOptions { EndPoints = { "localhost:6379" } });

   var db = _cache.GetDatabase();

   db.Execute("flushdb");

4. Type in KEYS * again and view that it's empty.

Hope this helps anyone looking for it.

Hereunto

Answer 24

Its better if you can have RDM (Redis Desktop Manager). You can connect to your redis server by creating a new connection in RDM.

Once its connected you can check the live data, also you can play around with any redis command.

Opening a cli in RDM.

1) Right click on the connection you will see a console option, just click on it a new console window will open at the bottom of RDM.

Coming back to your question FLUSHALL is the command, you can simply type FLUSHALL in the redis cli.

Moreover if you want to know about any redis command and its proper usage, go to link below. https://redis.io/commands.

Virginavirginal

Answer 25

There are different approaches. If you want to do this from remote, issue flushall to that instance, through command line tool redis-cli or whatever tools i.e. telnet, a programming language SDK. Or just log in that server, kill the process, delete its dump.rdb file and appendonly.aof(backup them before deletion).

Seville

Answer 26

If you are using Java then from the documentation, you can use any one of them based on your use case.

/**
 * Remove all keys from all databases.
 *
 * @return String simple-string-reply
 */
String flushall();

/**
 * Remove all keys asynchronously from all databases.
 *
 * @return String simple-string-reply
 */
String flushallAsync();

/**
 * Remove all keys from the current database.
 *
 * @return String simple-string-reply
 */
String flushdb();

/**
 * Remove all keys asynchronously from the current database.
 *
 * @return String simple-string-reply
 */
String flushdbAsync();

Code:

RedisAdvancedClusterCommands syncCommands = // get sync() or async() commands 
syncCommands.flushdb();

Read more: https://github.com/lettuce-io/lettuce-core/wiki/Redis-Cluster

Spermatozoid