This article offers a comprehensive 2026 overview of Redis commands, organized by function, with clear usage examples, return values, performance notes, and best‑practice recommendations such as avoiding KEYS in production and using SCAN, making it a practical reference for developers and architects.
This article provides a detailed walkthrough of the 15 most commonly used Redis commands—including key, hash, list, set, sorted‑set, and monitoring operations—showing syntax, return values, typical use cases, performance characteristics, and cautions for production environments.
Airbnb completely rewrote its internal key‑value store Mussel, moving from a legacy V1 system to a cloud‑native, NewSQL‑backed V2 that reduces operational complexity, improves scalability, adds flexible consistency, and supports massive batch imports, all while achieving zero‑downtime migration of over 1 PB of data.
DragonflyDB, a Redis‑compatible high‑performance KV store, delivers up to 25× the throughput of Redis while using 15‑30% less memory, and can be integrated into Spring Boot projects with zero code changes, offering faster latency, better resource utilization, and seamless migration.
Rudis v0.2.0 introduces a major architecture overhaul, upgraded Tokio runtime, shared‑nothing threading, master‑slave replication, transaction support, and a refactored KEYS command that boosts performance by up to 99.55% for large data sets.
This article provides a detailed walkthrough of Dragonboat's LogDB storage layer, covering its overall architecture, unified key‑value design, memory‑reuse mechanisms with IContext, the IKVStore abstraction, Pebble initialization, event‑driven busy detection, and the sharded DB implementation, all illustrated with code snippets and diagrams.
This article explains how overusing RocksDB's DeleteRange for bulk file deletions can cause severe get latency spikes and uncontrolled memory growth, analyzes the underlying range tombstone mechanisms, and shares a practical optimization that replaces DeleteRange with regular deletes.
This article explains the core concepts and architectures of distributed storage, covering file‑based systems like HDFS, object storage such as Ceph, block storage for high‑performance workloads, and key‑value stores like Redis and Cassandra, highlighting their use cases and design principles.
Valkey 8.0 introduces asynchronous IO threads, data prefetch, and memory access amortization (MAA), offloading many tasks from the main thread and dramatically increasing single‑node throughput to up to 1 million requests per second, while also improving memory utilization and overall system efficiency.
This tutorial demonstrates how to perform fundamental Redis operations—including setting, retrieving, and deleting keys, working with hashes, lists, and sorted sets—using Python's redis client and includes complete test code for each scenario.
Valkey, a Linux Foundation‑backed fork of Redis released under a BSD license, offers faster development, stronger community governance, and new performance and cloud‑native features, positioning it as a compelling alternative for modern workloads.
This article compares popular Java etcd client libraries, evaluates their features, performance, and suitability, and provides a hands‑on tutorial using jetcd with Maven dependencies, code examples for watching and reading keys, and discusses runtime considerations such as thread handling.
This article explains how Vitess was created to overcome MySQL leader‑follower replication limits at YouTube, detailing its sidecar VTTablet, stateless VTGate router, topology key‑value store, and scaling strategies that enable billions of users to be served reliably.
The Linux Foundation announced Valkey, a BSD‑licensed open‑source fork of Redis that continues development on Redis 7.2.4, gains backing from major cloud providers, and outlines a roadmap featuring enhanced clustering, multithreading, new commands, and vector search support.
The article explains RocksDB’s LSM‑based architecture, column‑family isolation, and snapshot features, and shows how Vivo’s VPUSH mapping service uses these capabilities to store billions of registerId‑to‑ClientId mappings with high‑concurrency, low‑cost, fault‑tolerant performance across multiple replicated servers.
The article explains RocksDB’s LSM‑based architecture, column‑family isolation, and snapshot features, and shows how Vivo’s VPUSH MappingTransformServer uses these capabilities with C++ code to store billions of registerId‑to‑ClientId mappings across multiple replicated servers for high‑concurrency, low‑latency, and fast service expansion.
This article explains Redis’s five core data object types—strings, lists, hashes, sets, and sorted sets—detailing their encoding schemes, underlying memory structures such as SDS, ziplist, linkedlist, hashtable, and skiplist, and how Redis optimizes storage and access performance.
This article introduces Redis as an open‑source, high‑performance in‑memory key‑value store, explains its rich data structures, underlying implementations, performance advantages, common use cases such as caching and messaging, and provides step‑by‑step installation and basic command examples for Ubuntu systems.
This article provides a comprehensive overview of Redis data types—including strings, hashes, lists, sets, sorted sets, streams, hyperloglog, geospatial indexes, bitmaps, and bitfields—detailing their structures, encoding mechanisms, application scenarios, and underlying implementation details with code examples.
The article introduces Deno KV, a globally replicated, strongly consistent key‑value database that runs locally with SQLite or in Deno Deploy with FoundationDB, highlights its simple yet powerful JavaScript‑centric API, atomic transactions, consistency models, and provides practical code examples for developers.
This article details Baidu Cloud's PegaDB—a Redis‑compatible, high‑capacity, low‑cost distributed KV store—covering its design choices, architecture, performance and replication optimizations, multi‑region active‑active support, native JSON model, community contributions, and future roadmap.
This article outlines the latest RocksDB release updates, including disabled checksum verification options, removed Lite and deprecated APIs, default shared library builds, new compression filter and MultiGetEntity APIs, and various bug fixes such as concurrency issues and async I/O error handling.
This article explains what etcd is, compares it with Zookeeper, describes its architecture and core components such as WAL, snapshots and boltdb, outlines its key features, and shows how it powers service registration, watch mechanisms, cluster monitoring and leader election in cloud‑native systems.
This article explains how Redis stores key‑value pairs, details the internal data structures such as dict, dictEntry and redisObject, and provides practical memory‑saving tricks—including key shortening, encoding choices, object sharing, bitmap usage, hash consolidation, fragmentation handling, and 32‑bit deployment—to dramatically reduce RAM consumption while maintaining performance.
This article explains what etcd is, its origins, core features such as simplicity, security, speed, and reliability, and details eight practical scenarios—including service discovery, messaging, load balancing, distributed coordination, locks, queues, monitoring, and leader election—showing why it often outperforms Zookeeper in cloud‑native environments.
This article introduces Pegasus, a distributed key‑value storage system, covering its background, architecture, data model, dual‑WAL design, performance benchmarks, recent features such as hot backup, bulk load, access control, partition split, as well as its surrounding ecosystem tools and open‑source community initiatives.
This article introduces LevelDB, a Google‑open‑source key‑value store, and illustrates four practical use cases—temporary token storage, hidden credential management, stateful Java services, and lightweight historical data archiving, accompanied by Groovy/Java code examples for implementation.
This article introduces Pegasus, a distributed key‑value store, covering its background, system architecture, double‑WAL design, performance benchmarks, recent features such as hot backup, bulk load, access control, partition split, as well as its ecosystem tools and community development plans.
This article explains the fundamentals of Log‑Structured Merge (LSM) Trees, covering their write‑ahead log, memtable, SSTable architecture, compaction processes, read/write optimizations, and popular open‑source implementations such as LevelDB, RocksDB, and GoLevelDB.
This article demonstrates how to encapsulate the native LevelDB Java API into a reusable class, adds support for integer values and Redis‑like operations such as increment, decrement, append, and cut, and provides complete code examples for the extended functionality.
This article introduces LevelDB, a Google‑built key/value store, and demonstrates how to integrate it in Java and Go projects by showing dependency setup, basic operations such as opening, putting, getting, deleting, iterating, and closing the database, and explains the typical use cases and file layout.
This whitepaper explains the definition and history of in‑memory databases, discusses their performance advantages and persistence challenges, outlines the technology’s maturity and bottlenecks, classifies key products, and provides technical and non‑technical criteria for selecting the most suitable solution for high‑concurrency, low‑latency workloads.
This whitepaper explains the concept, history, core attributes, typical industry use cases, major products, and selection guidelines for in‑memory databases, highlighting their performance advantages, technical challenges, and future trends driven by evolving memory technologies.
This article explains the fundamentals of LSM‑Tree storage engines, introduces SSTable concepts, describes how to build and maintain ordered log files, and provides a complete Java implementation of a tiny key‑value store with code examples and design analysis.
This article introduces Redis as a high‑performance, in‑memory key‑value database, explains its core features such as persistence, pub/sub, data structures, and atomic operations, and provides a comprehensive list of commands for keys, strings, hashes, lists, sets, and sorted sets.
This article walks through creating a lightweight Redis‑style key/value service called kedis by integrating Facebook's RocksDB storage engine and the RestExpress HTTP container, showing how to set up the server, define API routes, and perform basic put/get operations via HTTP requests.
This article compiles 40 common Redis interview questions and detailed answers, covering Redis fundamentals, data types, persistence mechanisms, performance characteristics, clustering, replication, memory optimization, eviction policies, and practical usage scenarios to help candidates confidently succeed in technical interviews.
This article explains what NoSQL means, contrasts it with SQL and relational databases, walks through schema design, primary keys, indexing, and then demonstrates how to implement a lightweight key‑value NoSQL store in pure Python with full command parsing and handling.
This article explains what NoSQL means, contrasts it with relational databases, and guides readers through building a simple Python key‑value NoSQL database, covering schema basics, querying, indexing, command parsing, and the trade‑offs between flexibility and query performance.
The article analyzes the massive storage and performance challenges of a real‑time DMP cache built on Redis, outlines data characteristics and technical obstacles, and proposes eviction policies, bucket‑based hashing, and fragmentation‑reduction techniques with Java code examples to achieve billion‑scale in‑memory key‑value storage.
This article introduces Redis as an open‑source, in‑memory data‑structure store, explains its role as a NoSQL database, details its five fundamental data types, common commands, expiration handling, pipelines, and transactions, and shows how it fits into modern scaling architectures.
This article introduces Redis's primary data structures—String, Hash, List, and Set—explaining their purpose, key commands, and practical usage examples, including batch operations, numeric adjustments, field management, list manipulation, and set operations, to help developers effectively work with the in‑memory database.
This article explains why Redis creates 16 default databases, how to configure their number, the proper way to view these databases as namespaces, and why multiple applications should use separate Redis instances, especially noting that Redis clusters support only a single db0.
This article introduces Redis's eight fundamental data types—String, List, Set, Hash, Sorted Set, Geospatial, HyperLogLog, and Bitmap—explaining their characteristics, typical use‑cases, and providing concrete command‑line examples that demonstrate creation, manipulation, and querying of each type.
This article demonstrates how to create a lightweight key/value store named kedis by integrating Facebook's RocksDB storage engine with the RestExpress HTTP container, providing step‑by‑step instructions, code examples for initializing the database, defining routes, and running the service via HTTP GET requests.
ByteKV is a C++-based, strongly consistent, range-partitioned key‑value storage system built by ByteDance, featuring a multi‑Raft consensus layer, custom storage engines (RocksDB and BlockDB), automatic partition splitting/merging, load balancing, distributed transactions, and a SQL table layer for rich data models.
Redis is a high‑performance, open‑source key‑value store offering persistence, rich data structures, replication, pub/sub, transactions, and clustering; this guide explains its fundamentals, data types (string, hash, list, set, sorted set), essential commands, and advanced features such as persistence options, replication, Sentinel, and sharding.
This article examines the limitations of traditional key‑value storage, explains Baidu’s high‑performance KV engine built on Open‑Channel SSDs, and shows how direct flash access dramatically reduces write and read amplification while improving bandwidth, space utilization, and overall QoS.
The article introduces HotRing, a hotspot‑aware in‑memory key‑value store from Alibaba's Tair team, explains the extreme traffic challenges of Alibaba's Double‑11 peak, details the design of ordered‑ring hashing, dynamic hotspot detection, lock‑free concurrency and rehashing, and shows how these innovations achieve up to 2.58× higher throughput than existing KV systems.
This article provides a comprehensive introduction to Redis, covering its key features, supported data structures, core commands, persistence mechanisms, replication, sentinel monitoring, sharding strategies, and transaction handling with practical code examples.
This guide introduces Redis as a high‑performance key‑value store, covering its core data structures, advantages, persistence mechanisms, publish/subscribe model, transaction handling, and replication strategies with practical command examples.
This article provides a comprehensive overview of Redis, covering its high‑performance key‑value architecture, persistence options, replication, sharding, data types such as strings, hashes, lists, sets and sorted sets, as well as advanced features like transactions, publish/subscribe, and Sentinel monitoring, all illustrated with practical command examples.
This article traces etcd’s evolution from its CoreOS origins, explains its Raft‑based distributed architecture, details its API groups, versioning and watch mechanisms, and showcases typical scenarios such as metadata storage, service discovery, leader election, and distributed coordination in cloud‑native environments.
This tutorial demonstrates how to use Facebook’s RocksDB storage engine together with the Netty‑based RestExpress HTTP container to create a lightweight Redis‑style key/value service called kedis, covering project setup, core API implementation, route configuration, building, launching, and basic curl interactions.
The article details the three‑stage evolution of 58.com’s distributed key‑value storage system WTable, covering its initial architecture, performance and operational optimizations, and the introduction of NewSQL‑style strong consistency and Raft‑based replication to improve scalability and reliability.
This article provides a comprehensive introduction to Redis, covering its high‑performance key‑value architecture, supported data structures (string, hash, list, set, sorted set), core commands, persistence mechanisms, replication, sentinel monitoring, sharding, pub/sub messaging and transaction handling, with practical command‑line examples.
FeatureKV is a high‑performance, scalable key‑value storage system built for WeChat's massive offline‑to‑online data pipelines, tackling challenges of 10⁹ reads per second and 10⁹ writes per hour with version management, efficient batch writes, and fault‑tolerant read services.
This article introduces Redis's fundamental and advanced data structures, explains how each is represented internally, and provides detailed examples of essential commands such as KEYS, EXISTS, DEL, EXPIRE, TTL, and TYPE, highlighting their usage, complexity, and best‑practice considerations.
FeatureKV is a high‑performance, scalable key‑value storage system built on WeChat’s internal file system and metadata service, designed to handle billion‑scale read and write demands, support batch offline writes, provide version management, and achieve low‑latency online reads for services like Look‑at‑Look, ads, and payments.
This article examines a distributed system concurrency problem, compares lock‑based transactions with multiversion concurrency control (MVCC), and explains why MVCC often outperforms pessimistic locking in scenarios demanding high read responsiveness and low contention.
This article explains how etcd stores and retrieves multiple revisions of a key using a B‑tree index, details the read and write paths, describes index restoration on startup, and shows how the watch subsystem delivers change events to clients, all illustrated with Go code snippets.
This article explains the inner workings of etcd, covering its Raft consensus implementation, node election and state management, as well as the persistent storage layer built on BoltDB, and includes detailed code excerpts to illustrate each component.
This article provides a comprehensive introduction to Redis, covering its core concepts, advantages, data structures, persistence mechanisms, eviction policies, clustering, common usage scenarios, and typical interview questions for developers working with this high‑performance in‑memory key‑value store.
Pika 3.0, a C++ open‑source Redis‑compatible storage built on RocksDB, introduces a new blackwidow engine, an improved binlog system, and a more efficient server layer, delivering higher performance, reduced disk usage, extended key length limits, and full Redis ZSET compatibility.
This article provides a comprehensive overview of Redis as a high‑performance, in‑memory key‑value store, explaining its data structures, persistence options, replication, benchmark results, and a wide range of real‑world scenarios where Redis excels over traditional databases.
This article explains what native multi‑model databases are, why they are needed, how they combine document, key‑value and graph models, and demonstrates their advantages through an aircraft maintenance management case study with concrete AQL queries.
This comprehensive guide explains what Redis is, its advantages over memcached, supported data structures, eviction policies, clustering options, persistence mechanisms, memory optimization techniques, and practical use‑cases such as caching, queues, leaderboards, and pub/sub, providing essential knowledge for developers and architects.
This article introduces Redis as a key‑value caching system, compares it with MongoDB and Memcache, explains installation, shows how to use the redis‑py Python client—including direct connections, connection pools, and basic data‑type operations—and provides code examples for setting and retrieving values.
This guide introduces Redis as an advanced key‑value store, explains how to start the server and use its CLI tools, and provides detailed command references and demos for strings, lists, sets, sorted sets, hashes, transactions, replication, and pub/sub.
This article explains the concept of NoSQL, contrasts it with traditional SQL databases, and walks you through building a minimal key‑value NoSQL server in pure Python, covering schema basics, indexing, message parsing, command handling, and practical code examples.
This article explains why Xiaomi built Pegasus to replace HBase, describes its architecture—including MetaServer, ReplicaServer, partitioning, multi‑replica design and the PacificA consensus algorithm—covers implementation challenges such as load balancing, consistency, latency, testing, and outlines current status and future plans.
LevelDB, Google's high-performance key‑value store built on LSM trees, uses an in‑memory skip‑list, immutable memtables, and sstable files organized in multi‑level compaction, offering interfaces for creation, reads, writes, snapshots, and new features like fuzzy search and JSON storage, all explained with diagrams.
This article walks through the concepts behind NoSQL databases, contrasts them with traditional SQL relational models, and provides a step‑by‑step Python implementation of a minimalist key‑value store, complete with command parsing, TCP/IP messaging, and code examples.
This article explains how big data challenges traditional storage, introduces HDFS for distributed file management, describes parallel processing frameworks like MapReduce, Tez, and Spark, compares higher‑level tools such as Hive and Pig, and explores real‑time streaming and key‑value stores for low‑latency analytics.
Pika, developed by 360’s Web Platform and DBA teams, is a Redis‑compatible, disk‑based key‑value store that addresses Redis’s high memory cost and scalability limits by offering persistent storage, multi‑threading, compression, and easy migration tools, making large‑capacity data handling cheaper and more reliable for enterprises.
This article explains what NoSQL means, compares it with traditional SQL databases, and walks through creating a lightweight Python key‑value store with TCP/IP commands, illustrating schema design, indexing, query examples, and the full source code for a toy NoSQL system.
This article provides a comprehensive overview of RocksDB, covering its origin, design goals, core architecture components, key features such as APIs, compression strategies, durability mechanisms, backup and replication support, as well as tooling, testing, and performance characteristics.
Redis is an open-source, in‑memory data structure store offering high‑performance caching, persistence, replication, and rich data types such as strings, lists, sets, hashes, and sorted sets, and this guide compares its strengths and differences with Memcached and other databases.
JIMDB is JD’s in‑house distributed cache platform that combines automatic fault detection, seamless online scaling, multi‑language support, and containerized deployment to replace traditional Memcached/Redis solutions, offering features such as one‑click cluster creation, elastic expansion, lossless scaling, and comprehensive monitoring for high‑traffic e‑commerce services.
This article analyzes Etcd's distributed architecture, Raft‑based consistency, storage implementation, watch and lease mechanisms, differences between v2 and v3, and compares it with Zookeeper and Consul, providing practical usage tips and surrounding tooling for developers of distributed systems.
This talk walks through the evolution of databases, explains the challenges of building a distributed key‑value system that provides full ACID properties, and details the architectural components, sharding, migration, snapshot isolation, two‑phase commit, timestamp handling, and distributed transaction processing techniques.
This article introduces etcd, a highly‑available key‑value store based on the Raft algorithm, and explores its classic use cases such as service discovery, messaging, load balancing, distributed coordination, locks, queues, monitoring, leader election, and compares it with ZooKeeper, highlighting its simplicity, security, and cloud‑native advantages.
This article explains the Bitcask key‑value storage model, covering its log‑structured file design, in‑memory hash index, handling of deletions and updates, periodic merge operations, and the use of hint files to speed up hash index reconstruction.
The article explains Amazon’s Dynamo distributed key‑value store architecture, covering its decentralized design, consistent hashing with virtual nodes, replication strategies, quorum‑based read/write parameters, vector‑clock versioning, failure detection, hinted handoff, scaling mechanisms, and how these techniques together provide high availability, scalability, and reliability.
LevelDB, created by Google Fellows Jeff Dean and Sanjay Ghemawat, is a high‑performance C++ key‑value library that provides persistent, ordered storage with snapshots, compression, and atomic batch operations, achieving up to 400,000 random writes and 60,000 random reads per second.
This article explains four fundamental database data models—key‑value pair, document, column, and graph—detailing their structures, scalability characteristics, and typical implementations such as Redis, MongoDB, HBase, and Neo4j.
This article details the evolution and redesign of JD.com’s product detail page architecture, describing the transition from static HTML generation to a dynamic, high‑performance, multi‑datacenter system built on key‑value storage, Nginx + Lua, asynchronous processing, multi‑level caching, and robust scaling and reliability strategies.
This interview with JD’s distributed cache and NoSQL lead reveals how JimDB evolved from a Redis‑based engine to a two‑tier SSD‑optimized key‑value store, detailing fault‑tolerant design, online migration, scaling strategies, and the shifting role of DBAs in massive e‑commerce traffic.
The article introduces SessionDB, a Java‑implemented, LSM‑tree‑based key/value storage engine designed to eliminate sticky sessions by providing high‑throughput, durable, and scalable session data handling, and details its architecture, optimizations, sharding strategy, and benchmark comparisons with BerkeleyDB, LevelDB, and RocksDB.
