Scaling Username Uniqueness Checks: DB Queries, Redis Cache & Bloom Filters

Preface

When a user registers an account, the system must ensure the chosen username is not already taken. A simple database lookup works for small user bases, but with hundreds of millions of users the latency, load, and scalability become serious concerns.

Database Solution

The most straightforward approach is to query the relational database directly. The following Java code demonstrates a typical implementation using JDBC.

<code>public class UsernameUniquenessChecker {
    private static final String DB_URL = "jdbc:mysql://localhost:3306/your_database";
    private static final String DB_USER = "your_username";
    private static final String DB_PASSWORD = "your_password";

    public static boolean isUsernameUnique(String username) {
        try (Connection conn = DriverManager.getConnection(DB_URL, DB_USER, DB_PASSWORD)) {
            String sql = "SELECT COUNT(*) FROM users WHERE username = ?";
            try (PreparedStatement stmt = conn.prepareStatement(sql)) {
                stmt.setString(1, username);
                try (ResultSet rs = stmt.executeQuery()) {
                    if (rs.next()) {
                        int count = rs.getInt(1);
                        return count == 0; // If count is 0, username is unique
                    }
                }
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return false; // In case of an error, consider the username as non‑unique
    }

    public static void main(String[] args) {
        String desiredUsername = "new_user";
        boolean isUnique = isUsernameUnique(desiredUsername);
        if (isUnique) {
            System.out.println("Username '" + desiredUsername + "' is unique. Proceed with registration.");
        } else {
            System.out.println("Username '" + desiredUsername + "' is already in use. Choose a different one.");
        }
    }
}
</code>

While simple, this method suffers from high latency, heavy database load, and poor horizontal scalability as request volume grows.

Cache Solution

To reduce database pressure, a Redis cache can store usernames that have already been seen. The code below shows a basic Redis‑based checker.

<code>public class UsernameCache {
    private static final String REDIS_HOST = "localhost";
    private static final int REDIS_PORT = 6379;
    private static final int CACHE_EXPIRATION_SECONDS = 3600;

    private static JedisPool jedisPool;

    static {
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        jedisPool = new JedisPool(poolConfig, REDIS_HOST, REDIS_PORT);
    }

    public static boolean isUsernameUnique(String username) {
        try (Jedis jedis = jedisPool.getResource()) {
            if (jedis.sismember("usernames", username)) {
                return false; // Username is not unique
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return true; // Username is unique (not found in cache)
    }

    public static void addToCache(String username) {
        try (Jedis jedis = jedisPool.getResource()) {
            jedis.sadd("usernames", username);
            jedis.expire("usernames", CACHE_EXPIRATION_SECONDS);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void close() {
        jedisPool.close();
    }
}
</code>

The cache dramatically improves response time, but storing every username in memory can require tens of gigabytes for billions of users, which may be prohibitive.

Bloom Filter Solution

A Bloom filter provides a memory‑efficient probabilistic set membership test. It uses a bit array and multiple hash functions to record element presence, allowing constant‑time checks with a controllable false‑positive rate.

The diagram below illustrates the bit array and hash functions.

Redis natively supports Bloom filters via the

bf

module. The following Java example creates a filter, adds a username, and checks membership.

<code>import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class BloomFilterExample {
    public static void main(String[] args) {
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        JedisPool jedisPool = new JedisPool(poolConfig, "localhost", 6379);

        try (Jedis jedis = jedisPool.getResource()) {
            // Create a Bloom filter named "usernameFilter" with expected elements and false‑positive rate
            jedis.bfCreate("usernameFilter", 10000000, 0.01);

            // Add a username to the Bloom filter
            jedis.bfAdd("usernameFilter", "alvin");

            // Check if the username already exists
            boolean exists = jedis.bfExists("usernameFilter", "alvin");
            System.out.println("Username exists: " + exists);
        }
    }
}
</code>

Advantages: dramatically lower memory usage (e.g., ~1.7 GB for 10 billion entries with 1 % false‑positive rate) and O(1) lookup time. Disadvantages: a non‑zero false‑positive rate and inability to delete individual elements.

Conclusion

Using Redis’s Bloom filter offers an efficient, scalable solution for massive‑scale username uniqueness validation, balancing memory consumption against an acceptable false‑positive probability, and can also be applied to cache‑penetration protection and other high‑throughput membership‑test scenarios.