Tagged articles
ROW format
27 articles · Page 1 of 1
This article details a systematic approach to diagnose and resolve MySQL 8.0 replication lag by enabling WRITESET on the source, configuring LOGICAL_CLOCK with optimal worker count on the replica, and preserving commit order, complete with diagnostic queries, configuration steps, and validation metrics.
GTIDLOGICAL_CLOCKMySQL
0 likes · 31 min read

This article introduces Apache Fory, a high-performance multi-language serialization framework, and demonstrates its integration with Spring Boot 3.5.0, showing up to 3x throughput improvement over Jackson in JSON benchmarks with code examples for binary, JSON, and row-format serialization.
Apache ForyJSON SerializationJava
0 likes · 12 min read

The article explains how MySQL determines whether a statement should be recorded in the binary log under ROW format, detailing the check_table_binlog_row_based function, the cached_row_logging_check flag, OPTION_BIN_LOG, and various scenarios—such as temporary tables, replication filters, no‑replicate tables, session settings, and internal operations—where binlog entries are omitted.
Binary LogMySQLROW format
0 likes · 11 min read


ITPUBDec 8, 2025 · Databases
This article examines MySQL’s handling of nullable columns, comparing the storage implications of saving NULL versus assigning default values, explains InnoDB row formats (REDUNDANT, COMPACT, DYNAMIC, COMPRESSED), and outlines the effects on storage space, indexing, and query behavior.
InnoDBMySQLNULL
0 likes · 6 min read

The article examines whether a nullable MySQL column should store NULL or a business default, detailing InnoDB row formats, storage overhead, record headers, hidden columns, and the trade‑offs of NOT NULL versus NULL definitions.
InnoDBMySQLNULL
0 likes · 7 min read

This article explains how MySQL stores rows, compares the four InnoDB row formats, and evaluates the trade‑offs of using NULL versus explicit default values for nullable columns, covering storage overhead, indexing behavior, and best‑practice design recommendations.
InnoDBMySQLNULL
0 likes · 7 min read

This article explains how MySQL stores rows using different InnoDB row formats, illustrates the internal layout of variable‑length columns and hidden fields, and compares the trade‑offs of defining columns as NOT NULL versus allowing NULL values, offering practical guidance for database design.
InnoDBMySQLNULL
0 likes · 8 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

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.
ROW formatdatabasestorage engine
0 likes · 16 min read

This article analyzes the MySQL 1709/1071 index‑column‑size‑too‑large error that appears after upgrading from 5.6 to 8.0.21, explains its relation to compact/redundant row formats, references the underlying bug, and provides practical steps and SQL queries to detect and fix affected tables before or after the upgrade.
Database UpgradeError 1709Index
0 likes · 12 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


ITPUBJan 20, 2024 · Databases
This article explores the true maximum length of MySQL VARCHAR columns, showing how charset, NULLability, column count, and row format affect the limit, and explains the underlying storage mechanics, row overflow, and alternatives for data larger than 64 KB.
CharsetMaximum LengthMySQL
0 likes · 13 min read


LouZaiDec 18, 2023 · Databases
This article analyzes the theoretical and practical limits of a single MySQL InnoDB table by examining B+‑tree depth, page layout, row format, and index pointer size, then calculates minimum and maximum record counts for int and bigint primary keys and validates the results with real‑world table schemas.
B+TreeIndex PointerInnoDB
0 likes · 13 min read

This article debunks the common belief that MySQL VARCHAR can store up to 65535 characters, showing how the true limit depends on the chosen character set, NULLability, column count, and row‑format details, and explains how oversized values are stored or require TEXT/BLOB types.
CharsetMySQLROW format
0 likes · 13 min read

This article explores how MySQL determines the maximum length of VARCHAR columns, showing that the limit depends on the chosen character set, nullability, and column count, and explains the underlying row storage format and how to handle oversized strings.
Dynamic StorageMaximum LengthMySQL
0 likes · 13 min read

This article investigates the true maximum length of MySQL VARCHAR columns, showing how charset byte size, NULLability, column count, and the InnoDB Dynamic row format together determine the effective limit, and explains how overflow is handled for very large strings.
BLOBCharsetDynamic Row
0 likes · 12 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

Explore the inner workings of MySQL InnoDB indexes, from row formats like Compact, Redundant, and Dynamic to page structures, B+Tree organization, and practical indexing strategies, complete with diagrams and tips for efficient query optimization and index design.
B+TreeIndexInnoDB
0 likes · 25 min read

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.
InnoDBMySQLROW format
0 likes · 17 min read

This article provides a comprehensive examination of InnoDB's physical file layout, detailing page components such as the file header, page header, record storage formats, variable‑length and NULL handling, free space, page directory, file trailer, external storage pages, and the differences among row formats and compression techniques, illustrated with concrete hexdump examples and SQL statements.
BLOB storageCompressionInnoDB
0 likes · 27 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 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.
InnoDBMySQLROW format
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 InnoDB's 16KB page structure, row formats, record metadata, primary key strategies, and how B+Tree indexes—including clustered, secondary, and covering indexes—organize and retrieve data, with practical SQL examples and performance considerations.
B+TreeIndexingInnoDB
0 likes · 30 min read

This article experimentally investigates whether MySQL re‑executes UPDATE statements that set a column to its current value, comparing behavior under ROW and STATEMENT binlog formats and revealing how InnoDB handles redundant updates.
InnoDBMySQLROW format
0 likes · 3 min read
