This article explains MySQL's transaction concepts, the four isolation levels defined by the SQL standard, how each level prevents dirty reads, non‑repeatable reads, and phantom reads, and provides practical commands and example experiments to configure and observe their behavior in InnoDB.
A MySQL data‑migration task using INSERT INTO SELECT triggered a full‑table scan, leading to lock contention, payment‑record loss, and ultimately the developer's dismissal, highlighting the dangers of unindexed bulk operations and the need for proper indexing and testing.
This article explains how to write Go unit tests for HTTP handlers that depend on MySQL by using fake implementations and the gomock library to replace the store layer, demonstrating both fake object and mock approaches, code examples, and best practices for isolating external dependencies.
This comprehensive guide explains MySQL transaction fundamentals, defines dirty reads, non‑repeatable reads and phantom reads, compares the four isolation levels, shows how to query and set them, and details the underlying locking mechanisms such as MVCC and next‑key locks.
Using MySQL’s INSERT INTO SELECT on a large, unindexed table caused full‑table locks that timed out concurrent transactions, leading to lost payment rows; the post‑mortem shows that adding appropriate indexes to the WHERE clause and understanding locking behavior prevents such intermittent failures.
The article explains how to handle distributed consistency when a financial reimbursement process involves MySQL writes and remote calls to BPM and SAP systems, analyzes failure scenarios, and proposes a split‑transaction approach using a task table, scheduled jobs, and Spring's afterCommit hook.
This article analyzes an intermittent failure where a MySQL instance managed by systemd in forking mode hangs because an automated test prematurely kills the newly created mysqld process, leading to a missing MAIN PID and a zombie process, and provides investigation steps and a practical fix.
Yearning is an open-source MySQL SQL audit platform built with Go and Vue.js that automates statement review, generates rollback scripts, provides audit logging, supports multi-channel notifications, and offers fine-grained permission control, with installation instructions and configuration details for rapid deployment.
This article explains MySQL's cost‑based optimizer, demonstrates how to calculate query costs for full‑table, covering, ref and range scans using actual source‑code constants, and applies the model to resolve index‑conflict cases in a store‑goods table, offering practical optimization guidelines and future tool ideas.
A real‑world MySQL case study shows how using INSERT INTO SELECT for large‑scale data migration without proper indexing caused full‑table scans, lock contention, and data loss, highlighting the need for careful query planning and performance testing.
This article explains how MySQL table‑level locks and metadata locks (MDL) can block both reads and writes, describes the two lock implementations, their types, the interaction with LOCK TABLES and FLUSH TABLES, and provides practical queries for diagnosing lock‑related blocking issues.
This article provides a comprehensive overview of InnoDB's transaction lock subsystem in MySQL, explaining row‑level and table‑level lock types, their internal implementations, lock‑compatibility rules, practical SQL examples, and common deadlock scenarios with detailed code illustrations.
This guide walks through implementing a complete product management module in a Java e‑commerce system, covering Snowflake distributed ID generation, database schema design for SPU and SKU tables, CRUD operations, category‑brand linking, audit workflow, status toggling, batch processing, and logical deletion, all with concrete code examples.
The article investigates why altering a MySQL VARCHAR column from a length that fits within 255 bytes to one that exceeds this limit (e.g., VARCHAR(63) to VARCHAR(64) in utf8mb4) triggers a costly copy operation, analyzes the storage mechanics, reproduces the issue, and provides practical recommendations to avoid performance penalties.
Discover why MySQL’s legacy ‘utf8’ charset only supports three‑byte characters, causing storage errors for true UTF‑8 data, and learn how the ‘utf8mb4’ charset resolves these issues, with historical context, technical details, and migration guidance.
This article explains MySQL InnoDB’s write‑ahead logging, detailing the roles of Buffer Pool, Redo and Undo logs, checkpoint mechanisms, and how they ensure data consistency and atomicity when a sudden power loss occurs.
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.
The article explains why MySQL’s built‑in utf8 charset cannot store four‑byte characters such as emojis, demonstrates the resulting insert error, shows how switching the database, table and connection to utf8mb4 fixes the issue, and recounts the historical reasons behind MySQL’s limited utf8 implementation.
This article walks through replacing MyBatis with MyBatis‑Plus in a legacy Java project, explains the “Conversion not supported for type java.time.LocalDateTime” error caused by MyBatis 3.5.1 and an outdated mysql‑connector‑java driver, and shows how upgrading the driver resolves the issue while offering debugging tips.
The article explains how to respond to accidental MySQL data deletion by analyzing loss causes, choosing recovery methods such as mysqldump backups, binary‑log point‑in‑time restores, or Percona’s InnoDB tool, provides step‑by‑step commands, and recommends preventive practices like regular backups, transactions, and strict permissions.
This article explains how Profile‑Guided Optimization (PGO) can increase MySQL throughput by 30‑50% without changing application code, detailing the required compilation steps, necessary CMake flags, and real‑world benchmark results that demonstrate the performance gains and their limitations.
This guide explains how MySQL's InnoDB engine handles transactions and ACID properties, demonstrates exclusive and shared locking mechanisms, shows how to use connection pools, and provides reusable Python code for robust database operations, all illustrated with clear SQL and Python snippets.
This article summarizes the major changes introduced in MySQL 8.4, including updated InnoDB parameters, revised default values, new cloning plugin rules, Windows SASL‑based LDAP authentication, and adjustments to replication settings, helping developers and DBAs optimize their database configurations.
The article walks through a real‑world MySQL performance case where a 100‑million‑row table caused SLA alerts, analyzes slow‑query logs, demonstrates index redesign, compares online DDL with pt‑osc, and shows how batch deletions by primary key dramatically reduce delete time and replication lag.
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 analyzes a MySQL 5.7.20 crash that occurs during INSERT operations on BLOB columns with INSERT … ON DUPLICATE syntax, explains the underlying bug in the copy_blob_value function, shows how to reproduce and locate it with gdb, and provides the fix introduced in MySQL 5.7.22.
This article demonstrates how to create a user authentication system in PHP, covering database table design, login and logout functions, password verification, session handling, and a role‑based permission check to enable multi‑level access control for secure web applications.
This article presents a comprehensive performance test of inserting massive amounts of randomly generated person records into MySQL, comparing three strategies—MyBatis lightweight insertion, direct JDBC handling, and JDBC batch processing—both with and without transactions, and concludes that combining batch processing with transactions yields the fastest insertion speed for large‑scale data loads.
This article explains why read‑heavy internet services use MySQL master‑slave replication for read/write separation, describes the asynchronous replication process, discusses latency side‑effects, and offers practical strategies such as data redundancy, caching, and direct master queries to mitigate delays.
Deep pagination in MySQL becomes a performance bottleneck when tables reach millions of rows, causing excessive row scans and costly index lookups; this article explains its root causes and presents six practical optimization techniques—including keyset pagination, delayed joins, covering indexes, data partitioning, and external search engines—to dramatically improve query speed.
This guide covers practical MySQL performance improvements, detailing SQL-level optimizations such as limit pagination, proper LIKE usage, UNION ALL, EXISTS vs IN, TRUNCATE, batch inserts, early filtering, function placement, data type minimization, CHAR/VARCHAR choices, indexing strategies, force index, as well as server parameter tuning for buffer pool and redo log settings.
This article explains where MySQL stores auto‑increment values, why gaps appear after failed inserts, duplicate‑key errors, rollbacks or batch inserts, and how different innodb_autoinc_lock_mode settings and MySQL 8.0 improvements can mitigate the issue.
MySQL, born in the 1990s as a free open‑source database, became a core component of the LAMP stack and remains widely used; the article explains why indexes are needed, compares binary trees, B‑trees and B+‑trees, and describes how modern cloud‑based MySQL services improve performance and reliability.
This guide compiles essential MySQL interview topics—including definitions, differences from Oracle and SQL Server, index types and usage, B‑tree vs B+‑tree structures, deadlock handling, and view concepts—providing a systematic overview for developers preparing for database interviews.
This tutorial explains how to connect PHP to databases using both mysqli and PDO, covering connection setup, error handling, executing queries, and properly closing the connection, with complete code examples for each method.
This article reviews the 14-part series on MySQL's transaction module, covering initialization, transaction types, two‑phase commit, binlog handling, savepoints, and full rollback, and provides links to each detailed post, including discussions on BEGIN statements, read‑only transactions, and the internal mechanisms of InnoDB.
A detailed post recounts a production outage caused by improper index handling in a massive MySQL table, walks through MySQL lock diagnostics, compares index behavior on MySQL and TiDB, and distills practical recommendations for safe DML, DDL, and index management.
This article explains the WKB binary format, its storage advantages in MySQL and PostgreSQL, and provides step‑by‑step Java code using JTS's GeometryFactory, WKBWriter, and WKBReader to write a Point to WKB, convert it to a hex string, and read it back into a geometry object.
This article details the migration of a popular social app's private‑message service from a saturated MySQL cluster to PolarDB, covering business challenges, evaluation of storage‑optimization, vertical and horizontal scaling, the chosen distributed database solution, step‑by‑step offline and online migration procedures, and the resulting performance and cost benefits.
The article investigates why MySQL batch jobs experience aborted connections, tracing the issue to TCP buffer overflow on the client side, excessive ACK traffic, and the default net_write_timeout of 60 seconds, and proposes kernel tweaks and query optimizations to resolve the problem.
This guide walks through three MySQL administration scenarios—resetting the root password using the --skip-grant-tables option, adding user accounts with proper grants, and changing passwords via UPDATE, SET PASSWORD, ALTER USER, GRANT, and mysqladmin—providing step‑by‑step commands and precautions.
This article walks through replacing MyBatis with MyBatis‑Plus in a legacy Java project, demonstrates the LocalDateTime conversion error caused by MySQL‑connector‑java version incompatibility, shows how upgrading the driver resolves the issue, and shares a cautionary tale about unintended bugs after component upgrades.
This article demonstrates how the MySQL LIKE clause can give misleading results when filtering triggers, walks through a step‑by‑step lab that creates tables and triggers, shows the pitfalls of LIKE, and presents a safer WHERE‑based method for retrieving trigger definitions.
The article explains why transaction isolation is essential in databases, describes common concurrency problems such as lost updates, dirty reads, non‑repeatable reads, and phantom reads, and outlines MySQL's four isolation levels with their effects and trade‑offs.
A Java developer recounts a production MySQL outage caused by a faulty batch insert, walks through failed delete and lock‑free attempts, then details a series of table‑recreation, truncate, and index‑rebuilding steps that finally restored data integrity and performance.
This article explains how to boost MySQL insertion speed by adjusting server hardware, tuning database parameters, choosing the MyISAM engine, and especially applying three batch‑insert techniques—SQL concatenation, MyBatis‑Flex saveBatch, and manual transaction batching—while showing test results and configuration tips.
This article explains how an invisible zero‑width Unicode character embedded in a MySQL table name can make the table appear to disappear, demonstrates the problem with reproducible examples, analyzes the root cause, and provides practical steps to detect and fix such issues.
This article recounts how a volunteer registration platform was redesigned to meet extreme concurrency demands—handling up to 40k QPS and 20k TPS—by evaluating MySQL limits, adding Redis caching, integrating RocketMQ, applying fault‑recovery mechanisms, and iteratively optimizing through multiple load‑testing rounds.
This guide explains why MySQL or Java processes can consume 900% CPU, outlines step‑by‑step diagnostics using tools like top, show processlist, jstack, and provides concrete fixes such as adding indexes, disabling slow logs, using caches, and optimizing thread handling.
Facing a 50‑million‑row financial transaction table that grew 6 million rows per month, the team analyzed the problem, set clear split goals, evaluated sharding middleware, designed a custom pagination algorithm, built a hybrid data‑migration plan, and executed a three‑stage rollout to safely replace the monolithic table with multiple 10‑million‑row shards.
This article explains how to use PHP's mysqli_num_rows function to retrieve the number of rows in a MySQL result set, providing a complete example that connects to the database, executes a SELECT query, checks for errors, obtains the row count, and displays it.
The article examines why MySQL LIMIT pagination becomes slower on deeper pages of a 500,000‑row table, analyzes query execution plans, and presents three optimization strategies—ordered index filtering, subquery pagination, and join‑based pagination—to improve performance in real‑world scenarios.
This article investigates a slow‑SQL incident caused by the TDDL optimizer reordering a MySQL query, analyzes why the optimizer chose an inefficient index, demonstrates how to verify and force the correct index, and proposes better index and partition‑key designs for optimal performance.
This article explains how MySQL 8.0.32 rolls back a transaction by first attempting a binlog rollback (which does nothing for a plain ROLLBACK), then performing InnoDB undo‑log processing, committing the internal InnoDB changes, and finally clearing temporary binlog data from the transaction cache.
Learn how to assess and optimize your MySQL database using four powerful open‑source tools—mysqltuner.pl, tuning‑primer.sh, pt‑variable‑advisor, and pt‑query‑digest—complete with download links, command‑line usage examples, and guidance on interpreting their diagnostic reports to improve performance and security.
The article analyzes a MySQL cascade replication issue where the new slave failed to sync due to duplicate server_id values, explains the root cause stemming from automated server_id assignment, and provides step‑by‑step remediation to ensure unique server_id settings and reliable replication.
This article explains the default repeatable‑read isolation level in InnoDB, details the three main lock types—record, gap, and next‑key—and shows how SELECT … FOR UPDATE applies different locking rules depending on primary key, unique, ordinary, range, or table‑scan queries, with practical SQL examples.
This article explains what MySQL binlog is, how it enables master‑slave replication, and explores practical business applications such as data heterogeneity, cache synchronization, and task distribution, while highlighting performance considerations and the benefits of using binlog‑based middleware.
This article explains MySQL events as built‑in schedulers, outlines their advantages, shows how to enable the event scheduler, create, view, modify, and drop events, and provides concrete examples for generating real‑time sales data and periodic statistics.
This article explains how MySQL executes ORDER BY queries, the role of sort_buffer, the difference between full-field and rowid sorting, how parameters like sort_buffer_size and max_length_for_sort_data affect performance, and how proper indexing can eliminate the need for sorting altogether.
The article walks through a performance test of inserting over 100,000 rows with many columns, showing how a naïve loop takes about 80 seconds while JDBC batch, manual transaction control, and MyBatis/MyBatis‑Plus batch APIs can reduce the time to roughly one second.
This article presents eight practical MySQL optimization methods—including smarter LIMIT usage, avoiding implicit type conversion, rewriting joins, handling mixed ordering, replacing EXISTS with joins, pushing down conditions, pre‑filtering data, and using WITH clauses—to dramatically reduce query execution time.
This article compares MySQL's JOIN and IN constructs, showing that IN can be slightly faster for simple filters while JOIN offers greater flexibility for complex, multi‑table queries, and it outlines when to use each approach along with additional optimization tips such as indexing and engine selection.
This guide walks through locating the Docker volume of a removed MySQL container, creating a new container with the same image, and swapping the volumes to restore the original database, providing step‑by‑step commands and screenshots for successful data recovery.
This article provides an in‑depth overview of MySQL string functions, covering concatenation, length, position, replacement, conversion, encryption, comparison, generation, and their syntax and usage examples, helping developers manipulate textual data efficiently in database operations.
This article compares PostgreSQL and MySQL across history, ACID compliance, performance, scalability, advanced features, tooling, security, backup strategies, and Linux installation steps, helping full‑stack developers choose the most suitable open‑source relational database for their projects.
This article analyzes why MySQL recommends auto‑increment primary keys over UUIDs or random snowflake IDs by designing three tables, running insert‑select benchmarks with Spring Boot's JdbcTemplate, presenting the test results, and discussing the underlying index‑structure impacts and trade‑offs.
This article explains MySQL InnoDB full-text search, covering inverted index structures, creation and usage of full-text indexes, query modes such as natural language, boolean, and query expansion, and provides practical SQL examples and considerations for effective text searching.
This article explains MySQL foreign keys, how to define them with CREATE TABLE syntax, cascade actions, limitations, pros and cons, and provides a complete MySQL 5.7 example with metadata queries and a cascade‑delete test, helping readers understand when to use or avoid foreign keys.
This article presents a detailed investigation of a MySQL master‑slave instance suffering from nightly SLA alerts due to slow‑query latency, analyzes the root causes with pt‑query‑digest and execution plans, proposes index redesign, demonstrates backup and restore with mydumper, compares online DDL and pt‑osc, and finally shows batch‑delete techniques to reduce load on large tables.
This article examines whether SELECT COUNT(*) causes full‑table scans, explains MySQL’s optimizer cost‑based index selection (including IO and CPU costs), demonstrates with a 100k‑row table how auxiliary indexes are chosen, and shows cases where the optimizer’s estimates mislead performance.
This article explains how MySQL 8.0.32 InnoDB rolls back to a specific savepoint by locating the savepoint in the thread's m_savepoints list, discarding relevant binlog entries, applying undo logs in reverse order, and finally removing any later savepoints, with full code examples.
This article shares a detailed ByteDance backend interview experience covering three rounds, summarizing essential topics such as Java HashMap internals, Spring circular dependencies, MySQL indexing, OS process/thread concepts, networking protocols, TLS handshake, HTTP/2 features, and common design patterns, providing concise explanations and practical tips.
This guide walks through setting up Flink CDC with MySQL on SpringBoot 2.7, covering binlog configuration, Maven dependencies, Java implementation for real‑time change capture, startup options, a custom Redis sink, and a web UI for monitoring the streaming pipeline.
This article explains the new mysqld-long-query-time option added to MySQL 8.0.30's mysqldump tool, shows how to configure it, presents comparative experiments demonstrating its effect on slow‑query logs, and provides conclusions and additional notes for practical database backup scenarios.
This article presents nine practical MySQL index optimization techniques—from selecting high‑selectivity columns and avoiding functions on indexed fields to applying the leftmost‑prefix rule, handling NULLs, using proper LIKE patterns, and leveraging EXPLAIN and LIMIT 1 for faster queries.
When a user reported errors, I discovered a MySQL table flooded with millions of bad rows from a new group, causing slow queries and crashes; I detail the step‑by‑step investigation, failed attempts with DELETE and lock‑free changes, and the final successful rebuild using temporary tables, DROP, TRUNCATE, and index reconstruction.
This article introduces MySQL and PostgreSQL, compares their architectures, presents benchmark results showing PostgreSQL's superior SELECT, INSERT, and UPDATE performance, discusses suitable application scenarios, and summarizes the strengths and weaknesses of each database for informed selection.
This article explains common MySQL performance pitfalls such as large‑offset pagination, implicit type conversion, inefficient UPDATE/DELETE joins, mixed ordering, EXISTS subqueries, predicate push‑down, early data reduction, and intermediate result set push‑down, and provides concrete rewrites that turn multi‑second queries into millisecond‑level executions.
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.
This article explores eight common MySQL performance pitfalls—from inefficient LIMIT usage and implicit type conversion to subquery joins, mixed ordering, EXISTS clauses, condition pushdown, early result limiting, and intermediate result set optimization—offering concrete rewrites and execution plan analyses to dramatically speed up queries.
This guide outlines a clear, maintainable CMS architecture for technical blogs, covering logical, development, physical, process, and scenario views, recommending MVC with Go, MySQL, and React/Vue, and provides a simple Go API example.
The article examines why MySQL performance drops sharply when a single table exceeds tens of millions of rows, debunks the index‑depth myth, explains SMO concurrency limits in InnoDB, and shows how B‑Link Tree indexes and heap‑organized tables can overcome these bottlenecks.
This article presents a series of MySQL performance‑enhancing techniques—including smarter LIMIT usage, avoiding implicit type conversion, rewriting UPDATE/DELETE with JOINs, mixed‑order sorting tricks, replacing EXISTS with JOINs, condition push‑down, early result limiting, and intermediate result push‑down—to dramatically reduce query execution time.
In MySQL 5.7, using REPLACE INTO on a table that has an auto‑increment primary key and an extra unique index can cause the master and slave AUTO_INCREMENT counters to diverge, leading to duplicate‑key errors after failover, a bug mitigated by upgrading to MySQL 8.0, manual counter fixes, or avoiding REPLACE INTO.
This article explains how InnoDB implements savepoints in MySQL 8.0.32, covering undo log sequencing, the savepoint structures in the server, binlog, and InnoDB layers, the process of locating and deleting duplicate savepoints, and the three-step procedure for creating a new savepoint.
The article demonstrates through a practical experiment that MySQL will use indexes for an OR condition only when both operands are indexed, otherwise it falls back to a full table scan, and it suggests using UNION as an optimization when one side lacks an index.
This article investigates a MySQL 8.0.27 replica that repeatedly hangs during show replica status, analyzes worker thread states, InnoDB status, checkpoint and I/O load, identifies an oversized Redo Log usage as the root cause, and provides configuration and upgrade suggestions to resolve the issue.
This article presents 18 practical guidelines for backend developers on naming conventions, field types, lengths, primary keys, indexes, storage engines, null constraints, foreign keys, character sets, collations, large fields, redundant fields, and comments to help create efficient, maintainable MySQL tables.
The article explains MySQL 8.0's INSTANT DDL algorithm, its default behavior, limitations such as the 64‑change cap, and provides practical recommendations for always specifying the algorithm, monitoring instant changes via INFORMATION_SCHEMA, and safely rebuilding tables when needed.
This article walks through the complete process of upgrading MySQL 5.7.43 to 8.0.34 on CentOS 7, covering lifecycle background, new 8.0 features, pre‑upgrade checks, data backup, configuration changes, installation, upgrade execution, post‑upgrade verification, and troubleshooting of typical SSL and host‑blocking issues.
This article demonstrates how to insert 300,000 rows into a MySQL table using MyBatis and JDBC, compares bulk batch insertion with per‑row looping, discusses packet size limits, transaction handling, performance metrics, and provides practical code snippets and optimization tips for efficient large‑scale data loading.
This article explains how MySQL auto‑increment primary keys work, the practical limits of various internal IDs such as auto‑increment, InnoDB row_id, Xid, trx_id, and thread_id, and compares them with external solutions like Redis‑based auto‑increment keys, providing guidance on choosing the right approach for different scenarios.
This guide explains how to install Docker, pull the official MySQL image, run a MySQL container with persistent storage, connect to it, perform basic SQL operations, and finally stop and remove the container, demonstrating a complete end‑to‑end deployment using Docker.
This article explains the fundamentals of database sharding and partitioning, why they are needed for massive data volumes, various vertical and horizontal splitting strategies, routing algorithms, client vs. proxy deployment models, and the practical challenges and solutions when using ShardingSphere 5.x.
This guide explains how to efficiently load one billion 1‑KB log entries from HDFS or S3 into MySQL by analyzing B‑tree limits, using batch inserts, choosing the right storage engine, sharding tables, optimizing file reading, and coordinating tasks with Redis, Redisson, and Zookeeper.
This article examines the detailed steps and performance impact of creating a MySQL connection from a Java web application, measures the latency of the handshake and authentication using Wireshark, and demonstrates why connection pooling is essential for high‑traffic services.
This article walks through replacing MyBatis with MyBatis‑Plus in a legacy Java project, uncovers the root cause of a LocalDateTime conversion error caused by MyBatis 3.5.1 and an outdated MySQL connector, demonstrates version upgrades and code fixes, and shares a related production bug and its remediation.
This article investigates the time overhead of establishing MySQL database connections in Java web applications, detailing the TCP handshake, authentication steps, and measured latency using Wireshark, and demonstrates why connection pooling is essential to avoid hundreds of milliseconds per request.
This article introduces MySQL and PostgreSQL, compares their architectures and benchmark results on identical hardware, highlights PostgreSQL's superior read/write performance, and discusses the strengths, weaknesses, and ideal use‑case scenarios for each database system.
