Redis Database Block

What is Redis?

Redis is like a super-fast digital notebook that keeps your data in memory for lightning-quick access. Unlike traditional databases that save everything to disk, Redis keeps data in RAM, making it perfect for caching, session storage, and real-time applications.

When to Use Redis

✅ Perfect for:

Caching frequently accessed data
Storing user sessions and temporary data
Real-time analytics and counters
Message queues and pub/sub systems
Rate limiting and throttling
Temporary data that expires automatically

❌ Not ideal for:

Long-term data storage (use PostgreSQL/MongoDB)
Complex relationships between data
Large files or documents
Data that must never be lost

How It Works

Connect to Redis: Provide your Redis server details
Choose Operation: Set, get, delete, or manage data
Work with Keys: Redis stores everything as key-value pairs
Set Expiration: Optionally make data expire after a certain time

Real-World Examples

🚀 API Response Caching

HTTP Request → Check Redis Cache → If Found: Return Cached Data → If Not: Call API → Cache Result

Cache API responses for 5 minutes to speed up your app and reduce API calls

👤 User Session Management

User Login → Store Session in Redis → User Requests → Validate Session → Auto-Expire After 1 Hour

Keep track of logged-in users with automatic session expiration

📊 Real-Time Counters

User Action → Increment Redis Counter → Check Current Count → If Threshold Reached → Trigger Action

Count website visits, downloads, or user actions in real-time

🔒 Rate Limiting

API Request → Check Redis Rate Limit → If Under Limit: Process → If Over Limit: Block Request

Prevent users from making too many requests too quickly

Easy Setup Guide

🔌 Step 1: Connect to Redis

Connection Information Needed:

Host: Your Redis server address (like localhost or redis.example.com)
Port: Usually 6379 (Redis default port)
Password: If your Redis server has authentication
Database: Redis database number (0-15, usually 0)

⚙️ Step 2: Choose Your Operation

SET - Store Data:

Key: "user_session_{{user_id}}"
Value: "{{session_data}}"
Expiration: 3600 seconds (1 hour)

GET - Retrieve Data:

Key: "user_session_{{user_id}}"
// Returns the stored session data

DELETE - Remove Data:

Key: "user_session_{{user_id}}"
// Removes the session completely

EXISTS - Check if Key Exists:

Key: "user_session_{{user_id}}"
// Returns true if key exists, false if not

Common Operations

📝 String Operations

Store Simple Values:

// Store user preference
SET("user_theme_{{user_id}}", "dark_mode")
 
// Store counter value
SET("page_views", "1250")
 
// Store JSON data
SET("user_profile_{{user_id}}", JSON.stringify({
  name: "John Doe",
  email: "john@example.com"
}))

🕐 Working with Expiration

Set Data That Expires:

// Cache API response for 5 minutes
SET("weather_{{city}}", "{{weather_data}}", 300)
 
// Store verification code for 10 minutes  
SET("verify_code_{{email}}", "{{code}}", 600)
 
// Session that expires in 1 hour
SET("session_{{user_id}}", "{{session_token}}", 3600)

🔢 Counter Operations

Increment/Decrement Counters:

// Count website visits
INCR("total_visits")
 
// Count user actions
INCR("user_actions_{{user_id}}")
 
// Decrease inventory
DECR("inventory_{{product_id}}")
 
// Add specific amount
INCRBY("points_{{user_id}}", 100)

📋 List Operations

Manage Lists of Data:

// Add to beginning of list
LPUSH("recent_orders", "{{order_id}}")
 
// Add to end of list
RPUSH("user_activities_{{user_id}}", "{{activity}}")
 
// Get list items
LRANGE("recent_orders", 0, 9)  // Get first 10 items

🗂️ Hash Operations

Store Related Data Together:

// Store user data as hash
HSET("user_{{user_id}}", {
  "name": "{{user_name}}",
  "email": "{{user_email}}",
  "last_login": "{{current_time}}"
})
 
// Get specific field
HGET("user_{{user_id}}", "email")
 
// Get all fields
HGETALL("user_{{user_id}}")

Working with Workflow Data

💾 Caching Database Queries

// Try Redis first, then database
Cache_Key = "products_category_{{category}}"
 
1. GET from Redis → If exists: Use cached data
2. If not found → Query database → Cache result for 10 minutes
3. Return data to workflow

🔐 Session Management

// Login workflow
1. User logs in successfully
2. Generate session token
3. SET("session_{{user_id}}", "{{token}}", 7200)  // 2 hours
4. Return token to user
 
// Validate session workflow  
1. User makes request with token
2. GET("session_{{user_id}}")
3. If exists and matches: Allow access
4. If not: Redirect to login

📈 Analytics and Tracking

// Page view tracking
1. User visits page
2. INCR("page_views_{{page_name}}")
3. INCR("daily_views_{{today_date}}")
4. INCRBY("user_page_views_{{user_id}}", 1)

Best Practices

⚡ For Performance

Use Appropriate Data Types: Choose the right Redis data type for your use case
Set Expiration Times: Always set TTL for temporary data
Use Short Keys: Shorter key names use less memory
Batch Operations: Group multiple operations when possible

🔒 For Reliability

Handle Missing Keys: Always check if keys exist before using them
Use Connection Pooling: Reuse connections for better performance
Monitor Memory Usage: Redis stores everything in memory
Have Fallback Plans: What happens if Redis is unavailable?

🎯 For Data Management

Consistent Key Naming: Use patterns like user_session_{{id}}
Appropriate Expiration: Don't keep temporary data forever
Clean Up Old Data: Remove unused keys to free memory
Use Namespacing: Group related keys with prefixes

Common Use Cases

🏪 E-commerce Shopping Cart

// Add item to cart
HSET("cart_{{user_id}}", "{{product_id}}", "{{quantity}}")
 
// Get cart contents  
HGETALL("cart_{{user_id}}")
 
// Remove item
HDEL("cart_{{user_id}}", "{{product_id}}")
 
// Clear cart after purchase
DEL("cart_{{user_id}}")

🎮 Gaming Leaderboard

// Update player score
ZADD("leaderboard", "{{score}}", "{{player_id}}")
 
// Get top 10 players
ZREVRANGE("leaderboard", 0, 9, "WITHSCORES")
 
// Get player rank
ZREVRANK("leaderboard", "{{player_id}}")

📊 Real-Time Analytics

// Track events
INCR("events_{{event_type}}_{{today}}")
LPUSH("recent_events", JSON.stringify({
  type: "{{event_type}}",
  timestamp: "{{now}}",
  user: "{{user_id}}"
}))
 
// Get hourly stats
MGET("events_signup_{{hour1}}", "events_signup_{{hour2}}")

Troubleshooting

❌ Connection Issues

Can't Connect to Redis:

Check host and port settings
Verify Redis server is running
Test firewall and network connectivity
Confirm authentication credentials

🔧 Common Problems

Key Not Found:

Key might have expired (check TTL)
Key name might be incorrect (case-sensitive)
Data might not have been saved properly

Memory Issues:

Check Redis memory usage
Set expiration times on temporary data
Clean up old, unused keys
Consider using Redis clustering for large datasets

Performance Problems:

Use appropriate data types for your use case
Avoid very long key names
Use pipelining for multiple operations
Monitor slow query logs

Node Display

The Redis block shows:

Operation Type: SET, GET, DELETE, etc.
Key Pattern: The Redis key being accessed
Connection Status: Connected, error, or disconnected
Expiration: TTL settings if applicable
Data Size: Amount of data stored/retrieved

Ready to supercharge your workflows with lightning-fast data access? Connect to Redis and start caching your way to better performance!

SQLite Firebase