Tagged articles
Database Storage
32 articles · Page 1 of 1
This article traces the origin of the Log-Structured Merge-Tree (LSM Tree) from a 1996 paper by Patrick O'Neil et al., explaining how its sequential-write, background-compaction design solved the random I/O bottleneck of B-Trees, enabling modern write-heavy systems like Cassandra, RocksDB, and Kafka.
B+TreeBigtableDatabase Storage
0 likes · 16 min read

This article explains how MySQL stores data in 16KB pages, uses B+‑tree indexes to locate rows, derives the commonly cited 20‑million‑row limit from page fan‑out and row size calculations, compares B‑tree and B+‑tree structures, and offers practical optimization tips.
B+TreeDatabase StorageIndexing
0 likes · 20 min read

This article explains MySQL's storage architecture, compares the DELETE, TRUNCATE, and DROP commands, shows their performance and side‑effects, and provides practical guidance on choosing the safest and most efficient way to remove data from a MySQL table.
DELETEDROPDatabase Storage
0 likes · 9 min read

This article explains how MySQL InnoDB transforms a simple INSERT statement into a complex on‑disk record by detailing the COMPACT row format, record header, variable‑length field list, NULL bitmap, and overflow handling, helping developers optimize storage and performance.
Database StorageInnoDBMySQL
0 likes · 10 min read

Modern databases have largely shifted from B‑tree based storage to LSM‑tree engines due to SSD hardware characteristics, high‑write workloads, concurrency advantages, simpler implementation, and evolving application demands, with additional insights into Paxos/Raft consensus, common database jargon, and performance optimizations.
ConcurrencyDatabase JargonDatabase Storage
0 likes · 11 min read

This article provides comprehensive examples of APScheduler's advanced features including database storage, multi-threading/multi-processing, event listeners, dynamic task management, external event triggers, priority settings, logging, advanced triggers, and timezone support.
APSchedulerCron TriggersDatabase Storage
0 likes · 6 min read

This article explains what InnoDB does, how its page‑based I/O causes the first query to be slower, the default Dynamic row format, how varchar length is stored, the practical limits of varchar(M) under utf8mb4, and the impact of metadata and internal fragmentation on row space.
Database StorageMySQLROW format
0 likes · 22 min read

This article explains MySQL's InnoDB storage engine, covering where data files are kept, the different row formats (compact, redundant, dynamic, compressed), the internal 16 KB page layout, record header fields, overflow handling, and how B‑Tree indexes (clustered and secondary) are built and accessed.
B+TreeDatabase StorageIndexing
0 likes · 22 min read

Discover how GaussDB(DWS) HStore tables combine columnar storage with Delta capabilities to support high‑concurrency real‑time data ingestion, upsert operations, and ultra‑fast analytical queries, while offering full ACID consistency, strong compression, and practical configuration tips for developers.
ColumnarDatabase StorageGaussDB
0 likes · 8 min read

This article explains the LSM‑Tree foundation of OceanBase, details its tiered and leveled compaction strategies, and presents two experiments that observe Mini and Minor compactions under different configuration parameters, revealing how minor freeze and trigger settings affect data movement between L0 and L1 layers.
Database StorageLSM-treeMini Compaction
0 likes · 13 min read


ITPUBFeb 9, 2023 · Databases
This article breaks down MySQL's InnoDB storage engine, detailing where data files reside, the different row formats (compact, redundant, dynamic, compressed), the internal 16 KB page layout, record header fields, overflow handling, and how B‑tree indexes (clustered and secondary) are built and searched.
B+TreeDatabase StorageIndexing
0 likes · 24 min read

This article explains where MySQL keeps its data files, how InnoDB organizes tablespaces into segments, extents, pages and rows, details the Compact row format—including variable‑length field length lists, NULL‑value lists, and hidden fields—and clarifies the limits of VARCHAR and row‑overflow handling.
Database StorageExtentInnoDB
0 likes · 22 min read

This article examines the fundamental differences between B‑Tree and LSM‑Tree storage structures in distributed and relational databases, detailing their write and read paths, performance trade‑offs, update handling, lock conflicts, and high‑availability considerations to help engineers choose the right engine for their workloads.
B-TreeDatabase StorageLSM-tree
0 likes · 25 min read

This article explains the fundamental differences between row‑based and column‑based storage in relational databases, compares their performance for writes, reads, compression and use cases, presents an openGauss experiment with sample tables and SQL commands, and offers practical guidance on when to choose each storage model.
Column StoreDatabase StorageRow Store
0 likes · 10 min read

This article compares row‑based and column‑based storage models, analyzes their write and read performance, presents a practical openGauss experiment showing size and insert‑time differences, and offers concrete guidance on selecting the appropriate storage type for various workloads.
Column StoreDatabase StorageRow Store
0 likes · 10 min read

This article explains the differences between row-based and column-based storage in databases, compares their advantages and disadvantages, presents experimental results using openGauss including space usage and insert performance, and offers practical guidance on selecting the appropriate storage model for various workloads.
Column StoreDatabase StorageRow Store
0 likes · 10 min read

This article explains the fundamental differences between row‑based and column‑based storage in databases, compares their read/write performance, presents experimental results on openGauss showing space and speed trade‑offs, and offers practical guidance on when to choose each storage model.
Column StoreDatabase StorageRow Store
0 likes · 11 min read

This article explains how InnoDB stores data on disk, the role of 16 KB pages in read/write operations, the dynamic row format’s length and NULL lists, overflow handling, and why varchar columns are limited to 16 383 characters under utf8mb4, illustrated with SQL examples.
Database StorageInnoDBMySQL
0 likes · 15 min read

This article explains why MySQL’s DELETE only sets a delete‑mark, how InnoDB’s MVCC and purge thread reuse freed pages, the impact of B+‑tree storage on I/O, page merge and split mechanisms, and the proper way to rebuild tables to recover space.
B+TreeDatabase StorageDelete Mark
0 likes · 14 min read

This article explains how InnoDB stores data on disk using 16 KB pages, describes the dynamic row format and its handling of variable‑length columns such as VARCHAR, and clarifies why MySQL limits VARCHAR to a maximum of 16 383 characters under utf8mb4.
Database StorageInnoDBMySQL
0 likes · 15 min read

This article explains how MySQL’s InnoDB engine stores data on disk and in memory, detailing the structure of data pages, the role of hidden columns, record linking, page headers, footers, and directory mechanisms that ensure efficient access and durability.
Database StorageHidden ColumnsInnoDB
0 likes · 16 min read

This article explains the storage units of InnoDB, calculates how many rows a B+‑tree can hold based on page size, record size and pointer size, demonstrates how to determine the tree height from the tablespace file, and summarizes the impact on query I/O.
B+TreeDatabase StorageInnoDB
0 likes · 10 min read

This article explains the fundamentals of MySQL InnoDB page size, how it interacts with operating system pages, and the performance implications for rows, indexes, and tablespaces, providing practical guidance for choosing optimal page sizes in production environments.
Database StorageInnoDBMySQL
0 likes · 8 min read


ITPUBOct 19, 2020 · Databases
This article explains how InnoDB’s B+ tree storage works, calculates the approximate number of rows a single tree can hold based on page size, record size, and tree height, and shows how to determine the tree height from the tablespace file.
B+TreeDatabase StorageIndex Height
0 likes · 9 min read

This article explains how InnoDB’s page size, row size, and B+‑tree structure determine that a single B+ tree can hold roughly twenty‑million rows, shows how to calculate tree height from the root page, and demonstrates the concepts with SQL queries and practical examples.
B+TreeDatabase StorageInnoDB
0 likes · 11 min read

This article explains the three types of MySQL InnoDB tablespaces—system, single, and general—detailing their structures, configuration options, advantages, disadvantages, and practical procedures for creation, migration, optimization, and removal, with concrete command‑line examples.
Database StorageInnoDBMySQL
0 likes · 13 min read

This article provides a comprehensive overview of Oracle database architecture, detailing memory, physical and logical structures, I/O characteristics of various files, differences between OLTP and OLAP workloads, and practical ASM configuration and storage optimization recommendations for high‑performance environments.
ASMDatabase StorageIO Characteristics
0 likes · 12 min read

This article examines the trade‑offs of LSM‑based storage engines on SSDs, highlighting write amplification issues, the benefits of separating keys from values via the WiscKey approach, and the challenges of range queries, garbage collection, and crash consistency.
Database StorageKey-Value SeparationLSM
0 likes · 8 min read

This article explains Oracle's system structure, the physical files used by RAC and ASM, their I/O patterns for OLTP and OLAP workloads, and provides detailed recommendations for ASM diskgroup design, redundancy, AU sizing, RAID choices, and SSD optimization for read and write intensive database operations.
ASMDatabase StorageI/O
0 likes · 12 min read

PostgreSQL's TOAST mechanism automatically compresses and, when necessary, moves oversized column values to an external toast table, using four storage strategies (plain, extended, external, main) that dictate compression and externalization behavior, with data exceeding roughly 2 KB triggering external storage regardless of strategy.
CompressionDatabase StorageExternal Storage
0 likes · 8 min read

This article provides a comprehensive technical overview of InnoDB's physical file architecture, detailing how fixed‑size blocks, page types, extents, file‑list structures, segment creation, page allocation, recycling mechanisms, index page composition, and both traditional and transparent compression methods work together to manage MySQL storage efficiently.
B-TreeDatabase StorageInnoDB
0 likes · 23 min read

This article explains when SQL Server row overflow occurs, details the exact on‑disk pointer and data structures that store overflowed variable‑length columns across multiple pages, and highlights the performance impact and mitigation strategies for large tables.
Database StorageHeap PageRow Overflow
0 likes · 9 min read
