redis-strings

精通 Redis 字符串 - SET、GET、INCR、DECR、原子计数器、二进制安全操作和缓存模式

📖 中文导读:精通 Redis 字符串 - SET、GET、INCR、DECR、原子计数器、二进制安全操作和缓存模式 以下正文为该技能的原始 SKILL.md 内容(英文),上方安装命令可直接使用。

name: redis-strings description: Master Redis Strings - SET, GET, INCR, DECR, atomic counters, binary-safe operations, and caching patterns sasmp_version: "1.3.0" bonded_agent: 02-redis-data-structures bond_type: PRIMARY_BOND

Production Configuration

version: "2.1.0" last_updated: "2025-01"

Parameters

parameters: key: type: string required: true pattern: "^[a-zA-Z0-9:_-]+$" max_length: 512 value: type: string required: true max_size: "512MB" ttl_seconds: type: integer required: false min: 1 max: 31536000 nx_xx: type: string required: false enum: [NX, XX] description: "NX=only if not exists, XX=only if exists"

Retry Configuration

retry_config: max_retries: 3 backoff_strategy: exponential backoff_base_ms: 100 retryable_errors: - connection_timeout - BUSY

Observability

observability: logging: level: debug include_key_pattern: true metrics: - operation_latency_ms - cache_hit_ratio - key_size_bytes

Validation Rules

validation: key_naming: pattern: "object:id:field" examples: ["user:123:profile", "cache:api:users"] value_limits: warn_size_kb: 100 max_size_kb: 10240


Redis Strings Skill

Overview

Production-grade String operations for Redis. Master atomic counters, caching patterns, and binary-safe string manipulation.

Core Commands

Basic Operations

SET key value [EX seconds] [PX milliseconds] [NX|XX] [KEEPTTL]
GET key
GETEX key [EX seconds|PX ms|EXAT ts|PXAT ts|PERSIST]  # Get + set TTL
DEL key [key ...]
EXISTS key [key ...]

Atomic Counters

INCR key                      # +1 (creates if missing, starts at 0)
DECR key                      # -1
INCRBY key increment          # +N
DECRBY key decrement          # -N
INCRBYFLOAT key increment     # Float increment

String Manipulation

APPEND key value              # Append to value
STRLEN key                    # Get length
GETRANGE key start end        # Substring (0-indexed, inclusive)
SETRANGE key offset value     # Replace from offset

Batch Operations

MSET key value [key value ...]      # Set multiple
MGET key [key ...]                  # Get multiple
MSETNX key value [key value ...]    # Set multiple if none exist

Advanced Options (Redis 6.2+)

SET key value GET                   # Set and return old value
SET key value IFEQ oldvalue         # Set if current equals (Redis 7.4+)
GETDEL key                          # Get and delete
SETEX key seconds value             # Set with TTL (deprecated, use SET EX)

Production Patterns

Pattern 1: Cache with TTL

# Set with 1-hour TTL
SET cache:user:123 '{"name":"John","email":"john@example.com"}' EX 3600

# Get (returns nil if expired)
GET cache:user:123

# Refresh TTL on access
GETEX cache:user:123 EX 3600

Pattern 2: Rate Limiter (Fixed Window)

# Increment counter, set TTL on first request
INCR ratelimit:user:123:minute
EXPIRE ratelimit:user:123:minute 60 NX

# Check count
GET ratelimit:user:123:minute

Pattern 3: Distributed Lock

# Acquire lock (NX = only if not exists)
SET lock:resource:123 "holder-uuid" NX EX 30

# Release lock (only if we own it) - use Lua
EVAL "if redis.call('get',KEYS[1])==ARGV[1] then return redis.call('del',KEYS[1]) else return 0 end" 1 lock:resource:123 "holder-uuid"

Pattern 4: Session Storage

# Create session
SET session:abc123 '{"user_id":1,"created":1704067200}' EX 86400

# Touch session (reset TTL)
GETEX session:abc123 EX 86400

# Invalidate session
DEL session:abc123

Command Complexity

Command Complexity Notes
SET/GET O(1) Constant time
MSET/MGET O(N) N = number of keys
INCR/DECR O(1) Atomic
APPEND O(1) Amortized
GETRANGE O(N) N = returned length
STRLEN O(1) Stored metadata

Assets

  • rate-limiter.lua - Atomic rate limiting script
  • config.yaml - Pattern configuration

Scripts

  • string-benchmark.sh - Performance testing script
  • helper.py - Python utilities

References

  • STRING_PATTERNS.md - Common patterns guide
  • GUIDE.md - Complete reference

Troubleshooting Guide

Common Issues & Solutions

1. WRONGTYPE Error

WRONGTYPE Operation against a key holding the wrong kind of value

Cause: Trying string operation on non-string key

Diagnosis:

TYPE mykey  # Check actual type

Prevention:

  • Use consistent key naming conventions
  • Check type before operations in scripts

2. Value Too Large

string exceeds maximum allowed size (512MB)

Fix:

  • Compress data before storing
  • Split into multiple keys
  • Use appropriate data structure (Hash for objects)

3. INCR on Non-Integer

ERR value is not an integer or out of range

Cause: INCR/DECR on string that isn't a valid integer

Fix:

# Check current value
GET counter

# Reset if corrupted
SET counter 0

4. NX/XX Not Working as Expected

# NX only sets if key doesn't exist
SET key value NX  # Returns nil if key exists

# XX only sets if key exists
SET key value XX  # Returns nil if key missing

Debug Checklist

□ Key exists? (EXISTS key)
□ Correct type? (TYPE key)
□ Value is valid integer for INCR? (GET key)
□ TTL set correctly? (TTL key)
□ Key pattern consistent?
□ Value size reasonable?

Performance Considerations

Scenario Issue Solution
Large values High latency Compress or split
Many small keys Memory overhead Use Hash for related data
No TTL on cache Memory leak Always set TTL
MGET 1000+ keys Blocking Batch into smaller chunks

Error Codes Reference

Code Name Description Recovery
S001 WRONGTYPE Type mismatch Check TYPE, fix key
S002 OVERFLOW Integer overflow Use INCRBYFLOAT or reset
S003 NAN Not a number Validate before INCR
S004 TOOLARGE Value > 512MB Compress or split
S005 SYNTAX Invalid command Check syntax

Test Template

# test_redis_strings.py
import redis
import pytest

@pytest.fixture
def r():
    return redis.Redis(decode_responses=True)

def test_set_get(r):
    r.set("test:string:1", "hello")
    assert r.get("test:string:1") == "hello"
    r.delete("test:string:1")

def test_incr(r):
    r.set("test:counter", "10")
    r.incr("test:counter")
    assert r.get("test:counter") == "11"
    r.delete("test:counter")

def test_set_nx(r):
    r.delete("test:nx")
    assert r.set("test:nx", "first", nx=True) == True
    assert r.set("test:nx", "second", nx=True) == None
    r.delete("test:nx")

def test_ttl(r):
    r.set("test:ttl", "value", ex=60)
    ttl = r.ttl("test:ttl")
    assert 55 < ttl <= 60
    r.delete("test:ttl")