Addressing MySQL Error 1020 – SQLSTATE: HY000 (ER_CHECKREAD): A Guide to Resolving Data Inconsistencies

MySQL Error 1020, characterized by the message “Record has changed since last read in table ‘%s'”, can be a signal of underlying issues with data consistency or transaction control in your database. This error indicates that a row expected to be read has been modified by another transaction after it was last read by the current session. In this guide, we’ll explore the common causes of this error and provide practical steps to diagnose and resolve it.

Understanding Error 1020 (ER_CHECKREAD)

Error 1020 arises in scenarios where a transaction reads a record and then attempts an operation later, only to find the record has been altered by another concurrent transaction. This could be due to isolation level settings, explicit locking, or other factors affecting transaction behavior.

Diagnosing the Problem

  1. Check Isolation Levels: Understand the isolation levels at play, as they determine how transaction integrity is maintained. MySQL supports different transaction isolation levels which can be checked by:
SELECT @@GLOBAL.tx_isolation, @@tx_isolation;
  1. Review Concurrent Transactions: Look for concurrent transactions that might be accessing the same records. Ensure that your application logic handles transactions in a way that prevents conflicts.
  2. Inspect Locks: Determine if there are any locks on the records that might cause this error. MySQL provides a way to check the locks using:

This command will give you a snapshot of the InnoDB engine status, which includes information about locks.

Fixing the Error

Adjusting Isolation Levels

If the issue is related to the transaction isolation level, consider adjusting it to a more appropriate level for your use case. For example, if you are using REPEATABLE READ and experiencing phantom reads, you might switch to SERIALIZABLE:


Be aware that increasing the isolation level can impact performance due to increased locking.

Managing Concurrent Transactions

Ensure that your application logic is designed to handle concurrency appropriately. This might involve using transactions with the correct isolation level, employing locking hints where necessary, or redesigning the application flow to reduce contention.

Explicit Locking

In some cases, employing explicit locking can help manage concurrent access. For example, you can use SELECT ... FOR UPDATE to lock selected rows:

SELECT * FROM table_name WHERE condition FOR UPDATE;
-- Perform your updates or deletes here

This will lock the rows and prevent other transactions from modifying them until your transaction is committed.

Optimistic Locking

For applications that can tolerate some level of concurrency, optimistic locking might be a solution. This involves adding a version number or timestamp column to your table and checking this value before performing an update or delete:

UPDATE table_name SET column1 = value1, version = version + 1 WHERE id = some_id AND version = current_version;

If the number of affected rows is 0, this indicates a concurrent modification, and the application can handle this accordingly.


MySQL Error 1020 is a sign of a conflict between concurrent transactions trying to access the same data. To resolve this issue, it’s essential to understand the interplay between transaction isolation levels, concurrent transactions, and locking mechanisms. Adjusting isolation levels, managing transaction concurrency, and using explicit or optimistic locking are all strategies that can help maintain data consistency and prevent this error.

When dealing with transaction-related errors, always ensure that your database operations are well-tested and that your application logic is robust against concurrent data access scenarios. By following these guidelines, you can ensure the integrity of your transactions and maintain a stable and reliable database system.

Leave a Comment