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.
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.
This article explains MySQL's MVCC mechanism in InnoDB, detailing how hidden fields, undo logs, and Read Views enable lock-free snapshot reads, the differences between RC and RR isolation levels, why MVCC prevents non-repeatable reads but not phantom reads, and common pitfalls like long transactions causing undo log bloat.
This article explains how MySQL's Repeatable Read isolation level prevents phantom reads by combining MVCC snapshot reads for consistent views and Next-Key Locks (record + gap locks) to block inserts during current reads like UPDATE, detailing the ReadView mechanism, version chains, and a concrete phantom read scenario.
This article compares PostgreSQL and MySQL across complex query optimization, data types, MVCC implementation, transaction rollback capabilities, and cloud ecosystem support, explaining why PostgreSQL is increasingly preferred for complex analytics, vector search, and geospatial applications.
This article explains MySQL InnoDB's MVCC mechanism, detailing how snapshot reads and current reads work, the hidden fields that drive versioning, the Read View rules for RC and RR isolation levels, and provides hands‑on SQL demos plus common pitfalls to avoid.
This article explains why MySQL needs locks beyond MVCC snapshot reads, categorizes lock granularity, mode and design, details global, table and row‑level locks—including intention, gap, next‑key, and implicit locks—then compares pessimistic and optimistic locking, shows how to choose the right lock, and covers deadlock causes, detection, and best‑practice avoidance.
This article provides an in‑depth analysis of PostgreSQL's lock system, covering lock types, MVCC interaction, deadlock detection, advisory locks, monitoring scripts, and practical optimization techniques for production environments.
The article explains why MySQL's InnoDB engine uses REPEATABLE READ by default, clarifies the differences between snapshot and current reads, compares RC and RR isolation levels, details MVCC mechanics, and provides a concise interview answer template with practical SQL examples.
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.
The article explains that MVCC in MySQL InnoDB prevents phantom reads for snapshot (ordinary SELECT) queries by using ReadView, while write‑conflict scenarios that appear as phantom reads are handled by unique index checks and gap locks, highlighting the distinction between snapshot and current reads.
The article explains why developers should move beyond MySQL to PostgreSQL, illustrating the productivity gains of native window functions, MVCC concurrency, rich indexing, JSONB support, and extensive extensions through detailed examples, installation guides, performance comparisons, and real‑world use cases.
The article explains why many developers stuck with MySQL should consider PostgreSQL, highlighting its superior SQL standards support, MVCC concurrency, rich indexing, JSONB performance, full‑text search, extensive extensions, and practical installation and Java integration steps, while also comparing pros, cons, and ideal use cases.
The article compares PostgreSQL and MySQL, highlighting PostgreSQL's richer data types, extensible ecosystem, advanced replication and monitoring features, while exposing MySQL's limitations in data modeling, sequence support, tooling, and replication, and concludes that the best choice depends on specific workload requirements.
The article compares PostgreSQL and MySQL across data types, native sequences, extensions, monitoring tools, replication mechanisms, licensing, community governance, and MVCC implementation, showing why many Chinese tech giants favor PostgreSQL for complex, high‑consistency workloads while acknowledging MySQL’s strengths in simple web scenarios.
The article analyzes why many Chinese cloud providers and enterprises prefer PostgreSQL to MySQL, detailing PostgreSQL's richer data types, native sequence support, extensible ecosystem, advanced monitoring, robust replication, open licensing, and MVCC implementation, while acknowledging MySQL's remaining advantages in specific scenarios.
This comprehensive guide explores PostgreSQL 17's lock mechanisms, covering lock classifications, table‑ and row‑level lock behavior, MVCC interaction, common pitfalls such as deadlocks and lock contention, and provides practical SQL queries, Bash monitoring scripts, advisory‑lock techniques, and best‑practice recommendations for performance tuning and reliable production deployment.
The article analyzes why many leading Chinese tech firms adopt PostgreSQL despite MySQL’s popularity, detailing PostgreSQL’s richer data types, native sequence support, extensible ecosystem, advanced monitoring tools, robust replication, open‑source licensing, and MVCC implementation, while also acknowledging MySQL’s strengths in simple deployment and read‑heavy workloads.
Lance uses Multi-Version Concurrency Control to provide ACID guarantees, creating immutable table versions on each commit and employing atomic storage primitives, rebase logic, and retry mechanisms to handle concurrent writes, conflict detection, and resolution across multiple transaction types.
The article examines why major Chinese cloud and technology providers are building distributed, cloud‑native or HTAP databases on PostgreSQL instead of MySQL, detailing differences in data types, sequences, extensions, monitoring, replication, licensing, and MVCC implementation.
Facing mysterious minute‑level data rollbacks caused by Impala's metadata cache, a team migrated from a T+1 Hive‑Impala stack to Apache Doris, achieving real‑time consistency, higher performance, simplified ETL, and reduced operational complexity across their points‑based loyalty system.
The article compares PostgreSQL and MySQL, detailing PostgreSQL’s richer data types, true sequence support, extensible ecosystem, advanced monitoring and replication features, while also acknowledging MySQL’s simplicity and strong points, to help readers decide which database fits their workload best.
The article compares PostgreSQL and MySQL, highlighting PostgreSQL's richer data types, true sequence support, powerful extensions, built‑in monitoring, advanced replication, open‑source licensing, and MVCC implementation, while acknowledging MySQL's strengths in quick deployment and read‑heavy workloads.
This article offers a thorough source‑code walkthrough of etcd v3.5+, revealing how its Go‑based architecture implements the Raft consensus algorithm, MVCC storage with BoltDB, efficient network communication via rafthttp, and Go concurrency patterns, while providing practical operational insights for performance tuning and reliability.
The article compares PostgreSQL and MySQL across data types, sequence handling, extensions, monitoring tools, replication, licensing, and MVCC implementation, showing why many Chinese tech giants prefer PostgreSQL for complex, high‑availability workloads while acknowledging MySQL’s strengths in simple web scenarios.
This article equips Go backend developers with deep, interview‑ready knowledge of database internals—covering how indexes truly work, why queries can still be slow, transaction isolation levels, lock types, MVCC mechanics, and connection‑pool tuning—to avoid performance pitfalls and stand out in technical interviews.
An in‑depth comparison of PostgreSQL and MySQL examines how primary and secondary indexes are implemented, contrasts query execution costs, explores data type impacts, explains MVCC undo logs, and discusses process versus thread architectures, highlighting performance trade‑offs for each system.
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.
This article explains why MySQL uses Multi-Version Concurrency Control, how it replaces traditional locking, the inner workings of hidden fields, undo logs, and read views, and details each transaction isolation level with practical SQL examples and common anomalies such as dirty, non‑repeatable, and phantom reads.
This article deeply explores MySQL transaction isolation levels, explaining ACID principles, the three concurrency problems (dirty read, non‑repeatable read, phantom read), the SQL standard isolation tiers, InnoDB's MVCC and locking mechanisms, practical implementation details for each level, and guidance on choosing and configuring the appropriate isolation level for real‑world applications.
This article provides detailed explanations of ten core MySQL topics—including InnoDB lock upgrades, redo log mechanics, MVCC version chains, tablespace types, page splitting, optimizer plan selection, crash recovery, binlog vs redo log, adaptive hash index, and memory management—along with practical tips for avoiding pitfalls and tuning performance.
This article walks through ten essential MySQL InnoDB interview questions, covering why InnoDB uses B+ trees, MVCC isolation levels, two‑phase commit, gap locks, buffer‑pool LRU design, undo‑log mechanics, binlog formats, lock‑upgrade behavior, double‑write buffering, and the differences between clustered and non‑clustered indexes.
An in‑depth post‑mortem of a JED database incident reveals how its lock matrix and MVCC isolation caused metric data loss, explains the underlying lock granularity, transaction isolation levels, and MVCC visibility rules, and proposes short‑term distributed‑lock and long‑term read‑calc‑write solutions.
This comprehensive guide walks you through MySQL InnoDB's core architecture, storage structures, indexing mechanisms, transaction and concurrency control, crash recovery, backup options, and practical performance‑tuning techniques, providing clear explanations and real‑world SQL examples.
A detailed investigation reveals that MySQL's lock matrix and MVCC‑based transaction isolation caused a concurrent synchronization job to lose metric and dimension data, and proposes a distributed‑lock solution together with a long‑term read‑calc‑write refactor to eliminate the issue.
This article explains MySQL's four transaction isolation levels, the concurrency problems they address, how MVCC works, and provides practical guidance on selecting the appropriate level based on business requirements and performance trade‑offs.
This article explains Apache Hudi's architecture, including its timeline mechanism, file layout, indexing strategies, table types (COW and MOR), query options, storage format versioning, backward compatibility, and key configuration settings for managing data lake tables.
Lamport Clocks provide a lightweight logical timestamp mechanism that captures the 'happens‑before' relationship between events, enabling causal ordering across distributed replicas, supporting versioned keys, MVCC storage, partial ordering, and highlighting both practical applications and inherent limitations in real‑world systems.
This article deeply explores MySQL's transaction isolation levels, explaining ACID properties, the four standard isolation levels, their phenomena such as dirty, non‑repeatable, and phantom reads, and how InnoDB implements them using MVCC, undo/redo logs, and various lock mechanisms.
The article explains the Copy‑On‑Write (COW) technique, its read‑write separation design, step‑by‑step flow, practical demos, Java's CopyOnWriteArrayList implementation, and MySQL InnoDB MVCC usage, while also discussing its performance benefits and inherent limitations.
This article explains the concept of Versioned Value, how multi‑version storage supports MVCC and time‑travel queries, and how it resolves write conflicts in single‑leader replication through WAL logs, high‑water marks, and skip‑list indexing, while also discussing its limitations.
This article compares PostgreSQL and MySQL by examining their index structures, query execution costs, data‑type impacts, undo‑log mechanisms, and process models, highlighting where each system excels or falls short in real‑world workloads.
This article provides a deep dive into MySQL’s architecture, covering the InnoDB storage engine’s layered structure, index design and usage, query execution plans, deep pagination challenges, slow‑query diagnostics, transaction processing, MVCC isolation, and the roles of undo, redo and binary logs.
This article explains MySQL’s index structures, SQL execution plan analysis, query execution flow, transaction isolation levels, MVCC mechanisms, and InnoDB buffer‑pool caching, providing detailed diagrams and practical examples to help developers optimize database performance.
This article explains MySQL's three concurrency types—read‑read, read‑write, and write‑write—describes how InnoDB uses MVCC, shared and exclusive locks, and provides practical examples and code for handling update‑loss and write‑write conflicts with optimistic and pessimistic locking.
The article explains how PostgreSQL’s MVCC model, tuple visibility, and 32‑bit transaction ID wrap‑around can cause “sudden death” of old rows, why billions of old transactions may render data invisible, and how vacuuming and freezing prevent catastrophic database failures.
This article explains MySQL’s transaction isolation mechanisms, compares the four isolation levels with concrete examples, shows how they affect phenomena like dirty reads, non‑repeatable reads and phantom reads, and provides practical guidance on configuring and avoiding long transactions.
After publishing 50 installments of the 'MySQL Core Modules' series covering transactions, locks, and undo, the author expresses gratitude to readers and the community, outlines upcoming articles on Undo, MVCC, and Redo, and reviews past content while planning a compiled book.
This comprehensive guide explains MySQL's underlying index structures (B‑tree, B+‑tree, hash), how execution plans are generated and interpreted, the mechanics of query execution, the role of locks and transaction isolation levels, the MVCC model, and the InnoDB buffer‑pool caching strategy.
This article explains MySQL InnoDB's multi-version concurrency control (MVCC), covering its basic concepts, hidden columns, isolation levels, the creation and evaluation of Read Views, and includes detailed source code examples and step‑by‑step experiments to illustrate transaction visibility.
This article compiles 40 core MySQL interview questions covering ACID properties, lock types, views, stored procedures, JOINs, storage engines, query optimization, buffer pools, write buffers, transaction mechanisms, MVCC, isolation levels, gap locks, metadata locks, thread model, row formats, and more, providing concise answers for each.
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.
This article provides a comprehensive technical guide on MySQL internals, covering the underlying data structures of indexes (B‑tree, B+‑tree, hash), how execution plans are generated and interpreted, the four transaction isolation levels, MVCC implementation, and the InnoDB buffer‑pool architecture.
This article investigates whether the REPEATABLE‑READ isolation level in InnoDB fully prevents phantom reads by conducting a series of current‑read and snapshot‑read experiments, analyzing transaction behavior, MVCC mechanisms, and offering recommendations to avoid phantom anomalies.
This article provides a comprehensive overview of concurrency control in Apache Hudi, explaining ACID properties, the role of MVCC and OCC, and how Hudi coordinates multiple writers and table services to achieve serializable scheduling while maintaining high performance.
This article examines whether the REPEATABLE‑READ isolation level in InnoDB fully prevents phantom reads by conducting systematic current‑read and snapshot‑read experiments, analyzing lock mechanisms, MVCC behavior, and presenting detailed SQL scripts, results, and recommendations for avoiding phantom reads.
A mock interview walks through MySQL transaction fundamentals, ACID principles, MVCC mechanics, undo log structures, and the differences between Read Committed and Repeatable Read isolation levels, illustrating each concept with code snippets and diagrams.
Through a series of MySQL 8.0 experiments, the article demonstrates that InnoDB inserts run concurrently, explains why phantom reads can appear, and details how MVCC, insert‑intention locks, and the ReadView mechanism together prevent phantom read anomalies.
This article provides a comprehensive overview of MySQL internals, covering index data structures such as B‑tree and B+‑tree, the differences between MyISAM and InnoDB indexes, SQL execution plan analysis, transaction isolation levels, lock mechanisms, MVCC implementation, and the InnoDB buffer‑pool caching process.
This article provides a comprehensive analysis of TiDB's PointGet operator, detailing its execution flow in the TiKV storage layer, including protobuf interfaces, read‑through lock handling, snapshot creation, MVCC logic, and the integration of the Titan plugin for large values.
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.
This article explains the various read and write anomalies that can occur during concurrent database transactions—such as dirty reads, nonrepeatable reads, phantom reads, lost updates, dirty writes, and write skew—and outlines isolation levels and practical techniques like MVCC, atomic updates, explicit locking, and compare‑and‑set to prevent them.
This comprehensive guide explores MySQL transaction fundamentals, the ACID properties, various isolation levels, concurrency issues like dirty, non‑repeatable, and phantom reads, and dives deep into MVCC implementation, hidden fields, undo logs, and read views to help developers write reliable, consistent database code.
This article explains MySQL's transaction implementation, covering write‑ahead logging, transaction IDs, multi‑version concurrency control, buffer pool management, and the roles of redo and undo logs in ensuring durability and atomicity.
This article explains MySQL InnoDB's concurrency control mechanisms—including read‑write locks, transaction isolation levels, MVCC, redo/undo logs, and rollback segments—and shows how they work together to ensure data consistency while maximizing read/write performance in high‑traffic environments.
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.
This article examines why PostgreSQL appears to outrank MySQL in recent popularity surveys, explains the DB‑Engines ranking methodology, compares architectural choices such as MVCC, multi‑process vs multi‑thread models, transaction rollback behavior, licensing, and real‑world performance benchmarks like TPC‑C, ultimately revealing that MySQL still dominates many high‑throughput OLTP scenarios.
The article evaluates database success by comparing PostgreSQL and MySQL across popularity, features, licensing, transaction behavior, MVCC, concurrency models, and use cases, showing PostgreSQL leads in complex queries and feature richness while MySQL remains the most widely used OLTP system, especially in China.
This article explains MySQL InnoDB's multi-version concurrency control (MVCC), detailing how transaction isolation levels such as read‑committed and repeatable‑read create snapshots, how undo logs and hidden columns form version chains, and walks through concrete examples to show which row values are visible to concurrent transactions.
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.
This article explains the fundamentals of database transactions, the ACID properties, and how InnoDB uses redo and undo logs together with MVCC to ensure atomicity, consistency, isolation, durability, and reliable crash recovery.
This article explains how Apache CouchDB achieves eventual consistency through its MVCC architecture, CAP theorem trade‑offs, incremental replication, and document‑level versioning, illustrating concepts such as local consistency, conflict resolution, and practical use‑cases for building scalable distributed systems.
This article explains how InnoDB’s REPEATABLE READ isolation level uses MVCC and gap locks to prevent most phantom reads, illustrates the mechanisms with SQL examples and diagrams, and outlines the remaining edge cases and best practices for fully avoiding phantom reads.
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.
This article explains what a database transaction is, details the ACID properties, compares MySQL's four isolation levels, clarifies why Repeatable Read is the default due to binlog formats and consistency, examines concurrency anomalies of each level, and provides practical guidance on handling large transactions, optimizing performance, and understanding InnoDB's MVCC implementation.
This article explains MySQL’s internal architecture, walks through how a SELECT query and an UPDATE statement are processed—including the connector, parser, optimizer, executor, redo log, binlog, and two‑phase commit—and details transaction properties, isolation levels, MVCC, and related configuration parameters.
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.
This article explains MySQL's transaction concepts, the four isolation levels—READ UNCOMMITTED, READ COMMITTED, REPEATABLE READ, and SERIALIZABLE—detailing their effects on dirty reads, non‑repeatable reads and phantom reads, how they are implemented with locks and MVCC, and provides practical SQL examples and diagrams.
This article explains the ACID properties of database transactions, clarifies the often‑confused concepts of consistency and isolation, details the four SQL standard isolation levels, compares lock‑based and MVCC concurrency controls, and examines concrete implementations in MySQL, PostgreSQL, and the distributed TDSQL system.
This article explains MySQL 5.7 InnoDB's four isolation levels, the structure and purpose of undo logs, the mechanics of multi‑version concurrency control (MVCC), read‑view creation and closure, and why REPEATABLE READ still allows phantom reads, illustrated with code examples.
This article explains how MySQL's InnoDB engine guarantees ACID properties by describing the four components of ACID, the four isolation levels, lock granularity and types, the MVCC mechanism with version chains and read views, and the roles of undo, redo, and bin logs in ensuring atomicity, consistency, isolation, and durability.
This article provides a comprehensive technical overview of MySQL's underlying index structures, SQL execution plan analysis, transaction isolation levels, MVCC concurrency control, and the InnoDB buffer pool mechanism, illustrating each concept with diagrams and practical SQL examples.
MVCC (Multiversion Concurrency Control) in MySQL InnoDB uses undo logs and read views to provide non‑locking snapshot reads, managing read‑write, write‑write, and read‑read concurrency, with implicit row fields and transaction IDs determining visibility across isolation levels.
This article explains MySQL's three concurrency types—read‑read, read‑write, and write‑write—describes how InnoDB uses shared/exclusive locks, MVCC snapshot reads, and ReadView metadata to ensure transaction isolation, and provides practical examples and lock‑based solutions for avoiding update loss.
This article explores how to achieve data consistency by examining transaction properties, isolation levels, common concurrency issues like dirty, non-repeatable, and phantom reads, and compares lock‑based concurrency control with multi‑version concurrency control (MVCC), detailing undo logs, read‑view mechanisms, and practical examples.
This article demystifies MySQL's Multi‑Version Concurrency Control (MVCC) by explaining its Undo Log and Read View mechanisms, showing how InnoDB implements read‑committed and repeatable‑read isolation without locking, and illustrating the process with clear examples and diagrams.
The article explains how snapshot isolation and multi-version concurrency control (MVCC) address read skew and nonrepeatable reads in databases, detailing transaction IDs, version visibility rules, implementation differences across PostgreSQL, MySQL, Oracle, and the impact on backups, analytics, and index handling.
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.
This article provides a comprehensive, step‑by‑step explanation of MySQL InnoDB's MVCC mechanism, covering its fundamentals, the role of Undo Log and Read View, and how it enables repeatable‑read and read‑committed isolation levels while preventing dirty reads and other concurrency anomalies.
This article breaks down how MySQL's InnoDB engine guarantees the four ACID properties—atomicity, consistency, isolation, and durability—by leveraging undo and redo logs, the binary log, hidden transaction metadata, and MVCC with ReadView, illustrating each mechanism with concrete examples.
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.
This article explains why PostgreSQL data loss occurs, compares DDL and DML causes, and reviews several recovery tools—including pg_resetwal, pg_dirtyread, pg_recovery, pg_filedump, WalMiner, and pageinspect—providing usage examples, summaries, and practical recommendations for effective data restoration.
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.
This article examines workload analysis and query performance differences between PostgreSQL and MySQL, focusing on JSON handling, indexing strategies, concurrency control, benchmark results, and replication features, while offering configuration tips to improve each database’s speed and efficiency.
This article explains how MySQL InnoDB implements locking, the two‑phase lock protocol, the four transaction isolation levels, the differences between pessimistic and optimistic locks, MVCC implementation, and how next‑key and gap locks prevent phantom reads in high‑concurrency environments.
This article provides an in‑depth explanation of MySQL InnoDB’s transaction system, covering ACID properties, isolation levels, MVCC implementation, various lock types, key data structures, lock acquisition flows, semi‑consistent reads, insert locking, implicit‑to‑explicit lock conversion, and rollback mechanisms.
This article explains the MySQL InnoDB undo log—its definition, role in transaction rollback and MVCC, when it is created, where and how it is stored across different MySQL versions, the internal tablespace and rollback‑segment structures, log types, and real‑world examples of its usage.
This article explains the fundamentals of MVCC, transaction isolation levels, and related concepts such as ACID properties, dirty reads, non‑repeatable reads, phantom reads, hidden columns, undo logs, version chains, read views, and demonstrates how InnoDB implements these mechanisms with practical SQL examples and diagrams.
This article explains how MySQL handles concurrent transactions using MVCC, lock mechanisms, and various isolation levels, detailing dirty writes, dirty reads, non‑repeatable reads, phantom reads, and the internal structures such as ReadView that enable reliable data consistency.
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.
