Tagged articles
isolation levels
68 articles · Page 1 of 1
This article explains how MySQL's MVCC uses version chains and ReadViews to enable lock-free snapshot reads, why isolation levels control ReadView creation timing (per-statement vs per-transaction), and why READ UNCOMMITTED and SERIALIZABLE bypass MVCC entirely, while writes still require row locks.
InnoDBMVCCMySQL
0 likes · 8 min read

This article explains how MySQL's MVCC mechanism uses version chains and ReadViews to enable lock-free snapshot reads, and why four isolation levels (READ UNCOMMITTED, READ COMMITTED, REPEATABLE READ, SERIALIZABLE) are still necessary: they define when ReadViews are created, controlling which version a transaction sees, while MVCC only handles reads—writes still require row locks.
InnoDBMVCCMySQL
0 likes · 9 min read


ITPUBAug 25, 2026 · Databases
The article reviews a speaker’s ten‑year journey from building multi‑level consistency models and defining over twenty new data anomalies to exposing ANSI‑SQL’s isolation flaws, unveiling the “Eight Immortals” consistency diagram, proposing the CCDB architecture with zero‑time unlock, and finally codifying three concurrent‑system design principles.
CCDBConcurrencyConsistency
0 likes · 30 min read


liandkJul 31, 2026 · Databases
This article explains why database transactions are a core backend skill, breaks down the four ACID properties, clarifies dirty read, non‑repeatable read and phantom read, compares the four isolation levels, and offers practical guidelines for choosing the right level in production.
ACIDDirty ReadMySQL
0 likes · 7 min read

The article explains how databases use Multi-Version Concurrency Control, Undo Logs, ReadViews, snapshot reads, and both pessimistic and optimistic locking to allow readers to see a stable historical version while writers modify data without causing inconsistency or performance loss.
LocksMVCCReadView
0 likes · 10 min read

The article uses a simple money‑transfer scenario to introduce database transactions, explains the four ACID properties, illustrates common concurrency anomalies such as dirty reads, non‑repeatable reads and phantom reads, and outlines the four isolation levels with their trade‑offs and default settings in MySQL and Oracle.
ACIDMySQLconcurrency control
0 likes · 8 min read

This article explains InnoDB's lock mechanisms—including table, intention, row, GAP, next‑key, and auto‑increment locks—shows how to inspect them via performance_schema tables, demonstrates lock behavior under different isolation levels with concrete SQL examples, and clarifies lock compatibility rules.
InnoDBLocksMySQL
0 likes · 20 min read

This guide explains MySQL's transaction architecture—from the ACID properties and their implementation with undo/redo logs and MVCC, through isolation levels and common concurrency anomalies, to detailed lock types, deadlock detection, and practical performance‑tuning strategies.
ACIDMySQLTransactions
0 likes · 13 min read

This article explains MySQL transaction fundamentals, illustrates a banking transfer scenario, details the ACID properties, explores dirty reads, non‑repeatable reads and phantom reads, and compares the four SQL‑92 isolation levels with practical code examples and InnoDB behavior.
ACIDInnoDBMySQL
0 likes · 10 min read

This article explains MySQL InnoDB’s MVCC mechanism, why it replaces traditional locking, details the four SQL isolation levels, illustrates dirty, non‑repeatable and phantom reads with examples, and breaks down the hidden fields, undo‑log chain, and read‑view algorithm that enable high‑concurrency, non‑blocking reads and writes.
InnoDBMVCCMySQL
0 likes · 18 min read

This article explains MySQL's transaction isolation levels, the ACID principles behind them, common anomalies like dirty reads, non‑repeatable reads and phantom reads, the locking mechanisms that enforce isolation, and how to configure the desired level in practice.
ACIDMySQLisolation levels
0 likes · 11 min read

This article explains what database transactions are, why they matter, details MySQL’s transaction commands, the ACID properties, isolation levels, lock types, MVCC, how to use InnoDB, handle errors, employ savepoints, and provides concrete SQL examples for creating, committing, rolling back, and managing transactions.
ACIDInnoDBLocks
0 likes · 12 min read

This article provides a comprehensive overview of MySQL's lock mechanisms, covering lock granularity, lock types, intention locks, record/gap/next‑key locks, their interaction with transaction isolation levels, two‑phase locking, deadlock handling, and practical optimization techniques for high‑concurrency applications.
ConcurrencyMySQLdeadlock
0 likes · 20 min read

This article explains MySQL's eight lock mechanisms, their purposes and classifications, demonstrates row‑level, gap, next‑key, table and metadata locks with code examples, discusses deadlock scenarios and detection, and provides practical monitoring and optimization strategies to improve concurrency and reliability.
ConcurrencyMySQLdatabase optimization
0 likes · 10 min read

This article explains how MySQL transactions and locking mechanisms ensure data consistency and handle high concurrency, covering basic transaction commands, isolation levels, practical lock implementations, deadlock simulation, and best‑practice recommendations for avoiding common concurrency problems.
LocksMySQLOptimistic Lock
0 likes · 7 min read

This article explains the concept and importance of MySQL database transactions, describes the ACID properties, shows how to use transaction control statements and savepoints, and demonstrates each isolation level (read uncommitted, read committed, repeatable read, serializable) with practical SQL examples.
ACIDMySQLSQL
0 likes · 10 min read

This article explains MySQL transaction fundamentals, the ACID properties, MVCC implementation, isolation levels, snapshot versus current reads, and the various lock types and modes, and provides practical examples of how different SQL statements acquire locks under InnoDB.
InnoDBLocksMVCC
0 likes · 14 min read

This article demonstrates how InnoDB handles row, next‑key, and gap locks for a SELECT … FOR SHARE query under REPEATABLE‑READ and READ‑COMMITTED isolation levels, showing the preparation steps, SQL examples, lock inspection queries, and a concise summary of the differences.
InnoDBLocksMySQL
0 likes · 8 min read

This article explains the various moments when InnoDB table and row locks are released during a transaction's lifecycle, covering mismatched WHERE conditions, the two‑phase commit prepare stage, AUTO‑INC locks, and differences across isolation levels in MySQL 8.0.32.
InnoDBMySQLdatabase
0 likes · 12 min read

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.
ACIDDatabase ConcurrencyMySQL
0 likes · 8 min read

This article explains MySQL InnoDB locking mechanisms, detailing the twelve lock types, their granularity, compatibility rules, how to view lock information, and how different SQL statements acquire locks under various isolation levels, with practical test cases and code examples.
InnoDBMySQLisolation levels
0 likes · 16 min read

This article explains the differences between Read Committed (RC) and Repeatable Read (RR) isolation levels in MySQL, detailing how snapshot reads work, why other levels avoid them, and illustrating their behavior with concrete transaction examples.
MySQLisolation levelssnapshot read
0 likes · 8 min read

This article explains MySQL transaction fundamentals, the necessity of ACID properties, details the four isolation levels and their impact on phenomena like dirty reads, non‑repeatable reads, and phantom reads, and provides practical SQL examples and strategies for ensuring data consistency in high‑concurrency environments.
ACIDDatabase ConcurrencyInnoDB
0 likes · 15 min read

This article explains the concept of database transactions, the ACID properties, how MySQL implements transactions with InnoDB, how to manage autocommit, the essential transaction control statements, a practical example using savepoints, and the four isolation levels supported by MySQL.
ACIDMySQLSQL
0 likes · 7 min read


政采云技术Oct 24, 2023 · Databases
This article explains MySQL InnoDB's Multi-Version Concurrency Control (MVCC), covering its basic concepts, read/write scenarios, implicit fields, undo logs, read view mechanisms, transaction handling, and differences between RC and RR isolation levels, providing a comprehensive guide for developers.
InnoDBMVCCMySQL
0 likes · 16 min read

This article explains MySQL transaction fundamentals, the ACID properties, how to start and control transactions, the problems of dirty, non‑repeatable and phantom reads, isolation level settings, MVCC mechanics, read‑view structures, and the role of undo logs in ensuring data consistency.
InnoDBMVCCMySQL
0 likes · 15 min read

This guide explains MySQL transaction fundamentals, the ACID properties, how to use explicit and implicit transactions, savepoints, and demonstrates each isolation level with commands and examples to help developers write reliable, concurrent database code.
ACIDMySQLSQL
0 likes · 12 min read

This article explains MySQL’s various lock types—global, table, metadata, intention, and row‑level—and shows how SELECT statements acquire different locks under each isolation level, with examples for existing and missing rows, range scans, unique and non‑unique indexes, and full‑table scans.
InnoDBMySQLdatabase
0 likes · 15 min read


政采云技术Mar 28, 2023 · Databases
This article explains why MySQL uses MVCC, how undo‑log version chains and read views implement multi‑version concurrency control, and details the various lock types—including global, table, metadata, intention, row, gap, and next‑key locks—under different isolation levels with practical code examples.
InnoDBLocksMVCC
0 likes · 11 min read

This article explains MySQL transaction fundamentals, including the ACID properties, isolation levels, MVCC mechanics, transaction start methods, and practical examples that illustrate how different isolation levels affect data visibility and consistency.
Database ConcurrencyInnoDBMVCC
0 likes · 20 min read


ITPUBJan 26, 2023 · Databases
This article experimentally demonstrates how MySQL's SELECT … FOR UPDATE statement acquires various locks—IX, X, and gap locks—under RC (read‑committed) and RR (repeatable‑read) isolation levels with unique, primary, normal, and missing indexes, revealing when row‑level versus table‑level locking occurs.
Database ConcurrencyInnoDBMySQL
0 likes · 16 min read

This article presents a series of MySQL 5.7.26 experiments that reveal how record locks on non‑indexed columns are applied to the primary (clustered) index under different isolation levels, how full‑table scans affect locking behavior, and why updates and inserts may or may not be blocked.
IndexInnoDBMySQL
0 likes · 17 min read

The article explains why transaction isolation is required, 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 on data consistency.
ACIDSQLisolation levels
0 likes · 8 min read

This article explains MySQL's multi-version concurrency control (MVCC), describing how version chains, undo logs, and ReadView work together to implement isolation levels, prevent dirty reads, non‑repeatable reads, and phantom reads, and how RC and RR isolation differ in practice.
Database ConcurrencyMVCCMySQL
0 likes · 8 min read

This article delves into MySQL’s internal logging mechanisms—redo log, undo log, and binlog—explaining their structures, purposes, and interactions, and then explores transaction concepts such as dirty reads/writes, non‑repeatable reads, phantom reads, isolation levels, and the MVCC implementation that ensures data consistency.
MVCCMySQLbinlog
0 likes · 11 min read

Through a series of MySQL 5.7.26 experiments the article reveals how record‑level locks are applied to primary‑key indexes when non‑indexed columns are locked, how isolation levels (READ COMMITTED vs REPEATABLE READ) change the locking order, and why both SELECT … FOR UPDATE and UPDATE statements can block other transactions.
IndexInnoDBMySQL
0 likes · 14 min read


政采云技术Jan 20, 2022 · Databases
This article explains InnoDB's Multi-Version Concurrency Control (MVCC) mechanism, detailing undo log, readview, hidden columns, visibility algorithms for RR and RC isolation levels, and includes source code snippets illustrating read view assignment and visibility checks.
Database InternalsInnoDBMVCC
0 likes · 12 min read

This article walks through MySQL's core concepts—including ACID guarantees, the four isolation levels, undo and redo logs, buffer pool flushing, lock types, gap locks, deadlock scenarios, and the B+‑tree based index architecture—providing interview‑ready insights and practical examples.
ACIDB+TreeDatabase Interview
0 likes · 12 min read

This article explains MySQL's MVCC mechanism, detailing how multi-version concurrency control, undo logs, and ReadView work together to implement isolation levels, prevent dirty reads, non-repeatable reads, and phantom reads, and compares the behavior of Read Committed and Repeatable Read.
MVCCMySQLReadView
0 likes · 9 min read

This article explains MySQL transaction isolation levels, the four concurrency problems (dirty write, dirty read, non‑repeatable read, phantom), how MVCC and version chains work, and the differences between READ COMMITTED and REPEATABLE READ using practical examples and diagrams.
MVCCMySQLRead View
0 likes · 10 min read

This article presents a series of MySQL experiments that examine how different isolation levels, partition‑key usage, and comparison operators affect the number and scope of locks acquired on partitioned tables, revealing the impact of partition pruning on lock contention.
LocksMySQLPartition Pruning
0 likes · 6 min read

This article explains MySQL's query cache settings, clustered and non‑clustered index design, optimizer cost calculations, how to interpret EXPLAIN output, and the roles of redo/undo logs and transaction isolation levels, providing practical examples and performance tips.
MySQLOptimizerQuery Cache
0 likes · 23 min read

This article explains MySQL transaction fundamentals, the ACID properties, common concurrency problems, isolation level differences, and how InnoDB implements MVCC using version chains and consistency views, illustrated with practical examples and diagrams.
ACIDDatabase ConcurrencyMVCC
0 likes · 15 min read

The article explains MySQL transaction ACID properties, details the four isolation levels and their associated anomalies, describes InnoDB's record, gap, and next‑key locks, and provides concrete SQL examples illustrating how these mechanisms prevent phantom reads and cause lock‑wait timeouts.
InnoDBMySQLdatabase
0 likes · 7 min read

This article explains the core concepts of MySQL transactions, the ACID properties, transaction states, isolation levels, multi‑version concurrency control (MVCC), and the various lock types and granularity used to ensure data consistency and concurrency control.
LocksMVCCMySQL
0 likes · 19 min read

This article explains MySQL locking mechanisms, covering lock concepts, isolation level interactions, lock granularity (row, table, page), lock types (shared, exclusive, record, gap, next-key), InnoDB row‑lock implementation, deadlock causes and remedies, and the differences between optimistic and pessimistic locking.
Database ConcurrencyInnoDBLocks
0 likes · 10 min read

This article explains how MySQL's InnoDB engine applies row‑level locks for DELETE and SELECT statements under various index configurations and isolation levels, covering MVCC, snapshot vs current reads, two‑phase locking, gap and next‑key locks, and the impact of primary, unique, non‑unique, and missing indexes.
InnoDBMVCCMySQL
0 likes · 15 min read

This article provides a comprehensive overview of MySQL fundamentals, covering transaction properties and isolation levels, MVCC mechanics, differences between InnoDB and MyISAM, query execution flow, redo and binlog, index structures, common pitfalls, and practical optimization and scaling strategies.
MVCCMySQLTransactions
0 likes · 29 min read

This article explains how MySQL implements transaction features such as atomicity, durability, and isolation by using redo logs, undo logs, lock mechanisms, and MVCC, and discusses the role of each component in ensuring data consistency and reliability.
LockMVCCMySQL
0 likes · 18 min read

This article provides a comprehensive examination of MySQL/InnoDB locking, covering MVCC, snapshot vs. current reads, cluster indexes, two‑phase locking, isolation levels, detailed lock‑behaviour for various index and isolation combinations, complex query lock analysis, and deadlock detection techniques.
InnoDBMVCCMySQL
0 likes · 23 min read

This article explains how MySQL implements transaction features such as atomicity, durability, and isolation by using redo logs, undo logs, lock mechanisms, and MVCC, detailing their roles, generation processes, and the impact of different isolation levels on data consistency.
ACIDMVCCMySQL
0 likes · 17 min read

This article explains the fundamentals of SQL Server transactions, the ACID properties, various lock types and modes, how to analyze and resolve blocking, the behavior of different isolation levels, and strategies for detecting and handling deadlocks, providing practical T‑SQL examples throughout.
DeadlocksLocksSQL Server
0 likes · 27 min read

This article explains database concurrency control mechanisms, detailing transaction fundamentals, isolation levels, associated anomalies, and how DB2, MySQL, and Oracle implement locks and isolation to ensure data consistency while balancing performance.
ConcurrencyDB2MySQL
0 likes · 15 min read

This article explains how MySQL implements transaction ACID properties by using redo logs for durability, undo logs for atomicity, lock mechanisms and MVCC for isolation, and discusses isolation levels, consistency, and practical examples with SQL code and diagrams.
LockMVCCMySQL
0 likes · 17 min read


ITPUBMar 5, 2020 · Databases
This comprehensive guide explains MySQL fundamentals, transaction handling, ACID properties, isolation levels, indexing strategies, storage engine differences, lock mechanisms, optimistic vs pessimistic locking, and techniques for optimizing large tables in production environments.
MySQLStorage EnginesTransactions
0 likes · 22 min read

This article explains how MySQL's InnoDB engine applies locks for DELETE and SELECT statements, covering MVCC, snapshot and current reads, clustered indexes, left‑most prefix rules, two‑phase locking, isolation levels, gap and next‑key locks, and analyzes nine different index‑and‑isolation scenarios with detailed conclusions.
InnoDBMVCCMySQL
0 likes · 16 min read

This guide explains MySQL fundamentals—including what a database is, transaction concepts and ACID properties, isolation levels and their effects, index structures and the left‑most prefix rule, storage engine differences, lock algorithms, and practical techniques for optimizing large tables such as partitioning and sharding.
MySQLTransactionsdatabase
0 likes · 23 min read

This article analyzes how MySQL/InnoDB applies row-level locks for DELETE and SELECT statements under various index configurations and isolation levels, explaining MVCC, current vs. snapshot reads, two‑phase locking, gap and next‑key locks, and the impact of primary, unique, non‑unique, and missing indexes.
InnoDBMVCCMySQL
0 likes · 15 min read


ITPUBOct 23, 2019 · Databases
This article systematically explains MySQL's logical server architecture, the various lock types (shared, exclusive, intention, record, gap, next‑key, insert‑intention, AUTO‑INC), transaction fundamentals, isolation levels, MVCC mechanics, and practical deadlock detection and avoidance techniques, complete with real‑world SQL examples.
LocksMVCCMySQL
0 likes · 23 min read

This article explains MySQL's locking mechanisms, comparing table‑level and row‑level locks, detailing InnoDB lock types such as shared, exclusive and intention locks, describing lock algorithms like record, gap, next‑key and insert‑intention locks, and covering lock‑related issues, transaction isolation levels, autocommit behavior, and group commit optimization.
Group CommitInnoDBMySQL
0 likes · 43 min read

This article explains the purpose and types of MySQL isolation levels, how they balance concurrency and consistency, details the concepts of record, gap, and next‑key locks, and demonstrates their behavior through multiple transaction scenarios with code examples.
Gap LocksMySQLisolation levels
0 likes · 19 min read

The article systematically explains MySQL’s locking mechanisms—including shared, exclusive, intention, gap, next‑key, insert‑intention, and auto‑increment locks—alongside transaction handling, isolation levels, MVCC‑based concurrency control, and deadlock detection and avoidance strategies, helping readers understand data consistency and performance.
LocksMVCCMySQL
0 likes · 23 min read

This article provides a comprehensive overview of MySQL’s logical server architecture, lock types, transaction fundamentals, ACID properties, isolation levels, MVCC mechanisms, and deadlock handling, including practical SQL examples and strategies for ensuring data consistency and performance.
LocksMVCCMySQL
0 likes · 19 min read


ITPUBJul 3, 2017 · Databases
This article explains MySQL's transaction fundamentals, the ACID properties, common concurrency problems such as dirty reads, non‑repeatable reads and phantom reads, and demonstrates each isolation level with step‑by‑step command‑line examples and recommendations for real‑world applications.
ACIDConcurrencyMySQL
0 likes · 13 min read

This article provides a comprehensive overview of SQL Server transaction concepts, ACID properties, lock types and escalation, blocking analysis using system DMVs, isolation level configurations, and deadlock detection and resolution, illustrated with practical code examples and diagrams.
ConcurrencyDeadlocksLocks
0 likes · 17 min read

This article explains why transactions are essential, describes the ACID properties, details MySQL's isolation levels and their effects, outlines InnoDB's redo/undo logging mechanism, and introduces distributed transaction models with two‑phase commit, providing practical examples and diagrams.
ACIDInnoDBMySQL
0 likes · 12 min read

This article provides a comprehensive overview of MySQL InnoDB's transaction lock system, covering row‑level and table‑level lock types, their flags, isolation‑level behavior, deadlock detection, and illustrative examples with SQL and source‑code snippets.
InnoDBLock TypesMySQL
0 likes · 28 min read

This article provides a comprehensive guide to MySQL performance optimization, covering isolation levels, MVCC, schema design, index strategies, query execution, partitioning, replication, scaling, hardware considerations, and backup/recovery techniques for building high‑performance, reliable database systems.
IndexingMySQLReplication
0 likes · 22 min read
