Amazon Web Services has handed a binary log improvement called BOLT (Binary Log Optimization for Large Transactions) to the MySQL open source project. The AWS Database Blog described the work on November 2, 2026, and the matching pull request on the mysql-server GitHub repository was taken into Oracle's internal bug tracker on October 29.
The change targets an old pain point. When binary logging is on, one huge transaction can hold up all other commits on the server while its events are written out. BOLT removes that stall, and AWS says the feature is planned for a future MySQL Innovation release.
The Problem BOLT Solves
In stock MySQL, each transaction collects its binlog events in a per-session cache. Once the events grow past binlog_cache_size, which defaults to 32 KiB, the overflow goes to a temporary spill file on disk. Building these caches happens in parallel, so it is cheap.
The expensive part comes at commit. To keep the binlog in strict order, MySQL takes a global lock on the active binlog file and copies the transaction's events into it. Any other session that wants to commit must wait, even if it touches completely different tables.
For small transactions this wait is tiny. For a transaction carrying tens of gigabytes, the copy can run for minutes. AWS gives the example of a 50 GiB change at roughly 120 MB/s, which keeps the lock for about seven minutes and also needs twice the disk space while the copy runs.
How BOLT Works
BOLT skips the copy entirely. When a large transaction commits, its spill file is renamed into the binlog sequence as the next binlog file and registered in the binlog index. This reuses the routine MySQL already uses for binlog file rotation.
The result is a commit cost that stays roughly flat no matter how big the transaction is. Because the events live in one place instead of two, the extra disk space is gone as well. Smaller transactions keep using the normal commit path.
A promoted file starts with a new event type named Large_transaction_header_event. It stores the position of the transaction's final event, so crash recovery can jump straight to the end instead of reading the whole body. The event is marked as ignorable, so older replicas, mysqlbinlog and change data capture tools such as Debezium or AWS DMS simply skip it.
Key Details and Settings
According to the AWS post and the pull request description, the feature is controlled by a small set of new variables:
- binlog_large_transaction_optimization_enabled: a dynamic switch that is ON by default.
- binlog_large_transaction_optimization_threshold: the size above which a transaction is promoted, 128 MB by default with a 10 MiB minimum.
- Binlog_large_transaction_optimization_count: a status counter showing how many transactions were promoted.
- Binlog_large_transaction_optimization_missed_count: a second counter listed in the pull request.
When source_verify_checksum is ON, recovery still reads the transaction in sequence rather than seeking past it. Aurora MySQL has run the same approach in production since version 1.22.0 in late 2019, and it is always on in Aurora MySQL 2.x, 3.x and 8.4.
Benchmark Results Reported by AWS
AWS tested a build of the MySQL trunk branch from October 2026 on a 64 vCPU EC2 instance with sysbench. These are vendor numbers from a controlled setup, so real workloads will differ.
- Commit time for a 50 GiB transaction fell from about 7 minutes to about 2.5 seconds.
- Binlog crash recovery for the same size dropped from about 4 minutes to around 0.1 seconds.
- Throughput rose roughly 3.1 times when every transaction was 5 GiB and about 2.8 times on a mixed workload.
What It Means for Developers
If you run MySQL with binary logging for replication or point-in-time recovery, a single bulk load or mass update can freeze unrelated OLTP traffic today. BOLT should make those spikes far less painful once it lands in a community release, with no application change needed.
It does not make huge transactions a good idea. AWS itself still advises splitting large jobs into smaller batches, because replicas apply a big transaction as one unit. With replica_preserve_commit_order enabled, other transactions on the replica must wait for it to finish, which causes lag.
The same advice about commit size and transaction behaviour applies across most relational databases.
Teams that run CDC pipelines should note the new event type. Tools are expected to skip it, but it is worth testing your Debezium or replication consumers against a build that includes BOLT before upgrading production.
How to Get It
Aurora MySQL users already have BOLT, enabled by default. Community MySQL and Amazon RDS for MySQL users will need to wait for the Innovation release that ships it, since Oracle has not yet named a version number.
Until then, keep an eye on the MySQL release notes and on the BOLT project tracker on GitHub. When the release arrives, check the new status counters after your next bulk job to confirm promotions are happening.
Conclusion
BOLT turns the commit of a very large MySQL transaction from a size-dependent copy under a global lock into a quick file promotion. It cuts commit and recovery delays sharply and helps mixed workloads. It is a welcome upstream contribution, though splitting big jobs into smaller batches remains good practice.
Sources
- AWS Database Blog: AWS contributes a large-transaction binary log optimization to MySQL
- GitHub mysql/mysql-server pull request 722: Optimize binlog handling of large transactions (BOLT)
See my articles more often when you search Google.
