MDEV-22126 Rename confusing constant mtr_t::OPT

The template parameter mtr_t::OPT refers to optional, not optimized.
Also the default parameter mtr_t::NORMAL refers to optimized writes.
The name MAYBE_NOP would be more descriptive, conveying the idea
that a write to a durable page might not actually have any effect.

23 files changed, 156 insertions, 142 deletions

diff --git a/storage/innobase/btr/btr0btr.cc b/storage/innobase/btr/btr0btr.cc
index 651b9dc6efe..5746ac05817 100644
--- a/storage/innobase/btr/btr0btr.cc
+++ b/storage/innobase/btr/btr0btr.cc
@@ -460,10 +460,11 @@ btr_page_create(
         mtr->memset(block, FIL_RTREE_SPLIT_SEQ_NUM, 8, 0);
     }
     /* Set the level of the new index page */
-    mtr->write<2,mtr_t::OPT>(*block,
-                             my_assume_aligned<2>(PAGE_HEADER + PAGE_LEVEL +
-                                                  block->frame), level);
-    mtr->write<8,mtr_t::OPT>(*block, index_id, index->id);
+    mtr->write<2,mtr_t::MAYBE_NOP>(*block,
+                                   my_assume_aligned<2>(PAGE_HEADER +
+                                                        PAGE_LEVEL +
+                                                        block->frame), level);
+    mtr->write<8,mtr_t::MAYBE_NOP>(*block, index_id, index->id);
   }
 }
 
@@ -979,7 +980,8 @@ static void btr_free_root(buf_block_t *block, mtr_t *mtr, bool invalidate)
     constexpr uint16_t field= PAGE_HEADER + PAGE_INDEX_ID;
 
     byte *page_index_id= my_assume_aligned<2>(field + block->frame);
-    if (mtr->write<8,mtr_t::OPT>(*block, page_index_id, BTR_FREED_INDEX_ID) &&
+    if (mtr->write<8,mtr_t::MAYBE_NOP>(*block, page_index_id,
+                                       BTR_FREED_INDEX_ID) &&
         UNIV_LIKELY_NULL(block->page.zip.data))
       memcpy_aligned<2>(&block->page.zip.data[field], page_index_id, 8);
   }
@@ -1137,9 +1139,10 @@ btr_create(
 			}
 		}
 		/* Set the level of the new index page */
-		mtr->write<2,mtr_t::OPT>(*block, PAGE_HEADER + PAGE_LEVEL
-					 + block->frame, 0U);
-		mtr->write<8,mtr_t::OPT>(*block, page_index_id, index_id);
+		mtr->write<2,mtr_t::MAYBE_NOP>(*block, PAGE_HEADER + PAGE_LEVEL
+					       + block->frame, 0U);
+		mtr->write<8,mtr_t::MAYBE_NOP>(*block, page_index_id,
+					       index_id);
 	}
 
 	/* We reset the free bits for the page in a separate
@@ -1724,8 +1727,8 @@ btr_page_empty(
 					    8, 0);
 			}
 		}
-		mtr->write<2,mtr_t::OPT>(*block, PAGE_HEADER + PAGE_LEVEL
-					 + block->frame, level);
+		mtr->write<2,mtr_t::MAYBE_NOP>(*block, PAGE_HEADER + PAGE_LEVEL
+					       + block->frame, level);
 		if (autoinc) {
 			mtr->write<8>(*block, PAGE_HEADER + PAGE_MAX_TRX_ID
 				      + block->frame, autoinc);
@@ -1786,8 +1789,8 @@ void btr_set_instant(buf_block_t* root, const dict_index_t& index, mtr_t* mtr)
 	if (index.table->instant) {
 		mtr->memset(root, infimum - root->frame, 8, 0);
 		mtr->memset(root, supremum - root->frame, 7, 0);
-		mtr->write<1,mtr_t::OPT>(*root, &supremum[7],
-					 index.n_core_null_bytes);
+		mtr->write<1,mtr_t::MAYBE_NOP>(*root, &supremum[7],
+					       index.n_core_null_bytes);
 	}
 }
 
@@ -1807,10 +1810,10 @@ void btr_reset_instant(const dict_index_t &index, bool all, mtr_t *mtr)
     {
       ut_ad(mach_read_from_2(page_type) == FIL_PAGE_TYPE_INSTANT ||
             mach_read_from_2(page_type) == FIL_PAGE_INDEX);
-      mtr->write<2,mtr_t::OPT>(*root, page_type, FIL_PAGE_INDEX);
+      mtr->write<2,mtr_t::MAYBE_NOP>(*root, page_type, FIL_PAGE_INDEX);
       byte *instant= PAGE_INSTANT + PAGE_HEADER + root->frame;
-      mtr->write<2,mtr_t::OPT>(*root, instant,
-                               page_ptr_get_direction(instant + 1));
+      mtr->write<2,mtr_t::MAYBE_NOP>(*root, instant,
+                                     page_ptr_get_direction(instant + 1));
     }
     else
       ut_ad(mach_read_from_2(page_type) == FIL_PAGE_TYPE_INSTANT);
@@ -1828,9 +1831,10 @@ void btr_reset_instant(const dict_index_t &index, bool all, mtr_t *mtr)
     }
     ut_ad(!memcmp(&root->frame[infimum], supremuminfimum + 8, 8) ==
           !memcmp(&root->frame[supremum], supremuminfimum, 8));
-    mtr->memcpy<mtr_t::OPT>(*root, &root->frame[infimum], supremuminfimum + 8,
-                            8);
-    mtr->memcpy<mtr_t::OPT>(*root, &root->frame[supremum], supremuminfimum, 8);
+    mtr->memcpy<mtr_t::MAYBE_NOP>(*root, &root->frame[infimum],
+                                  supremuminfimum + 8, 8);
+    mtr->memcpy<mtr_t::MAYBE_NOP>(*root, &root->frame[supremum],
+                                  supremuminfimum, 8);
   }
 }
 
diff --git a/storage/innobase/btr/btr0bulk.cc b/storage/innobase/btr/btr0bulk.cc
index 9873f30aa45..4fdae95c173 100644
--- a/storage/innobase/btr/btr0bulk.cc
+++ b/storage/innobase/btr/btr0bulk.cc
@@ -97,9 +97,9 @@ PageBulk::init()
 			page_create(new_block, &m_mtr,
 				    m_index->table->not_redundant());
 			m_mtr.memset(*new_block, FIL_PAGE_PREV, 8, 0xff);
-			m_mtr.write<2,mtr_t::OPT>(*new_block,
-						  PAGE_HEADER + PAGE_LEVEL
-						  + new_page, m_level);
+			m_mtr.write<2,mtr_t::MAYBE_NOP>(*new_block, PAGE_HEADER
+							+ PAGE_LEVEL
+							+ new_page, m_level);
 			m_mtr.write<8>(*new_block, index_id, m_index->id);
 		}
 	} else {
diff --git a/storage/innobase/btr/btr0cur.cc b/storage/innobase/btr/btr0cur.cc
index 8a547669894..69bd2ecff0b 100644
--- a/storage/innobase/btr/btr0cur.cc
+++ b/storage/innobase/btr/btr0cur.cc
@@ -3985,7 +3985,7 @@ static void btr_cur_upd_rec_sys(buf_block_t *block, rec_t *rec,
   }
 
   if (UNIV_LIKELY(len)) /* extra safety, to avoid corrupting the log */
-    mtr->memcpy<mtr_t::OPT>(*block, dest, sys + d, len);
+    mtr->memcpy<mtr_t::MAYBE_NOP>(*block, dest, sys + d, len);
 }
 
 /*************************************************************//**
@@ -4128,9 +4128,10 @@ void btr_cur_upd_rec_in_place(rec_t *rec, const dict_index_t *index,
 				       ? -REC_NEW_INFO_BITS
 				       : -REC_OLD_INFO_BITS];
 
-		mtr->write<1,mtr_t::OPT>(*block, info_bits,
-			      (*info_bits & ~REC_INFO_BITS_MASK)
-			      | update->info_bits);
+		mtr->write<1,mtr_t::MAYBE_NOP>(*block, info_bits,
+					       (*info_bits
+						& ~REC_INFO_BITS_MASK)
+					       | update->info_bits);
 	}
 
 	for (ulint i = 0; i < update->n_fields; i++) {
@@ -4192,8 +4193,8 @@ void btr_cur_upd_rec_in_place(rec_t *rec, const dict_index_t *index,
 		}
 
 		if (len) {
-			mtr->memcpy<mtr_t::OPT>(*block, data, uf->new_val.data,
-						len);
+			mtr->memcpy<mtr_t::MAYBE_NOP>(*block, data,
+						      uf->new_val.data, len);
 		}
 	}
 
@@ -5307,7 +5308,7 @@ void btr_rec_set_deleted(buf_block_t *block, rec_t *rec, mtr_t *mtr)
     const byte v = flag
       ? (*b | REC_INFO_DELETED_FLAG)
       : (*b & byte(~REC_INFO_DELETED_FLAG));
-    mtr->write<1,mtr_t::OPT>(*block, b, v);
+    mtr->write<1,mtr_t::MAYBE_NOP>(*block, b, v);
   }
 }
 
@@ -6958,9 +6959,8 @@ btr_cur_set_ownership_of_extern_field(
 		mach_write_to_1(data + local_len + BTR_EXTERN_LEN, byte_val);
 		page_zip_write_blob_ptr(block, rec, index, offsets, i, mtr);
 	} else {
-		mtr->write<1,mtr_t::OPT>(*block,
-					 data + local_len + BTR_EXTERN_LEN,
-					 byte_val);
+		mtr->write<1,mtr_t::MAYBE_NOP>(*block, data + local_len
+					       + BTR_EXTERN_LEN, byte_val);
 	}
 }
 
@@ -7488,7 +7488,7 @@ next_zip_page:
 					store_len = extern_len;
 				}
 
-				mtr.memcpy<mtr_t::OPT>(
+				mtr.memcpy<mtr_t::MAYBE_NOP>(
 					*block,
 					FIL_PAGE_DATA + BTR_BLOB_HDR_SIZE
 					+ block->frame,
@@ -7514,7 +7514,7 @@ next_zip_page:
 
 				if (prev_page_no == FIL_NULL) {
 					ut_ad(blob_npages == 0);
-					mtr.write<4,mtr_t::OPT>(
+					mtr.write<4,mtr_t::MAYBE_NOP>(
 						*rec_block,
 						field_ref + BTR_EXTERN_SPACE_ID,
 						space_id);
@@ -7748,9 +7748,10 @@ btr_free_externally_stored_field(
 				mtr.write<4>(*block,
 					     BTR_EXTERN_PAGE_NO + field_ref,
 					     next_page_no);
-				mtr.write<4,mtr_t::OPT>(*block,
-							BTR_EXTERN_LEN + 4
-							+ field_ref, 0U);
+				mtr.write<4,mtr_t::MAYBE_NOP>(*block,
+							      BTR_EXTERN_LEN
+							      + 4 + field_ref,
+							      0U);
 			}
 		} else {
 			ut_ad(!block->page.zip.data);
@@ -7768,9 +7769,9 @@ btr_free_externally_stored_field(
 			trx_rollback_all_recovered() could
 			dereference the half-deleted BLOB, fetching a
 			wrong prefix for the BLOB. */
-			mtr.write<4,mtr_t::OPT>(*block,
-						BTR_EXTERN_LEN + 4 + field_ref,
-						0U);
+			mtr.write<4,mtr_t::MAYBE_NOP>(*block,
+						      BTR_EXTERN_LEN + 4
+						      + field_ref, 0U);
 		}
 
 		/* Commit mtr and release the BLOB block to save memory. */
diff --git a/storage/innobase/dict/dict0crea.cc b/storage/innobase/dict/dict0crea.cc
index f7bd584129d..a5a7fe9f2d7 100644
--- a/storage/innobase/dict/dict0crea.cc
+++ b/storage/innobase/dict/dict0crea.cc
@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 1996, 2016, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2017, 2019, MariaDB Corporation.
+Copyright (c) 2017, 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -377,11 +377,11 @@ dict_build_table_def_step(
 				page_id_t(trx->rsegs.m_redo.rseg->space->id,
 					  undo->hdr_page_no),
 				&mtr);
-			mtr.write<1,mtr_t::OPT>(
+			mtr.write<1,mtr_t::MAYBE_NOP>(
 				*block,
 				block->frame + undo->hdr_offset
 				+ TRX_UNDO_DICT_TRANS, 1U);
-			mtr.write<8,mtr_t::OPT>(
+			mtr.write<8,mtr_t::MAYBE_NOP>(
 				*block,
 				block->frame + undo->hdr_offset
 				+ TRX_UNDO_TABLE_ID, trx->table_id);
@@ -858,8 +858,8 @@ dict_create_index_tree_step(
 					     DICT_FLD__SYS_INDEXES__PAGE_NO,
 					     &len);
 	ut_ad(len == 4);
-	mtr.write<4,mtr_t::OPT>(*btr_pcur_get_block(&pcur), data,
-				node->page_no);
+	mtr.write<4,mtr_t::MAYBE_NOP>(*btr_pcur_get_block(&pcur), data,
+				      node->page_no);
 
 	mtr.commit();
 
diff --git a/storage/innobase/dict/dict0dict.cc b/storage/innobase/dict/dict0dict.cc
index c4e279a01f4..885437061c5 100644
--- a/storage/innobase/dict/dict0dict.cc
+++ b/storage/innobase/dict/dict0dict.cc
@@ -4315,8 +4315,8 @@ dict_index_set_merge_threshold(
 			DICT_FLD__SYS_INDEXES__MERGE_THRESHOLD, &len);
 
 		ut_ad(len == 4);
-		mtr.write<4,mtr_t::OPT>(*btr_cur_get_block(&cursor), field,
-					merge_threshold);
+		mtr.write<4,mtr_t::MAYBE_NOP>(*btr_cur_get_block(&cursor),
+					      field, merge_threshold);
 	}
 
 	mtr_commit(&mtr);
diff --git a/storage/innobase/fil/fil0crypt.cc b/storage/innobase/fil/fil0crypt.cc
index 99398dc9f0b..fa643e88a68 100644
--- a/storage/innobase/fil/fil0crypt.cc
+++ b/storage/innobase/fil/fil0crypt.cc
@@ -409,7 +409,7 @@ void fil_space_crypt_t::write_page0(buf_block_t* block, mtr_t* mtr)
 		+ fsp_header_get_encryption_offset(block->zip_size());
 	byte* b = block->frame + offset;
 
-	mtr->memcpy<mtr_t::OPT>(*block, b, CRYPT_MAGIC, MAGIC_SZ);
+	mtr->memcpy<mtr_t::MAYBE_NOP>(*block, b, CRYPT_MAGIC, MAGIC_SZ);
 
 	b += MAGIC_SZ;
 	byte* const start = b;
diff --git a/storage/innobase/fsp/fsp0fsp.cc b/storage/innobase/fsp/fsp0fsp.cc
index a4c1530d55e..86b199c5267 100644
--- a/storage/innobase/fsp/fsp0fsp.cc
+++ b/storage/innobase/fsp/fsp0fsp.cc
@@ -572,8 +572,8 @@ void fsp_header_init(fil_space_t* space, ulint size, mtr_t* mtr)
 	mtr->write<2>(*block, block->frame + FIL_PAGE_TYPE,
 		      FIL_PAGE_TYPE_FSP_HDR);
 
-	mtr->write<4,mtr_t::OPT>(*block, FSP_HEADER_OFFSET + FSP_SPACE_ID
-				 + block->frame, space->id);
+	mtr->write<4,mtr_t::MAYBE_NOP>(*block, FSP_HEADER_OFFSET + FSP_SPACE_ID
+				       + block->frame, space->id);
 	ut_ad(0 == mach_read_from_4(FSP_HEADER_OFFSET + FSP_NOT_USED
 				    + block->frame));
 	/* recv_sys_t::parse() expects to find a WRITE record that
@@ -584,9 +584,10 @@ void fsp_header_init(fil_space_t* space, ulint size, mtr_t* mtr)
 				   + block->frame, size);
 	ut_ad(0 == mach_read_from_4(FSP_HEADER_OFFSET + FSP_FREE_LIMIT
 				    + block->frame));
-	mtr->write<4,mtr_t::OPT>(*block, FSP_HEADER_OFFSET + FSP_SPACE_FLAGS
-				 + block->frame,
-				 space->flags & ~FSP_FLAGS_MEM_MASK);
+	mtr->write<4,mtr_t::MAYBE_NOP>(*block,
+				       FSP_HEADER_OFFSET + FSP_SPACE_FLAGS
+				       + block->frame,
+				       space->flags & ~FSP_FLAGS_MEM_MASK);
 	ut_ad(0 == mach_read_from_4(FSP_HEADER_OFFSET + FSP_FRAG_N_USED
 				    + block->frame));
 
@@ -1794,8 +1795,8 @@ fseg_create(
 	mtr->write<4>(*block, byte_offset + FSEG_HDR_PAGE_NO
 		      + block->frame, iblock->page.id.page_no());
 
-	mtr->write<4,mtr_t::OPT>(*block, byte_offset + FSEG_HDR_SPACE
-				 + block->frame, space->id);
+	mtr->write<4,mtr_t::MAYBE_NOP>(*block, byte_offset + FSEG_HDR_SPACE
+				       + block->frame, space->id);
 
 funct_exit:
 	if (!has_done_reservation) {
@@ -1971,7 +1972,8 @@ fseg_alloc_free_extent(
 		seg_id = mach_read_from_8(inode + FSEG_ID);
 
 		xdes_set_state(**xdes, descr, XDES_FSEG, mtr);
-		mtr->write<8,mtr_t::OPT>(**xdes, descr + XDES_ID, seg_id);
+		mtr->write<8,mtr_t::MAYBE_NOP>(**xdes, descr + XDES_ID,
+					       seg_id);
 		flst_add_last(iblock,
 			      static_cast<uint16_t>(inode - iblock->frame
 						    + FSEG_FREE), *xdes,
@@ -2081,7 +2083,8 @@ take_hinted_page:
 		ut_a(ret_descr == descr);
 
 		xdes_set_state(*xdes, ret_descr, XDES_FSEG, mtr);
-		mtr->write<8,mtr_t::OPT>(*xdes, ret_descr + XDES_ID, seg_id);
+		mtr->write<8,mtr_t::MAYBE_NOP>(*xdes, ret_descr + XDES_ID,
+					       seg_id);
 		flst_add_last(iblock,
 			      static_cast<uint16_t>(seg_inode - iblock->frame
 						    + FSEG_FREE), xdes,
diff --git a/storage/innobase/fut/fut0lst.cc b/storage/innobase/fut/fut0lst.cc
index 618eb1881e3..c75d2670181 100644
--- a/storage/innobase/fut/fut0lst.cc
+++ b/storage/innobase/fut/fut0lst.cc
@@ -75,7 +75,7 @@ static void flst_zero_both(const buf_block_t& b, byte *addr, mtr_t *mtr)
 {
   if (mach_read_from_4(addr + FIL_ADDR_PAGE) != FIL_NULL)
     mtr->memset(&b, ulint(addr - b.frame) + FIL_ADDR_PAGE, 4, 0xff);
-  mtr->write<2,mtr_t::OPT>(b, addr + FIL_ADDR_BYTE, 0U);
+  mtr->write<2,mtr_t::MAYBE_NOP>(b, addr + FIL_ADDR_BYTE, 0U);
   /* Initialize the other address by (MEMMOVE|0x80,offset,FIL_ADDR_SIZE,source)
   which is 4 bytes, or less than FIL_ADDR_SIZE. */
   memcpy(addr + FIL_ADDR_SIZE, addr, FIL_ADDR_SIZE);
@@ -230,7 +230,7 @@ void flst_init(const buf_block_t& block, byte *base, mtr_t *mtr)
 {
   ut_ad(mtr->memo_contains_page_flagged(base, MTR_MEMO_PAGE_X_FIX |
                                         MTR_MEMO_PAGE_SX_FIX));
-  mtr->write<4,mtr_t::OPT>(block, base + FLST_LEN, 0U);
+  mtr->write<4,mtr_t::MAYBE_NOP>(block, base + FLST_LEN, 0U);
   static_assert(FLST_LAST == FLST_FIRST + FIL_ADDR_SIZE, "compatibility");
   flst_zero_both(block, base + FLST_FIRST, mtr);
 }
diff --git a/storage/innobase/gis/gis0rtree.cc b/storage/innobase/gis/gis0rtree.cc
index d20ae4fe812..de8046cd94c 100644
--- a/storage/innobase/gis/gis0rtree.cc
+++ b/storage/innobase/gis/gis0rtree.cc
@@ -300,9 +300,9 @@ rtr_update_mbr_field(
 			memcpy(rec, node_ptr->fields[0].data, DATA_MBR_LEN);
 			page_zip_write_rec(block, rec, index, offsets, 0, mtr);
 		} else {
-			mtr->memcpy<mtr_t::OPT>(*block, rec,
-						node_ptr->fields[0].data,
-						DATA_MBR_LEN);
+			mtr->memcpy<mtr_t::MAYBE_NOP>(*block, rec,
+						      node_ptr->fields[0].data,
+						      DATA_MBR_LEN);
 		}
 
 		if (cursor2) {
diff --git a/storage/innobase/handler/handler0alter.cc b/storage/innobase/handler/handler0alter.cc
index 310d50a78fb..8ee10849e43 100644
--- a/storage/innobase/handler/handler0alter.cc
+++ b/storage/innobase/handler/handler0alter.cc
@@ -10220,7 +10220,7 @@ commit_cache_norebuild(
 					    space->zip_size(),
 					    RW_X_LATCH, &mtr)) {
 					mtr.set_named_space(space);
-					mtr.write<4,mtr_t::OPT>(
+					mtr.write<4,mtr_t::MAYBE_NOP>(
 						*b,
 						FSP_HEADER_OFFSET
 						+ FSP_SPACE_FLAGS + b->frame,
diff --git a/storage/innobase/ibuf/ibuf0ibuf.cc b/storage/innobase/ibuf/ibuf0ibuf.cc
index 9bf10f2031b..1f00649babc 100644
--- a/storage/innobase/ibuf/ibuf0ibuf.cc
+++ b/storage/innobase/ibuf/ibuf0ibuf.cc
@@ -653,7 +653,7 @@ ibuf_bitmap_page_set_bits(
 #endif
 	}
 
-	mtr->write<1,mtr_t::OPT>(*block, map_byte, b);
+	mtr->write<1,mtr_t::MAYBE_NOP>(*block, map_byte, b);
 }
 
 /** Calculates the bitmap page number for a given page number.
diff --git a/storage/innobase/include/btr0btr.ic b/storage/innobase/include/btr0btr.ic
index 35ac49dd117..ee78ab1b1d9 100644
--- a/storage/innobase/include/btr0btr.ic
+++ b/storage/innobase/include/btr0btr.ic
@@ -51,7 +51,7 @@ void btr_page_set_level(buf_block_t *block, ulint level, mtr_t *mtr)
   ut_ad(level <= BTR_MAX_NODE_LEVEL);
   constexpr uint16_t field= PAGE_HEADER + PAGE_LEVEL;
   byte *b= my_assume_aligned<2>(&block->frame[field]);
-  if (mtr->write<2,mtr_t::OPT>(*block, b, level) &&
+  if (mtr->write<2,mtr_t::MAYBE_NOP>(*block, b, level) &&
       UNIV_LIKELY_NULL(block->page.zip.data))
     memcpy_aligned<2>(&block->page.zip.data[field], b, 2);
 }
@@ -64,7 +64,7 @@ inline void btr_page_set_next(buf_block_t *block, ulint next, mtr_t *mtr)
 {
   constexpr uint16_t field= FIL_PAGE_NEXT;
   byte *b= my_assume_aligned<4>(&block->frame[field]);
-  if (mtr->write<4,mtr_t::OPT>(*block, b, next) &&
+  if (mtr->write<4,mtr_t::MAYBE_NOP>(*block, b, next) &&
       UNIV_LIKELY_NULL(block->page.zip.data))
     memcpy_aligned<4>(&block->page.zip.data[field], b, 4);
 }
@@ -77,7 +77,7 @@ inline void btr_page_set_prev(buf_block_t *block, ulint prev, mtr_t *mtr)
 {
   constexpr uint16_t field= FIL_PAGE_PREV;
   byte *b= my_assume_aligned<4>(&block->frame[field]);
-  if (mtr->write<4,mtr_t::OPT>(*block, b, prev) &&
+  if (mtr->write<4,mtr_t::MAYBE_NOP>(*block, b, prev) &&
       UNIV_LIKELY_NULL(block->page.zip.data))
     memcpy_aligned<4>(&block->page.zip.data[field], b, 4);
 }
diff --git a/storage/innobase/include/mtr0log.h b/storage/innobase/include/mtr0log.h
index ee823caf6cb..a8840b187a8 100644
--- a/storage/innobase/include/mtr0log.h
+++ b/storage/innobase/include/mtr0log.h
@@ -200,7 +200,7 @@ inline bool mtr_t::write(const buf_block_t &block, void *ptr, V val)
     {
       if (p == end)
       {
-        ut_ad(w == OPT);
+        ut_ad(w == MAYBE_NOP);
         return false;
       }
     }
@@ -494,7 +494,7 @@ inline void mtr_t::memcpy(const buf_block_t &b, void *dest, const void *str,
     {
       if (d == end)
       {
-        ut_ad(w == OPT);
+        ut_ad(w == MAYBE_NOP);
         return;
       }
     }
diff --git a/storage/innobase/include/mtr0mtr.h b/storage/innobase/include/mtr0mtr.h
index 23b52ed0677..2f71155187c 100644
--- a/storage/innobase/include/mtr0mtr.h
+++ b/storage/innobase/include/mtr0mtr.h
@@ -400,7 +400,7 @@ public:
     /** the page is guaranteed to always change */
     NORMAL= 0,
     /** optional: the page contents might not change */
-    OPT,
+    MAYBE_NOP,
     /** force a write, even if the page contents is not changing */
     FORCED
   };
diff --git a/storage/innobase/include/page0page.h b/storage/innobase/include/page0page.h
index 1a67b28707e..561267d0e56 100644
--- a/storage/innobase/include/page0page.h
+++ b/storage/innobase/include/page0page.h
@@ -433,8 +433,8 @@ inline void page_rec_set_n_owned(buf_block_t *block, rec_t *rec, ulint n_owned,
   else
   {
     rec-= comp ? REC_NEW_N_OWNED : REC_OLD_N_OWNED;
-    mtr->write<1,mtr_t::OPT>(*block, rec, (*rec & ~REC_N_OWNED_MASK) |
-                             (n_owned << REC_N_OWNED_SHIFT));
+    mtr->write<1,mtr_t::MAYBE_NOP>(*block, rec, (*rec & ~REC_N_OWNED_MASK) |
+                                   (n_owned << REC_N_OWNED_SHIFT));
   }
 }
 
diff --git a/storage/innobase/include/page0page.ic b/storage/innobase/include/page0page.ic
index 92b8922ffe0..668287c121a 100644
--- a/storage/innobase/include/page0page.ic
+++ b/storage/innobase/include/page0page.ic
@@ -88,7 +88,7 @@ page_set_ssn_id(
   ut_ad(!page_zip || page_zip == &block->page.zip);
   constexpr uint16_t field= FIL_RTREE_SPLIT_SEQ_NUM;
   byte *b= my_assume_aligned<2>(&block->frame[field]);
-  if (mtr->write<8,mtr_t::OPT>(*block, b, ssn_id) &&
+  if (mtr->write<8,mtr_t::MAYBE_NOP>(*block, b, ssn_id) &&
       UNIV_LIKELY_NULL(page_zip))
     memcpy_aligned<2>(&page_zip->data[field], b, 8);
 }
@@ -126,7 +126,7 @@ inline void page_header_reset_last_insert(buf_block_t *block, mtr_t *mtr)
 {
   constexpr uint16_t field= PAGE_HEADER + PAGE_LAST_INSERT;
   byte *b= my_assume_aligned<2>(&block->frame[field]);
-  if (mtr->write<2,mtr_t::OPT>(*block, b, 0U) &&
+  if (mtr->write<2,mtr_t::MAYBE_NOP>(*block, b, 0U) &&
       UNIV_LIKELY_NULL(block->page.zip.data))
     memset_aligned<2>(&block->page.zip.data[field], 0, 2);
 }
diff --git a/storage/innobase/page/page0page.cc b/storage/innobase/page/page0page.cc
index 5620330071e..2458a40ec1d 100644
--- a/storage/innobase/page/page0page.cc
+++ b/storage/innobase/page/page0page.cc
@@ -970,12 +970,12 @@ page_delete_rec_list_end(
     ut_ad(slot_index > 0);
   }
 
-  mtr->write<2,mtr_t::OPT>(*block, my_assume_aligned<2>
-                           (PAGE_N_DIR_SLOTS + PAGE_HEADER + block->frame),
-                           slot_index + 1);
-  mtr->write<2,mtr_t::OPT>(*block, my_assume_aligned<2>
-                           (PAGE_LAST_INSERT + PAGE_HEADER + block->frame),
-                           0U);
+  mtr->write<2,mtr_t::MAYBE_NOP>(*block, my_assume_aligned<2>
+                                 (PAGE_N_DIR_SLOTS + PAGE_HEADER +
+                                  block->frame), slot_index + 1);
+  mtr->write<2,mtr_t::MAYBE_NOP>(*block, my_assume_aligned<2>
+                                 (PAGE_LAST_INSERT + PAGE_HEADER +
+                                  block->frame), 0U);
   /* Catenate the deleted chain segment to the page free list */
   alignas(4) byte page_header[4];
   byte *page_free= my_assume_aligned<4>(PAGE_HEADER + PAGE_FREE +
@@ -1001,7 +1001,7 @@ page_delete_rec_list_end(
 
   if (page_is_comp(block->frame))
   {
-    mtr->write<2,mtr_t::OPT>(*block, slot, PAGE_NEW_SUPREMUM);
+    mtr->write<2,mtr_t::MAYBE_NOP>(*block, slot, PAGE_NEW_SUPREMUM);
     byte *owned= PAGE_NEW_SUPREMUM - REC_NEW_N_OWNED + block->frame;
     byte new_owned= static_cast<byte>((*owned & ~REC_N_OWNED_MASK) |
                                       n_owned << REC_N_OWNED_SHIFT);
@@ -1021,7 +1021,7 @@ page_delete_rec_list_end(
       return;
     }
 #endif
-    mtr->write<1,mtr_t::OPT>(*block, owned, new_owned);
+    mtr->write<1,mtr_t::MAYBE_NOP>(*block, owned, new_owned);
     mtr->write<2>(*block, prev_rec - REC_NEXT, static_cast<uint16_t>
                   (PAGE_NEW_SUPREMUM - page_offset(prev_rec)));
     mtr->write<2>(*block, last_rec - REC_NEXT, free
@@ -1030,11 +1030,11 @@ page_delete_rec_list_end(
   }
   else
   {
-    mtr->write<2,mtr_t::OPT>(*block, slot, PAGE_OLD_SUPREMUM);
+    mtr->write<2,mtr_t::MAYBE_NOP>(*block, slot, PAGE_OLD_SUPREMUM);
     byte *owned= PAGE_OLD_SUPREMUM - REC_OLD_N_OWNED + block->frame;
     byte new_owned= static_cast<byte>((*owned & ~REC_N_OWNED_MASK) |
                                       n_owned << REC_N_OWNED_SHIFT);
-    mtr->write<1,mtr_t::OPT>(*block, owned, new_owned);
+    mtr->write<1,mtr_t::MAYBE_NOP>(*block, owned, new_owned);
     mtr->write<2>(*block, prev_rec - REC_NEXT, PAGE_OLD_SUPREMUM);
     mtr->write<2>(*block, last_rec - REC_NEXT, free);
   }
diff --git a/storage/innobase/page/page0zip.cc b/storage/innobase/page/page0zip.cc
index 4b45b90c24e..34bb61210f5 100644
--- a/storage/innobase/page/page0zip.cc
+++ b/storage/innobase/page/page0zip.cc
@@ -400,7 +400,7 @@ inline void mtr_t::zmemcpy(const buf_block_t &b, void *dest, const void *str,
     {
       if (d == end)
       {
-        ut_ad(w == OPT);
+        ut_ad(w == MAYBE_NOP);
         return;
       }
     }
@@ -3836,8 +3836,8 @@ void page_zip_write_rec(buf_block_t *block, const byte *rec,
 
 		/* Copy the node pointer to the uncompressed area. */
 		byte* node_ptr = storage - REC_NODE_PTR_SIZE * (heap_no - 1);
-		mtr->zmemcpy<mtr_t::OPT>(*block, node_ptr,
-					 rec + len, REC_NODE_PTR_SIZE);
+		mtr->zmemcpy<mtr_t::MAYBE_NOP>(*block, node_ptr,
+					       rec + len, REC_NODE_PTR_SIZE);
 	}
 
 	ut_a(!*data);
@@ -3909,8 +3909,8 @@ page_zip_write_blob_ptr(
 	externs -= (blob_no + 1) * BTR_EXTERN_FIELD_REF_SIZE;
 	field += len - BTR_EXTERN_FIELD_REF_SIZE;
 
-	mtr->zmemcpy<mtr_t::OPT>(*block, externs, field,
-				 BTR_EXTERN_FIELD_REF_SIZE);
+	mtr->zmemcpy<mtr_t::MAYBE_NOP>(*block, externs, field,
+				       BTR_EXTERN_FIELD_REF_SIZE);
 
 #ifdef UNIV_ZIP_DEBUG
 	ut_a(page_zip_validate(page_zip, page, index));
@@ -4049,8 +4049,8 @@ page_zip_write_trx_id_and_roll_ptr(
 		}
 	} else {
 write:
-                mtr->zmemcpy<mtr_t::OPT>(*block, storage, field,
-					 sys_len - len);
+                mtr->zmemcpy<mtr_t::MAYBE_NOP>(*block, storage, field,
+					       sys_len - len);
 	}
 #if defined UNIV_DEBUG || defined UNIV_ZIP_DEBUG
 	ut_a(!memcmp(storage - len, field - len, sys_len));
@@ -4171,7 +4171,7 @@ void page_zip_rec_set_deleted(buf_block_t *block, rec_t *rec, bool flag,
     b|= (PAGE_ZIP_DIR_SLOT_DEL >> 8);
   else
     b&= byte(~(PAGE_ZIP_DIR_SLOT_DEL >> 8));
-  mtr->zmemcpy<mtr_t::OPT>(*block, slot, &b, 1);
+  mtr->zmemcpy<mtr_t::MAYBE_NOP>(*block, slot, &b, 1);
 #ifdef UNIV_ZIP_DEBUG
   ut_a(page_zip_validate(&block->page.zip, block->frame, nullptr));
 #endif /* UNIV_ZIP_DEBUG */
@@ -4197,7 +4197,7 @@ page_zip_rec_set_owned(
     b|= (PAGE_ZIP_DIR_SLOT_OWNED >> 8);
   else
     b&= byte(~(PAGE_ZIP_DIR_SLOT_OWNED >> 8));
-  mtr->zmemcpy<mtr_t::OPT>(*block, slot, &b, 1);
+  mtr->zmemcpy<mtr_t::MAYBE_NOP>(*block, slot, &b, 1);
 }
 
 /**********************************************************************//**
diff --git a/storage/innobase/row/row0purge.cc b/storage/innobase/row/row0purge.cc
index 20685398a81..c05ab6bb73f 100644
--- a/storage/innobase/row/row0purge.cc
+++ b/storage/innobase/row/row0purge.cc
@@ -707,8 +707,9 @@ static void row_purge_reset_trx_id(purge_node_t* node, mtr_t* mtr)
 				size_t offs = page_offset(ptr);
 				mtr->memset(block, offs, DATA_TRX_ID_LEN, 0);
 				offs += DATA_TRX_ID_LEN;
-				mtr->write<1,mtr_t::OPT>(*block, block->frame
-							 + offs, 0x80U);
+				mtr->write<1,mtr_t::MAYBE_NOP>(*block,
+							       block->frame
+							       + offs, 0x80U);
 				mtr->memset(block, offs + 1,
 					    DATA_ROLL_PTR_LEN - 1, 0);
 			}
diff --git a/storage/innobase/row/row0umod.cc b/storage/innobase/row/row0umod.cc
index 6822c4a363d..4edab754a2b 100644
--- a/storage/innobase/row/row0umod.cc
+++ b/storage/innobase/row/row0umod.cc
@@ -481,8 +481,9 @@ row_undo_mod_clust(
 				size_t offs = page_offset(rec + trx_id_offset);
 				mtr.memset(block, offs, DATA_TRX_ID_LEN, 0);
 				offs += DATA_TRX_ID_LEN;
-				mtr.write<1,mtr_t::OPT>(*block, block->frame
-							+ offs, 0x80U);
+				mtr.write<1,mtr_t::MAYBE_NOP>(*block,
+							      block->frame
+							      + offs, 0x80U);
 				mtr.memset(block, offs + 1,
 					   DATA_ROLL_PTR_LEN - 1, 0);
 			}
diff --git a/storage/innobase/trx/trx0purge.cc b/storage/innobase/trx/trx0purge.cc
index e2c14d3842e..35b6b82d2c8 100644
--- a/storage/innobase/trx/trx0purge.cc
+++ b/storage/innobase/trx/trx0purge.cc
@@ -298,8 +298,8 @@ trx_purge_add_undo_to_history(const trx_t* trx, trx_undo_t*& undo, mtr_t* mtr)
 		       static_cast<uint16_t>(undo->hdr_offset
 					     + TRX_UNDO_HISTORY_NODE), mtr);
 
-	mtr->write<8,mtr_t::OPT>(*undo_page, undo_header + TRX_UNDO_TRX_NO,
-				 trx->no);
+	mtr->write<8,mtr_t::MAYBE_NOP>(*undo_page,
+				       undo_header + TRX_UNDO_TRX_NO, trx->no);
 	/* This is needed for upgrading old undo log pages from
 	before MariaDB 10.3.1. */
 	if (UNIV_UNLIKELY(!mach_read_from_2(undo_header
@@ -362,8 +362,8 @@ trx_purge_free_segment(trx_rseg_t* rseg, fil_addr_t hdr_addr)
 	again. The list of pages in the undo log tail gets
 	inconsistent during the freeing of the segment, and therefore
 	purge should not try to access them again. */
-	mtr.write<2,mtr_t::OPT>(*block, block->frame + hdr_addr.boffset
-				+ TRX_UNDO_NEEDS_PURGE, 0U);
+	mtr.write<2,mtr_t::MAYBE_NOP>(*block, block->frame + hdr_addr.boffset
+				      + TRX_UNDO_NEEDS_PURGE, 0U);
 
 	while (!fseg_free_step_not_header(
 		       TRX_UNDO_SEG_HDR + TRX_UNDO_FSEG_HEADER
diff --git a/storage/innobase/trx/trx0rseg.cc b/storage/innobase/trx/trx0rseg.cc
index ccc8ccb6ac1..25dfaded978 100644
--- a/storage/innobase/trx/trx0rseg.cc
+++ b/storage/innobase/trx/trx0rseg.cc
@@ -55,26 +55,27 @@ trx_rseg_write_wsrep_checkpoint(
 	DBUG_ASSERT(xid->bqual_length >= 0);
 	DBUG_ASSERT(xid->gtrid_length + xid->bqual_length < XIDDATASIZE);
 
-	mtr->write<4,mtr_t::OPT>(*rseg_header,
-				 TRX_RSEG + TRX_RSEG_WSREP_XID_FORMAT
-				 + rseg_header->frame,
-				 uint32_t(xid->formatID));
+	mtr->write<4,mtr_t::MAYBE_NOP>(*rseg_header,
+				       TRX_RSEG + TRX_RSEG_WSREP_XID_FORMAT
+				       + rseg_header->frame,
+				       uint32_t(xid->formatID));
 
-	mtr->write<4,mtr_t::OPT>(*rseg_header,
-				 TRX_RSEG + TRX_RSEG_WSREP_XID_GTRID_LEN
-				 + rseg_header->frame,
-				 uint32_t(xid->gtrid_length));
+	mtr->write<4,mtr_t::MAYBE_NOP>(*rseg_header,
+				       TRX_RSEG + TRX_RSEG_WSREP_XID_GTRID_LEN
+				       + rseg_header->frame,
+				       uint32_t(xid->gtrid_length));
 
-	mtr->write<4,mtr_t::OPT>(*rseg_header,
-				 TRX_RSEG + TRX_RSEG_WSREP_XID_BQUAL_LEN
-				 + rseg_header->frame,
-				 uint32_t(xid->bqual_length));
+	mtr->write<4,mtr_t::MAYBE_NOP>(*rseg_header,
+				       TRX_RSEG + TRX_RSEG_WSREP_XID_BQUAL_LEN
+				       + rseg_header->frame,
+				       uint32_t(xid->bqual_length));
 
 	const ulint xid_length = static_cast<ulint>(xid->gtrid_length
 						    + xid->bqual_length);
-	mtr->memcpy<mtr_t::OPT>(*rseg_header,
-				TRX_RSEG + TRX_RSEG_WSREP_XID_DATA
-				+ rseg_header->frame, xid->data, xid_length);
+	mtr->memcpy<mtr_t::MAYBE_NOP>(*rseg_header,
+				      TRX_RSEG + TRX_RSEG_WSREP_XID_DATA
+				      + rseg_header->frame,
+				      xid->data, xid_length);
 	if (xid_length < XIDDATASIZE
 	    && memcmp(TRX_RSEG + TRX_RSEG_WSREP_XID_DATA
 		      + rseg_header->frame, field_ref_zero,
@@ -340,12 +341,12 @@ trx_rseg_header_create(
 		/* Add the rollback segment info to the free slot in
 		the trx system header */
 
-		mtr->write<4,mtr_t::OPT>(
+		mtr->write<4,mtr_t::MAYBE_NOP>(
 			*sys_header,
 			TRX_SYS + TRX_SYS_RSEGS + TRX_SYS_RSEG_SPACE
 			+ rseg_id * TRX_SYS_RSEG_SLOT_SIZE
 			+ sys_header->frame, space->id);
-		mtr->write<4,mtr_t::OPT>(
+		mtr->write<4,mtr_t::MAYBE_NOP>(
 			*sys_header,
 			TRX_SYS + TRX_SYS_RSEGS + TRX_SYS_RSEG_PAGE_NO
 			+ rseg_id * TRX_SYS_RSEG_SLOT_SIZE
@@ -739,10 +740,10 @@ void trx_rseg_update_binlog_offset(buf_block_t *rseg_header, const trx_t *trx,
 		return;
 	}
 
-	mtr->write<8,mtr_t::OPT>(*rseg_header,
-				 TRX_RSEG + TRX_RSEG_BINLOG_OFFSET
-				 + rseg_header->frame,
-				 trx->mysql_log_offset);
+	mtr->write<8,mtr_t::MAYBE_NOP>(*rseg_header,
+				       TRX_RSEG + TRX_RSEG_BINLOG_OFFSET
+				       + rseg_header->frame,
+				       trx->mysql_log_offset);
 
 	void* name = TRX_RSEG + TRX_RSEG_BINLOG_NAME + rseg_header->frame;
 
diff --git a/storage/innobase/trx/trx0undo.cc b/storage/innobase/trx/trx0undo.cc
index 480f81835ec..aa8c644a896 100644
--- a/storage/innobase/trx/trx0undo.cc
+++ b/storage/innobase/trx/trx0undo.cc
@@ -401,8 +401,9 @@ trx_undo_seg_create(fil_space_t *space, buf_block_t *rseg_hdr, ulint *id,
 	mtr->write<2>(*block, TRX_UNDO_PAGE_HDR + TRX_UNDO_PAGE_FREE
 		      + block->frame,
 		      TRX_UNDO_SEG_HDR + TRX_UNDO_SEG_HDR_SIZE);
-	mtr->write<2,mtr_t::OPT>(*block, TRX_UNDO_SEG_HDR + TRX_UNDO_LAST_LOG
-				 + block->frame, 0U);
+	mtr->write<2,mtr_t::MAYBE_NOP>(*block,
+				       TRX_UNDO_SEG_HDR + TRX_UNDO_LAST_LOG
+				       + block->frame, 0U);
 
 	flst_init(*block, TRX_UNDO_SEG_HDR + TRX_UNDO_PAGE_LIST + block->frame,
 		  mtr);
@@ -434,7 +435,7 @@ static uint16_t trx_undo_header_create(buf_block_t *undo_page, trx_id_t trx_id,
   byte *undo_type= my_assume_aligned<2>
     (TRX_UNDO_PAGE_HDR + TRX_UNDO_PAGE_TYPE + undo_page->frame);
   ut_ad(mach_read_from_2(undo_type) <= TRX_UNDO_UPDATE);
-  mtr->write<2,mtr_t::OPT>(*undo_page, undo_type, 0U);
+  mtr->write<2,mtr_t::MAYBE_NOP>(*undo_page, undo_type, 0U);
   byte *start= my_assume_aligned<4>(TRX_UNDO_PAGE_HDR + TRX_UNDO_PAGE_START +
                                     undo_page->frame);
   const uint16_t free= mach_read_from_2(start + 2);
@@ -468,15 +469,15 @@ static uint16_t trx_undo_header_create(buf_block_t *undo_page, trx_id_t trx_id,
   memcpy_aligned<2>(buf + 2, start, 2);
   static_assert(TRX_UNDO_NEEDS_PURGE + 2 == TRX_UNDO_LOG_START,
                 "compatibility");
-  mtr->memcpy<mtr_t::OPT>(*undo_page, free + TRX_UNDO_NEEDS_PURGE +
-                          undo_page->frame, buf, 4);
+  mtr->memcpy<mtr_t::MAYBE_NOP>(*undo_page, free + TRX_UNDO_NEEDS_PURGE +
+                                undo_page->frame, buf, 4);
   /* Initialize all fields TRX_UNDO_XID_EXISTS to TRX_UNDO_HISTORY_NODE. */
   if (prev_log)
   {
     mtr->memset(undo_page, free + TRX_UNDO_XID_EXISTS,
                 TRX_UNDO_PREV_LOG - TRX_UNDO_XID_EXISTS, 0);
-    mtr->write<2,mtr_t::OPT>(*undo_page, free + TRX_UNDO_PREV_LOG +
-                             undo_page->frame, prev_log);
+    mtr->write<2,mtr_t::MAYBE_NOP>(*undo_page, free + TRX_UNDO_PREV_LOG +
+                                   undo_page->frame, prev_log);
     static_assert(TRX_UNDO_PREV_LOG + 2 == TRX_UNDO_HISTORY_NODE,
                   "compatibility");
     mtr->memset(undo_page, free + TRX_UNDO_HISTORY_NODE, FLST_NODE_SIZE, 0);
@@ -508,12 +509,12 @@ static void trx_undo_write_xid(buf_block_t *block, uint16_t offset,
 
   trx_ulogf_t* log_hdr= block->frame + offset;
 
-  mtr->write<4,mtr_t::OPT>(*block, log_hdr + TRX_UNDO_XA_FORMAT,
-                           static_cast<uint32_t>(xid.formatID));
-  mtr->write<4,mtr_t::OPT>(*block, log_hdr + TRX_UNDO_XA_TRID_LEN,
-                           static_cast<uint32_t>(xid.gtrid_length));
-  mtr->write<4,mtr_t::OPT>(*block, log_hdr + TRX_UNDO_XA_BQUAL_LEN,
-                           static_cast<uint32_t>(xid.bqual_length));
+  mtr->write<4,mtr_t::MAYBE_NOP>(*block, log_hdr + TRX_UNDO_XA_FORMAT,
+                                 static_cast<uint32_t>(xid.formatID));
+  mtr->write<4,mtr_t::MAYBE_NOP>(*block, log_hdr + TRX_UNDO_XA_TRID_LEN,
+                                 static_cast<uint32_t>(xid.gtrid_length));
+  mtr->write<4,mtr_t::MAYBE_NOP>(*block, log_hdr + TRX_UNDO_XA_BQUAL_LEN,
+                                 static_cast<uint32_t>(xid.bqual_length));
   const ulint xid_length= static_cast<ulint>(xid.gtrid_length
                                              + xid.bqual_length);
   mtr->memcpy(*block, &block->frame[offset + TRX_UNDO_XA_XID],
@@ -1061,10 +1062,11 @@ trx_undo_create(trx_t* trx, trx_rseg_t* rseg, trx_undo_t** undo,
 	case TRX_DICT_OP_TABLE:
 		(*undo)->table_id = trx->table_id;
 		(*undo)->dict_operation = TRUE;
-		mtr->write<1,mtr_t::OPT>(*block, block->frame + offset
-					 + TRX_UNDO_DICT_TRANS, 1U);
-		mtr->write<8,mtr_t::OPT>(*block, block->frame + offset
-					 + TRX_UNDO_TABLE_ID, trx->table_id);
+		mtr->write<1,mtr_t::MAYBE_NOP>(*block, block->frame + offset
+					       + TRX_UNDO_DICT_TRANS, 1U);
+		mtr->write<8,mtr_t::MAYBE_NOP>(*block, block->frame + offset
+					       + TRX_UNDO_TABLE_ID,
+					       trx->table_id);
 	}
 
 	*err = DB_SUCCESS;
@@ -1127,10 +1129,11 @@ trx_undo_reuse_cached(trx_t* trx, trx_rseg_t* rseg, trx_undo_t** pundo,
 	case TRX_DICT_OP_TABLE:
 		undo->table_id = trx->table_id;
 		undo->dict_operation = TRUE;
-		mtr->write<1,mtr_t::OPT>(*block, block->frame + offset
-					 + TRX_UNDO_DICT_TRANS, 1U);
-		mtr->write<8,mtr_t::OPT>(*block, block->frame + offset
-					 + TRX_UNDO_TABLE_ID, trx->table_id);
+		mtr->write<1,mtr_t::MAYBE_NOP>(*block, block->frame + offset
+					       + TRX_UNDO_DICT_TRANS, 1U);
+		mtr->write<8,mtr_t::MAYBE_NOP>(*block, block->frame + offset
+					       + TRX_UNDO_TABLE_ID,
+					       trx->table_id);
 	}
 
 	return block;