This article presents a step‑by‑step design of HermesMQ, an industrial‑grade message queue built from scratch to support ten‑million‑order traffic, covering storage as sequential logs, network architecture with Netty and Reactor, high‑availability replication, partition ordering, transaction messaging, back‑pressure, observability, and practical deployment guidelines.
This article walks through every stage a MySQL statement undergoes—from client connection, authentication, and (now‑removed) query cache, through parsing, optimization, execution, and storage‑engine access—highlighting the roles of InnoDB vs MyISAM, logging mechanisms, and best‑practice table design tips.
The article explains Lance's stable_id (stable row ID) and address_id concepts, why stable IDs are needed, how they are encoded and mapped via RowIdIndex, the trade‑offs of this design, how to enable them, and how to convert between row address and stable ID.
The article dissects Milvus 3.0's storage overhaul, explaining why the legacy per‑column binlog layout (V1) and the packed Parquet format (V2) were replaced by the Loon manifest table (V3), and how this redesign enables external collections, zero‑copy Spark reads, and efficient TEXT LOB handling.
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.
This article compares InnoDB and MyISAM across transaction support, MVCC, storage structures, indexing, caching, and typical use cases, explains why InnoDB became the default engine in MySQL 5.5+, and provides concrete migration steps and performance‑tuning guidance.
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 delves into the hierarchical logical architecture of MySQL’s InnoDB storage engine, detailing how table spaces, segments, extents, pages, and rows are organized, their functions, configuration options, and how they together enable efficient data storage, access, and transaction management.
This article compares MySQL's InnoDB and MyISAM storage engines across dimensions such as transaction support, locking, file structure, indexing, full‑text search, and COUNT(*) performance, helping developers choose the appropriate engine based on workload and consistency requirements.
This guide compiles essential MySQL interview questions covering storage engines, indexes, transactions, locks, and triggers, providing clear explanations and illustrations for both beginners and experienced candidates seeking to excel in database interviews.
This comprehensive guide explains MySQL storage engine concepts, compares built‑in engines like InnoDB and MyISAM, details how to view and configure engines, and covers transaction fundamentals, isolation levels, locking mechanisms, and practical migration case studies for reliable database operations.
This article details the design and evolution of DHPS, Kuaishou's load‑balanced, RDMA‑based high‑performance service architecture, explaining its network, storage, and traffic‑scheduling innovations that deliver over 270% query‑throughput improvement, lower latency, reduced CPU usage, and near‑five‑nine availability for large‑scale AI inference workloads.
This article compares MySQL's three common storage engines—InnoDB, MyISAM, and Memory—by examining their core features, locking mechanisms, transaction support, durability, foreign‑key capabilities, typical use cases, and provides concrete CREATE TABLE examples and a side‑by‑side feature matrix to help developers choose the right engine.
This article objectively compares middleware‑based sharding with NewSQL distributed databases, examining their architectures, transaction support, CAP implications, high‑availability, scaling, storage engines, and ecosystem maturity to help readers decide which solution best fits their workload.
This article details Tencent Cloud's TDSQL‑C, a cloud‑native relational database that combines traditional MySQL compatibility with a storage‑compute separated architecture, global multi‑region replication, advanced log handling, and continuous performance upgrades to deliver ultra‑high throughput, massive storage, and strong data reliability.
The article explains why using DELETE to remove rows in MySQL is discouraged, covering storage architecture, engine behavior, transaction handling, space reclamation, and compares DELETE with TRUNCATE and DROP in terms of speed, safety, and side effects.
This article explains where MySQL stores its data on disk, how the InnoDB engine organizes files, pages, extents, segments, and rows, and details the Compact, Dynamic, and Compressed row formats, including null‑value handling and overflow mechanisms.
The article walks through a complete Zig implementation of an LSM‑Tree, detailing its in‑memory skip‑list MemTable, immutable SSTable blocks with compression and Bloom filters, write‑ahead logging, iterator hierarchy for reads, and multi‑level compaction logic that merges and rewrites SSTables.
This article explains MySQL's storage engine architecture, compares built‑in engines such as InnoDB and MyISAM, details their file system interactions, table‑space types, and transaction features—including ACID properties, isolation levels, locking mechanisms, and practical migration steps for production environments.
This article explains MySQL’s logical architecture, details the storage‑engine API and its key components such as connectors, parsers, optimizer, caches, and file system interaction, and provides step‑by‑step guidance on creating, opening, locking, scanning tables and building a custom storage engine.
This article explains how MySQL 8.0.32 InnoDB generates and stores Insert Undo logs, detailing their binary format, field meanings, example values, and how the hidden DB_ROLL_PTR field encodes the log address, with accompanying SQL and shell examples.
This article walks through building a database storage engine from a simple shell script to a full distributed key‑value system, covering in‑memory indexing, SSTable creation, LSM‑Tree architecture with compaction, replication strategies, and sharding techniques for scaling across multiple machines.
RocksDB, an open‑source key‑value storage engine created by Facebook in 2012, delivers high performance, durability, and tunable configurations for flash and SSDs; the article details its core features, internal components such as MemTable and Bloom filters, and real‑world uses in TiDB and Apache Flink.
This article explains MySQL storage engine concepts, compares InnoDB, MyISAM, and MEMORY, describes how data is stored in shared tablespace versus file‑per‑table modes, and provides configuration commands for switching modes, changing default engines, and inspecting or altering a table’s engine.
The article compares MySQL and MariaDB, tracing MySQL’s historic rise, explaining why MariaDB was forked, detailing their governance, enumerating MariaDB’s additional storage engines and performance optimizations, highlighting new features, and analyzing recent adoption trends that suggest MariaDB may eventually overtake MySQL.
MySQL’s pluggable storage‑engine architecture lets each table use a specific engine, with InnoDB (the default in MySQL 8.x) offering row‑level locking, ACID transactions, foreign‑key support, crash recovery, MVCC and a buffer pool, while MyISAM provides only table‑level locking, no transactions, and is suited mainly for read‑intensive workloads lacking recovery requirements.
This article provides a comprehensive overview of Apache Doris, explaining its frontend and backend nodes, storage structures such as tablets, rowsets, and segments, replication mechanisms, partitioning versus bucketing, indexing types, compaction processes, and high‑availability strategies through a detailed Q&A format.
This curated bibliography compiles seminal database‑system papers—spanning foundational relational theory, system design for RDBMS and NoSQL, SQL engine optimization, storage structures, transaction and scheduling mechanisms, plus workload, networking, quality, and tuning research—each entry listing title, authors, year and a PDF link for scholars and practitioners.
StarRocks 3.3 introduces a comprehensive set of enhancements—including maturity levels, ARM‑optimized performance, advanced caching, materialized‑view rewrites, storage optimizations, and expanded lakehouse ecosystem support—that together boost stability, query speed, and usability for large‑scale analytics workloads.
An exclusive interview with Baidu’s senior database architects reveals the motivations behind building a dedicated enterprise vector database, details its novel column‑store engine, C++‑based retrieval stack, performance gains over open‑source solutions, multi‑modal support, RAG integration, and future research directions.
The article explains the release of MySQL 8.4 as the first LTS version, compares LTS and Innovation release tracks, and details the 20 InnoDB system variables whose default values have been changed to better suit modern production environments, including performance‑related settings and hardware‑aware defaults.
This article explains MySQL’s logical architecture, details the pluggable storage‑engine API, lists the default engines, and provides step‑by‑step guidance with code examples on how to create a custom MySQL storage engine.
This article provides a comprehensive overview of MatrixOne's hyper‑converged cloud‑native database architecture, detailing its three‑layer design, data execution flow, columnar storage format, metadata hierarchy, performance optimizations, compatibility mechanisms, and practical usage scenarios.
This article outlines ten essential MySQL table design best practices, covering requirement analysis, data type selection, normalization, indexing, keys, character sets, storage engines, partitioning, backup, and performance monitoring to improve scalability, maintainability, and efficiency.
This article introduces the open‑source distributed database MatrixOne, tracing its early NewSQL/MPP architecture, the challenges that prompted a major redesign, and the resulting HTAP‑oriented three‑layer architecture with decoupled compute, transaction, and storage layers, highlighting performance, cost, and scalability improvements.
This article walks through building a simple yet enterprise‑grade key‑value storage engine in Go, covering WAL implementation, LSM‑Tree structure, SkipList‑based in‑memory storage, transaction handling for Put/Get/Delete, and the on‑disk log format, with a complete 1,000‑line codebase hosted on GitHub.
This article explains how MySQL establishes connections, the supported communication protocols and message formats, the lexical and syntactic parsing process, query optimization and execution plan generation, the role of different storage engines, and how the execution engine uses the plan to operate on the storage layer.
This article introduces Shen Jiangwei, a MatrixOne storage engine engineer, and outlines his presentation on the design of MatrixOne's storage format, covering its motivation, data structures, performance and compatibility guarantees, and the system's cloud‑native OLTP/OLAP/Streaming capabilities.
This article explains how InnoDB stores data on disk, describing tablespaces, segments, extents, pages, row formats, record headers, page directories, B+‑tree indexes, and the differences between clustered and secondary indexes, with examples and diagrams to illustrate each component.
This article explains how MariaDB evolved from a MySQL branch into a comprehensive database ecosystem, covering the Community and Enterprise servers, diverse storage engines, MaxScale proxy, ColumnStore analytics, Xpand distributed scaling, and the SkySQL fully managed cloud service.
This article explains the architecture and key components of distributed analytical databases, contrasting them with MPP systems, and details the design of StarRing’s ArgoDB—including its storage, compute, transaction, and SQL engines—highlighting scalability, elasticity, and resource management for modern data warehousing.
This article explains the internal storage layout, on‑disk and in‑memory data structures, and the query execution flow of Prometheus V2, illustrating how blocks, chunks, WAL, indexes and postings are organized and accessed to serve time‑series queries efficiently.
This article provides an in‑depth analysis of Prometheus V2's storage architecture, detailing the on‑disk block layout, chunk and index formats, the inverted index structure, memory representations, and the step‑by‑step query process that locates matching time‑series data.
This article explains why ClickHouse delivers high query speed by detailing storage‑engine optimizations such as pre‑sorting, columnar layout and compression, and compute‑engine techniques like vectorized execution, built‑in functions and minimal join usage, while also promoting the related book and giveaway.
The article explains MySQL InnoDB’s internal storage hierarchy—from tablespaces, segments, and extents to pages and rows—its physical components such as buffer pool, change buffer, adaptive hash index, redo and binary logs, persistence techniques like double‑write buffering and log‑flushing policies, and how two‑phase commit and SQL execution interact, helping developers write correct, high‑performance applications.
This article explains MySQL's client‑server architecture and walks through the three main stages—connection handling, query parsing and optimization, and storage engine selection—detailing protocols, authentication, cache behavior, optimizer mechanics, and engine characteristics with practical commands and examples.
TiDB is an open‑source, MySQL‑compatible distributed database that unifies OLTP and OLAP by using a stateless SQL layer, a Placement Driver for metadata and Raft‑managed TiKV/TiFlash storage, key‑value mapping with RocksDB, and a push‑down execution engine that splits work between coprocessor and root tasks for scalable, highly available workloads.
This article explains MySQL’s three‑tier logical architecture—from client services to core query processing and storage engines—and details the four ANSI SQL transaction isolation levels, highlighting their behavior, advantages, and trade‑offs in MySQL.
This article explains the motivation, design, and implementation of vectorizing Apache Doris's storage layer using SIMD techniques, covering engine overview, vectorized programming concepts, storage architecture, index and predicate optimizations, delayed materialization, output improvements, and performance test results.
LSM‑Tree stores writes in an in‑memory MemTable then flushes ordered SSTables to disk, using Bloom filters and indexes to speed reads, while periodic compactions merge files; modern systems such as LevelDB, HBase, and ClickHouse adopt this design to achieve high write throughput despite slower point and range queries and occasional compaction overhead.
This article provides a systematic deep‑dive into MySQL table‑lock mechanics, comparing storage engines, explaining the advantages of table locks, detailing lock acquisition and release rules, showing how to monitor lock statistics, and revealing why MyISAM can deliver superior performance for heavy concurrent insert and select workloads despite using only table‑level locking.
This article explains MySQL InnoDB's tablespace architecture—including segments, extents, pages, and rows—and details how clustered and secondary indexes are implemented using B+ trees, comparing them with other tree structures to illustrate why B+ trees are optimal for disk‑based databases.
The article provides a comprehensive guide to relational database design using MySQL, covering ER modeling, normalization (BCNF and 3NF), storage engine selection, character set and data type choices, as well as index design principles illustrated with a student course selection example.
This article explains the fundamentals of relational database design, covering E‑R modeling with a student‑course example, normalization through BCNF and 3NF, selection of MySQL storage engines, character set and data type choices, and best practices for index design.
This article explains relational database design using MySQL, covering ER modeling, BCNF and 3NF normalization, storage engine and charset choices, data type selection, and index design, illustrated with examples and practical guidelines for building a student course selection system.
This article explains MySQL’s core architecture, detailing components such as connection pools, SQL interface, optimizer, and storage engine plugins, then compares MyISAM and InnoDB, and dives deep into InnoDB’s memory structures, buffer pool, adaptive hash index, tablespaces, and redo log mechanisms.
This article explains the two kinds of MySQL temporary tables—external and internal—covers the scenarios that trigger their creation, details how MySQL chooses MEMORY, MyISAM or InnoDB storage engines based on system variables and data size, and describes indexing, hash‑field fallbacks, and optimization hints such as SQL_SMALL_RESULT and SQL_BIG_RESULT.
This article explains InnoDB’s role as a MySQL storage engine, how it reads and writes data using 16 KB pages, the mechanics of row formats—especially the dynamic format—and why varchar columns are limited to 16383 characters, illustrated with SQL examples and diagrams.
This article presents a detailed case study of an IoT device metadata management platform, describing the business scenario, the evolution from a single‑node MySQL solution through sharded MySQL, HBase and Elasticsearch, to a self‑developed distributed storage engine that separates compute and storage, supports LSM, multi‑dimensional indexing, routing keys, and parallel scans to meet massive write‑read throughput and complex query requirements.
This article provides a comprehensive guide to relational database design with MySQL, covering ER modeling, BCNF and 3NF normalization, storage engine selection, character set and data type choices, and index design principles, illustrated through a student‑course selection example.
This article provides a comprehensive overview of distributed storage, covering seven core aspects such as replication, storage engines, transaction processing, analytical query execution, multi‑core scalability, computation models, and compilation techniques, while also highlighting practical challenges and design considerations for modern database systems.
This article explains the core components of database systems, including their client‑server architecture, query processing, storage engine modules, classification by storage media (memory vs. disk), and the differences between row‑oriented and column‑oriented data layouts, concluding with future topics to explore.
This article explores MySQL's client‑server interaction, connection methods, query parsing and optimization, InnoDB storage engine design, data page layout, BufferPool structures, and the free, flush, and LRU linked lists, including their challenges and optimization techniques.
This article explains InnoDB's storage engine mechanics, page-based I/O, the default Dynamic row format, how variable‑length fields like VARCHAR are recorded, why the maximum usable length is 16383 characters in utf8mb4, and the handling of NULL lists and overflow columns.
This article explains MySQL's client‑server architecture, detailing how the server processes connections, parses and optimizes queries, generates execution plans, and interacts with various storage engines, while also covering configuration variables, connection monitoring, and practical command examples.
This article explains how InnoDB stores data in 16 KB pages, calculates how many rows a B+Tree index can hold, shows how to determine the tree height from the page level, and answers why MySQL uses B+Tree rather than other tree structures.
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.
The article presents Maxwell, a C/assembly‑based high‑performance accounting database designed for Alipay, detailing its architecture, hotspot account challenges, performance optimizations such as Raft and a custom storage engine, and real‑world results showing thousand‑fold throughput gains and robust operation during massive promotional events.
This article provides a comprehensive overview of MySQL, detailing its configuration file search order, component architecture, various storage engines such as MyISAM, NDB, Memory, and an in‑depth examination of InnoDB’s internal structures, memory management, background threads, LRU handling, redo log buffering, and checkpoint mechanisms.
This article explains the storage units of InnoDB, calculates how many rows a B+ tree can hold at different heights, shows how to determine the tree height from the page level, and answers why MySQL uses B+ trees for indexing.
This article explains MySQL's architecture, the server and storage‑engine layers, query execution phases, status states, query cache behavior, the optimizer's parsing and planning steps, EXPLAIN output fields, the cost model, and why the optimizer selects index_author_id instead of index_title for a given query.
The first StarRocks Hacker Meetup recapped essential techniques for building high‑performance databases, covering CPU vectorization basics, key optimization strategies, and a preview of the upcoming session on real‑time updates and storage engine redesign, all presented by community experts.
The article explains the MySQL BlackHole storage engine, its black‑hole behavior, practical scenarios such as acting as a pseudo‑master to reduce master load and as a binlog collector, and provides detailed configuration steps including engine selection and binlog settings.
This article dissects MySQL's InnoDB storage engine by first exposing the internal page layout, then explaining the clustered index organization, and finally detailing the slot mechanism used for intra‑page queries, while illustrating insertion strategies and space‑reclamation techniques.
The Tencent CMongo team analyzed severe memory consumption, slow queries, and hour‑long startup caused by millions of MongoDB collections, identified bottlenecks in WiredTiger’s data‑handle management and schema‑lock handling, and introduced a shared‑table‑space architecture that reduces WT tables to a handful, achieving 1‑2 order‑of‑magnitude speedups and eliminating OOM failures.
This article reviews Ceph's architecture, benchmarks, monitoring methods, and a wide range of performance‑optimizing strategies—including storage‑engine tweaks, network‑communication improvements, data‑placement algorithms, configuration tuning, and hardware‑specific adaptations—while also outlining future research directions.
Apache Kudu 1.15.0 adds experimental multi‑row transaction support (currently INSERT and INSERT_IGNORE), Raft‑based master configuration tools, table comment synchronization with Hive Metastore, per‑table size and row‑count limits configurable via flags or the kudu table set_limit tool, a customizable Kerberos principal flag, and TLS v1.3 with optional cipher‑suite selection, collectively enhancing low‑latency random access and analytical capabilities in the Hadoop ecosystem.
This article explains InnoDB's storage hierarchy (sector, block, page), calculates how many rows fit in a 16KB page, shows how B+‑tree height and pointer counts determine total record capacity, and demonstrates the I/O cost of primary and secondary index lookups using practical MySQL commands.
This article explains how many rows a single InnoDB B+‑tree can hold by describing InnoDB’s 16 KB page size, the storage of data and index pages, calculating rows per leaf page, pointer capacity, tree height for typical workloads, and how to determine the height from the page‑level metadata.
This article explains the storage units of InnoDB, calculates how many rows a B+‑tree leaf page can hold, derives the total record capacity for trees of different heights, and shows how to determine the actual B+‑tree height in a MySQL table using page metadata.
This article explains how Prometheus turns complex monitoring into manageable tasks by introducing its core concepts, daily query examples, the advantages of its TSDB storage engine, and powerful data computation techniques that enable efficient large‑scale time‑series analysis.
This article explains how InnoDB’s 16 KB pages form B+‑tree indexes, calculates the number of rows a tree can hold at different heights, shows how to determine the tree’s height from the tablespace file, and why MySQL prefers B+ trees for indexing.
This article explains why defining columns as NOT NULL in MySQL improves query optimization, reduces index complexity and storage overhead, and avoids unexpected behavior in aggregates and calculations, while also covering default values, row formats, and practical testing results.
This article explains MySQL's three‑layer logical architecture, the roles of redo, undo, and binary logs, how they interact with the buffer pool and crash recovery, and provides practical commands for managing slow query, general, and error logs.
This article explains the complete MySQL architecture, covering its connection, service, storage‑engine, and system‑file layers, the role of each component such as connection pools, query cache, parser, optimizer, executor, and the differences between InnoDB and MyISAM, providing practical insights for developers and interview preparation.
Since 2019 NetEase Media has migrated several recommendation and account services from RDS to MyRocks, cutting disk usage by up to 68 % and halving response times while handling 40‑50 k QPS write‑heavy workloads, though the engine lacks partitioning, online DDL, and certain index types, requiring careful workload assessment.
LevelDB stores data using an in‑memory Memtable that flushes to immutable tables and disk‑based SSTables, writes are logged then batched and applied through a writer queue, reads check Memtable, immutable Memtable, then SSTables, and background compactions merge tables to improve read performance and reclaim space.
This article compiles 100 common MySQL interview questions covering index structures, hash vs B‑tree trade‑offs, clustering, transaction isolation levels, lock types, primary key choices, storage engines, data types, binlog formats, pagination strategies, and best practices for schema design and query optimization.
This article presents a comprehensive Q&A guide for developers covering MySQL index structures, transaction principles, table schema design, storage engine choices, and various practical issues such as char vs varchar, binlog formats, large pagination, and stored procedures.
This article provides a comprehensive interview‑style overview of MySQL fundamentals, covering relational database concepts, data types, storage engines, SQL syntax, version checking, normal forms, views, stored procedures, and performance tips, all essential for backend developers and database professionals.
This article explains MySQL's two‑layer architecture, the step‑by‑step execution flow of an SQL statement—including connection, query cache, parser, optimizer, executor, and storage engine—and the roles of redo log and binlog in ensuring data consistency.
This article provides an in‑depth overview of MySQL, covering storage engine concepts, selecting appropriate data types, index design and usage, view creation, stored procedure syntax, variable handling, and trigger implementation, with practical examples and SQL code snippets to illustrate each topic.
This article explains the storage units of InnoDB, how B+‑tree indexes are organized on pages, calculates the maximum number of rows a B+ tree can hold based on page size and pointer count, and shows how to determine the tree height from the tablespace file.
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.
This comprehensive guide explains MySQL's layered architecture, storage engine plugins, index structures, transaction isolation levels, locking mechanisms, performance tuning techniques, partitioning, sharding, and replication, providing practical insights for developers and DBAs to optimize and scale MySQL deployments.
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.
This comprehensive MySQL FAQ covers its definition, implementation language, key features, differences from SQL, storage engines, data types, triggers, security tips, performance considerations, and practical queries such as retrieving the N‑th highest salary, providing a solid reference for developers and DBAs.
This article explains the principles, evolution, modern structures, compaction strategies, optimization techniques such as Bloom filters and partitioning, and concurrency and recovery mechanisms of Log-Structured Merge (LSM) trees, which are widely used in contemporary NoSQL storage systems.
This article explains how InnoDB organizes data with B+ trees, calculates the maximum number of rows a single tree can hold (around 20 million), and shows how page size, pointer count, and tree height affect MySQL index performance.