Here is a comprehensive example that covers a wide range of common Redis features:
A. Common Commands
1. Basic CRUD Operations
Set and Get Data
SET user:1:name "John Doe"
GET user:1:name
Example with TTL (Time to Live)
SET session:1234 "session_data" EX 60 # Key will expire in 60 seconds
GET session:1234
TTL session:1234 # Check how much time is left for the key
2. Hashes
Hashes are used to store multiple fields and values under a single key.
Example: Using Hashes to Store User Information
HSET user:1 name "John Doe" email "john@example.com"
HGETALL user:1 # Retrieve all fields and values
HGET user:1 email # Retrieve specific field
HDEL user:1 email # Delete specific field
3. Lists
Lists are used to store an ordered sequence of elements.
Example: Using Lists for a Queue
RPUSH queue:tasks "task1" "task2" # Add tasks to the right end of the list
LPOP queue:tasks # Remove the task from the left end
LRANGE queue:tasks 0 -1 # Get all tasks in the queue
4. Sets
Sets are unordered collections of unique elements.
Example: Using Sets to Store Unique Tags
SADD tags "redis" "nosql" "database"
SMEMBERS tags # Get all members of the set
SISMEMBER tags "redis" # Check if an element exists
SREM tags "nosql" # Remove an element from the set
5. Sorted Sets
Sorted Sets are like Sets but with an associated score for each member, which allows ordering.
Example: Using Sorted Sets for Leaderboards
ZADD leaderboard 1000 "user:1" 500 "user:2"
ZRANGE leaderboard 0 -1 WITHSCORES # Get all members with scores
ZRANK leaderboard "user:1" # Get the rank of a specific member
ZINCRBY leaderboard 100 "user:1" # Increment the score of a member
6. Transactions
Transactions in Redis allow you to execute multiple commands in a single, atomic operation using MULTI and EXEC.
Example: Simple Transaction
MULTI
SET account:1:balance 100
INCRBY account:1:balance 50
DECRBY account:1:balance 25
EXEC
7. Pipelining
Pipelining allows multiple commands to be sent to the server without waiting for a reply.
Example: Pipelining with Redis CLI
redis-cli --pipe
SET user:1 "John Doe"
SET user:2 "Jane Doe"
SET user:3 "Alice Smith"
8. Pub/Sub (Publish/Subscribe)
Redis Pub/Sub allows for message broadcasting to multiple clients subscribed to a channel.
Example: Publish/Subscribe System
Publisher
PUBLISH news "Breaking News: Redis is awesome!"
Subscriber
SUBSCRIBE news
9. Lua Scripting
You can run Lua scripts in Redis for atomic and efficient processing.
Example: Lua Script for Incrementing a Key
EVAL "return redis.call('INCRBY', KEYS[1], ARGV[1])" 1 counter 10
This script increments the value of counter by 10.
10. Expiration and Persistence
You can set expiration times for keys, or Redis can persist data using snapshots (RDB) or append-only files (AOF).
Example: Set Expiration
SET temp:key "temp_value" EX 10 # Key will expire after 10 seconds
Example: Persistence Configuration
SAVE # Force an RDB snapshot
BGSAVE # Background save
11. HyperLogLog
HyperLogLog is used for approximating the cardinality (i.e., number of unique elements) of large datasets.
Example: Counting Unique Visitors
PFADD unique_visitors "user1" "user2" "user3"
PFCOUNT unique_visitors # Approximate count of unique users
12. Bitmaps
Redis allows bit-level operations on string values.
Example: Simple Bitmap Usage
SETBIT user:1:loggedin 0 1 # Set bit 0 to 1
GETBIT user:1:loggedin 0 # Get bit 0
BITCOUNT user:1:loggedin # Count number of set bits
13. Geospatial Indexes
Redis allows you to store, query, and perform operations on geospatial data.
Example: Geospatial Operations
GEOADD cities:locations 13.361389 38.115556 "Palermo"
GEOADD cities:locations 15.087269 37.502669 "Catania"
GEORADIUS cities:locations 15 37 100 km # Find locations within 100 km
14. Streams
Streams are a type of log structure that allows you to store and consume data in an append-only manner.
Example: Adding and Reading from a Stream
XADD mystream * name "John Doe" age 30
XRANGE mystream - +
15. Redis Cluster
Redis supports clustering to scale horizontally.
Example: Create a Cluster
You would typically use redis-cli or a specialized tool for cluster setup, but the basic steps involve:
redis-cli --cluster create 127.0.0.1:7000 127.0.0.1:7001 127.0.0.1:7002 --cluster-replicas 1
16. Replication
Redis supports master-slave replication for high availability.
Example: Setting Up Replication
In the Redis configuration file (redis.conf):
replicaof 127.0.0.1 6379
17. Redis Sentinel
Sentinel provides high availability through automatic failover.
Example: Starting Sentinel
redis-sentinel /path/to/sentinel.conf
In the Sentinel config file:
sentinel monitor mymaster 127.0.0.1 6379 2
18. Redis Modules
Redis Modules allow you to extend Redis with custom functionality.
Example: Loading a Redis Module
In the Redis config file:
loadmodule /path/to/module.so
Modules like RedisGraph, RedisAI, and RediSearch are popular extensions.
19. Memory Management
Redis provides commands to monitor memory usage and optimize performance.
Example: Checking Memory Usage
INFO memory
This provides detailed information about memory consumption, fragmentation, and key eviction policy.
20. EXPLAIN Command
While Redis doesn’t have an equivalent to SQL EXPLAIN, you can use the DEBUG command to get insights into what the server is doing.
Example: DEBUG Command
DEBUG OBJECT keyname
This shows metadata about a specific key, such as encoding, reference count, and idle time.
B. Other Advanced Commands
The comprehensive Redis example covers most common features, but here are a few additional advanced or specialized features that might be useful:
1. Scan Operations
Redis provides a way to iterate over large datasets without blocking.
Example: Iterating Over Keys (Non-Blocking)
SCAN 0 MATCH user:* COUNT 10
SCAN is a cursor-based iteration over the dataset.
Example: Scanning a Hash
HSCAN user:1 0 MATCH field* COUNT 5
2. Redis Memory Optimization
Example: Eviction Policies
Redis allows you to specify eviction policies for managing memory.
CONFIG SET maxmemory-policy allkeys-lru
This setting enables the LRU (Least Recently Used) eviction policy.
Example: Memory Usage of Specific Key
MEMORY USAGE user:1
This command returns the memory usage in bytes for the key user:1.
3. Keyspace Notifications
Redis can send notifications about keyspace events, such as expiration or modification of keys.
Example: Enabling Notifications
CONFIG SET notify-keyspace-events Ex
This enables expiration notifications.
Example: Listening for Expiration Events
PSUBSCRIBE __keyevent@0__:expired
This subscribes to events where keys in database 0 expire.
4. Stream Consumers and Consumer Groups
Stream Consumer Groups allow multiple consumers to read from the same stream independently.
Example: Creating and Using Consumer Groups
XGROUP CREATE mystream group1 0
XREADGROUP GROUP group1 consumer1 COUNT 1 STREAMS mystream >
5. Redis Modules (Advanced)
While Redis Modules were mentioned, a more specific module like RedisJSON can be a powerful addition.
Example: Using RedisJSON Module
JSON.SET user:100 $ '{"name":"John","age":30}'
JSON.GET user:100 $.name
RedisJSON allows you to store and manipulate JSON documents in Redis.
6. Bitfield Operations
The BITFIELD command allows you to manipulate integers stored in bits in a string.
Example: Bitfield Usage
BITFIELD mybits SET u8 100 255
This sets an unsigned 8-bit integer at offset 100 to the value 255.
7. Scripting with Pipelining
While pipelining was covered, you can combine it with Lua scripting to optimize multiple commands in a single request.
Example: Atomic Update with Lua and Pipelining
EVAL "redis.call('SET', KEYS[1], ARGV[1]) redis.call('INCRBY', KEYS[2], ARGV[2])" 2 key1 key2 value1 10
8. RediSearch (Advanced)
If working with full-text search, RediSearch is a powerful Redis module.
Example: RediSearch Usage
FT.CREATE myIndex SCHEMA title TEXT WEIGHT 5.0 body TEXT
FT.ADD myIndex doc1 1.0 FIELDS title "Redis Modules" body "Search capabilities in Redis"
FT.SEARCH myIndex "Redis"
This allows full-text search in Redis using the RediSearch module.
9. Bloom Filters (Probabilistic Data Structures)
Redis has built-in support for Bloom filters via RedisBloom module.
Example: Using Bloom Filter
BF.ADD myBloom "foo"
BF.EXISTS myBloom "foo"
BF.EXISTS myBloom "bar"
Bloom filters provide space-efficient set-like functionality, with a small chance of false positives.
10. Redis Streams Advanced Features
While basic streams were covered, advanced stream features like trimming and acknowledging entries are also common.
Example: Trimming Streams
XADD mystream MAXLEN 1000 * name "Alice"
Automatically trims the stream to maintain at most 1000 entries.
Example: Acknowledging Entries in Consumer Group
XACK mystream group1 1526569495637-0
Acknowledge that a message has been processed by a consumer group.
Conclusion
This example covers almost all common Redis features, including basic CRUD operations, advanced data structures (hashes, lists, sets, sorted sets), pipelines, transactions, and specialized use cases (streams, geospatial data, and hyperloglog). It also touches on higher-level features like Lua scripting, clustering, replication, and Redis Sentinel for high availability.
Additionally, It mentions some more advanced use cases for Redis, including real-time analytics (bitfield, stream consumers), data modeling (RediSearch, RedisJSON), and optimization techniques (memory, keyspace notifications).
Redis is extremely versatile and this comprehensive example provides an overview of how it can be used across different scenarios.
If you found this helpful, let me know by leaving a 👍 or a comment!, or if you think this post could help someone, feel free to share it! Thank you very much! 😃
Read more about RESTful API with Redis
Top comments (0)