MDEV-11487 Revert InnoDB internal temporary tables from WL#7682

WL#7682 in MySQL 5.7 introduced the possibility to create light-weight
temporary tables in InnoDB. These are called 'intrinsic temporary tables'
in InnoDB, and in MySQL 5.7, they can be created by the optimizer for
sorting or buffering data in query processing.

In MariaDB 10.2, the optimizer temporary tables cannot be created in
InnoDB, so we should remove the dead code and related data structures.

1 files changed, 53 insertions, 395 deletions

diff --git a/storage/innobase/btr/btr0cur.cc b/storage/innobase/btr/btr0cur.cc
index 7daec068f78..0d72b9d2b92 100644
--- a/storage/innobase/btr/btr0cur.cc
+++ b/storage/innobase/btr/btr0cur.cc
@@ -280,10 +280,10 @@ btr_cur_latch_leaves(
 	case BTR_MODIFY_TREE:
 		/* It is exclusive for other operations which calls
 		btr_page_set_prev() */
-		ut_ad(mtr_memo_contains_flagged(mtr,
-			dict_index_get_lock(cursor->index),
-			MTR_MEMO_X_LOCK | MTR_MEMO_SX_LOCK)
-		      || dict_table_is_intrinsic(cursor->index->table));
+		ut_ad(mtr_memo_contains_flagged(
+			      mtr,
+			      dict_index_get_lock(cursor->index),
+			      MTR_MEMO_X_LOCK | MTR_MEMO_SX_LOCK));
 		/* x-latch also siblings from left to right */
 		left_page_no = btr_page_get_prev(page, mtr);
 		mode = latch_mode;
@@ -583,9 +583,7 @@ btr_cur_will_modify_tree(
 {
 	ut_ad(!page_is_leaf(page));
 	ut_ad(mtr_memo_contains_flagged(mtr, dict_index_get_lock(index),
-					MTR_MEMO_X_LOCK
-					| MTR_MEMO_SX_LOCK)
-	      || dict_table_is_intrinsic(index->table));
+					MTR_MEMO_X_LOCK | MTR_MEMO_SX_LOCK));
 
 	/* Pessimistic delete of the first record causes delete & insert
 	of node_ptr at upper level. And a subsequent page shrink is
@@ -909,13 +907,13 @@ btr_cur_search_to_nth_level(
 # ifdef UNIV_SEARCH_PERF_STAT
 	info->n_searches++;
 # endif
-	/* Use of AHI is disabled for intrinsic table as these tables re-use
-	the index-id and AHI validation is based on index-id. */
 	if (rw_lock_get_writer(btr_get_search_latch(index))
 		== RW_LOCK_NOT_LOCKED
 	    && latch_mode <= BTR_MODIFY_LEAF
 	    && info->last_hash_succ
+# ifdef MYSQL_INDEX_DISABLE_AHI
 	    && !index->disable_ahi
+# endif
 	    && !estimate
 # ifdef PAGE_CUR_LE_OR_EXTENDS
 	    && mode != PAGE_CUR_LE_OR_EXTENDS
@@ -1958,7 +1956,11 @@ need_opposite_intention:
 		will properly check btr_search_enabled again in
 		btr_search_build_page_hash_index() before building a
 		page hash index, while holding search latch. */
-		if (btr_search_enabled && !index->disable_ahi) {
+		if (btr_search_enabled
+# ifdef MYSQL_INDEX_DISABLE_AHI
+		    && !index->disable_ahi
+# endif
+		    ) {
 			btr_search_info_update(index, cursor);
 		}
 #endif
@@ -2009,179 +2011,6 @@ func_exit:
 	DBUG_RETURN(err);
 }
 
-/** Searches an index tree and positions a tree cursor on a given level.
-This function will avoid latching the traversal path and so should be
-used only for cases where-in latching is not needed.
-
-@param[in,out]	index	index
-@param[in]	level	the tree level of search
-@param[in]	tuple	data tuple; Note: n_fields_cmp in compared
-			to the node ptr page node field
-@param[in]	mode	PAGE_CUR_L, ....
-			Insert should always be made using PAGE_CUR_LE
-			to search the position.
-@param[in,out]	cursor	tree cursor; points to record of interest.
-@param[in]	file	file name
-@param[in[	line	line where called from
-@param[in,out]	mtr	mtr
-@param[in]	mark_dirty
-			if true then mark the block as dirty */
-dberr_t
-btr_cur_search_to_nth_level_with_no_latch(
-	dict_index_t*		index,
-	ulint			level,
-	const dtuple_t*		tuple,
-	page_cur_mode_t		mode,
-	btr_cur_t*		cursor,
-	const char*		file,
-	ulint			line,
-	mtr_t*			mtr,
-	bool			mark_dirty)
-{
-	page_t*		page = NULL; /* remove warning */
-	buf_block_t*	block;
-	ulint		height;
-	ulint		up_match;
-	ulint		low_match;
-	ulint		rw_latch;
-	page_cur_mode_t	page_mode;
-	ulint		buf_mode;
-	page_cur_t*	page_cursor;
-	ulint		root_height = 0; /* remove warning */
-	ulint		n_blocks = 0;
-	dberr_t		err = DB_SUCCESS;
-	mem_heap_t*	heap		= NULL;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets		= offsets_;
-	rec_offs_init(offsets_);
-
-	DBUG_ENTER("btr_cur_search_to_nth_level_with_no_latch");
-
-	ut_ad(dict_table_is_intrinsic(index->table));
-	ut_ad(level == 0 || mode == PAGE_CUR_LE);
-	ut_ad(dict_index_check_search_tuple(index, tuple));
-	ut_ad(dtuple_check_typed(tuple));
-	ut_ad(index->page != FIL_NULL);
-
-	UNIV_MEM_INVALID(&cursor->up_match, sizeof cursor->up_match);
-	UNIV_MEM_INVALID(&cursor->low_match, sizeof cursor->low_match);
-#ifdef UNIV_DEBUG
-	cursor->up_match = ULINT_UNDEFINED;
-	cursor->low_match = ULINT_UNDEFINED;
-#endif /* UNIV_DEBUG */
-
-	cursor->flag = BTR_CUR_BINARY;
-	cursor->index = index;
-
-	page_cursor = btr_cur_get_page_cur(cursor);
-
-        const ulint		space = dict_index_get_space(index);
-        const page_size_t	page_size(dict_table_page_size(index->table));
-        /* Start with the root page. */
-        page_id_t		page_id(space, dict_index_get_page(index));
-
-	up_match = 0;
-	low_match = 0;
-
-	height = ULINT_UNDEFINED;
-
-	/* We use these modified search modes on non-leaf levels of the
-	B-tree. These let us end up in the right B-tree leaf. In that leaf
-	we use the original search mode. */
-
-	switch (mode) {
-	case PAGE_CUR_GE:
-		page_mode = PAGE_CUR_L;
-		break;
-	case PAGE_CUR_G:
-		page_mode = PAGE_CUR_LE;
-		break;
-	default:
-		page_mode = mode;
-		break;
-	}
-
-	/* Loop and search until we arrive at the desired level */
-	bool at_desired_level = false;
-	while (!at_desired_level) {
-		buf_mode = BUF_GET;
-		rw_latch = RW_NO_LATCH;
-
-		ut_ad(n_blocks < BTR_MAX_LEVELS);
-
-		block = buf_page_get_gen(page_id, page_size, rw_latch, NULL,
-			buf_mode, file, line, mtr, &err, mark_dirty);
-
-		if (err != DB_SUCCESS) {
-			if (err == DB_DECRYPTION_FAILED) {
-				ib_push_warning((void *)NULL,
-					DB_DECRYPTION_FAILED,
-					"Table %s is encrypted but encryption service or"
-					" used key_id is not available. "
-					" Can't continue reading table.",
-					index->table->name);
-				index->table->is_encrypted = true;
-			}
-
-			DBUG_RETURN(err);
-		}
-
-		page = buf_block_get_frame(block);
-
-		if (height == ULINT_UNDEFINED) {
-			/* We are in the root node */
-
-			height = btr_page_get_level(page, mtr);
-			root_height = height;
-			cursor->tree_height = root_height + 1;
-		}
-
-		if (height == 0) {
-			/* On leaf level. Switch back to original search mode.*/
-			page_mode = mode;
-		}
-
-		page_cur_search_with_match(
-				block, index, tuple, page_mode, &up_match,
-				&low_match, page_cursor, NULL);
-
-		ut_ad(height == btr_page_get_level(
-			page_cur_get_page(page_cursor), mtr));
-
-		if (level != height) {
-
-			const rec_t*	node_ptr;
-			ut_ad(height > 0);
-
-			height--;
-
-			node_ptr = page_cur_get_rec(page_cursor);
-
-			offsets = rec_get_offsets(
-					node_ptr, index, offsets,
-					ULINT_UNDEFINED, &heap);
-
-			/* Go to the child node */
-			page_id.reset(space, btr_node_ptr_get_child_page_no(
-				node_ptr, offsets));
-
-			n_blocks++;
-		} else {
-			/* If this is the desired level, leave the loop */
-			at_desired_level = true;
-		}
-	}
-
-	cursor->low_match = low_match;
-	cursor->up_match = up_match;
-
-	if (heap != NULL) {
-		mem_heap_free(heap);
-	}
-
-	DBUG_RETURN(err);
-}
-
 /*****************************************************************//**
 Opens a cursor at either end of an index. */
 dberr_t
@@ -2556,125 +2385,6 @@ btr_cur_open_at_index_side_func(
 	return err;
 }
 
-/** Opens a cursor at either end of an index.
-Avoid taking latches on buffer, just pin (by incrementing fix_count)
-to keep them in buffer pool. This mode is used by intrinsic table
-as they are not shared and so there is no need of latching.
-@param[in]	from_left	true if open to low end, false if open
-				to high end.
-@param[in]	index		index
-@param[in,out]	cursor		cursor
-@param[in]	file		file name
-@param[in]	line		line where called
-@param[in,out]	mtr		mini transaction
-*/
-dberr_t
-btr_cur_open_at_index_side_with_no_latch_func(
-	bool		from_left,
-	dict_index_t*	index,
-	btr_cur_t*	cursor,
-	ulint		level,
-	const char*	file,
-	ulint		line,
-	mtr_t*		mtr)
-{
-	page_cur_t*	page_cursor;
-	ulint		height;
-	rec_t*		node_ptr;
-	ulint		n_blocks = 0;
-	mem_heap_t*	heap		= NULL;
-	ulint		offsets_[REC_OFFS_NORMAL_SIZE];
-	ulint*		offsets		= offsets_;
-	dberr_t		err = DB_SUCCESS;
-	rec_offs_init(offsets_);
-
-	ut_ad(level != ULINT_UNDEFINED);
-
-	page_cursor = btr_cur_get_page_cur(cursor);
-	cursor->index = index;
-	page_id_t		page_id(dict_index_get_space(index),
-					dict_index_get_page(index));
-	const page_size_t&	page_size = dict_table_page_size(index->table);
-
-	height = ULINT_UNDEFINED;
-
-	for (;;) {
-		buf_block_t*	block;
-		page_t*		page;
-		ulint		rw_latch = RW_NO_LATCH;
-
-		ut_ad(n_blocks < BTR_MAX_LEVELS);
-
-		block = buf_page_get_gen(page_id, page_size, rw_latch, NULL,
-			BUF_GET, file, line, mtr, &err);
-
-		if (err != DB_SUCCESS) {
-			if (err == DB_DECRYPTION_FAILED) {
-				ib_push_warning((void *)NULL,
-					DB_DECRYPTION_FAILED,
-					"Table %s is encrypted but encryption service or"
-					" used key_id is not available. "
-					" Can't continue reading table.",
-					index->table->name);
-				index->table->is_encrypted = true;
-			}
-
-			return (err);
-		}
-
-		page = buf_block_get_frame(block);
-
-		ut_ad(fil_page_index_page_check(page));
-		ut_ad(index->id == btr_page_get_index_id(page));
-
-		if (height == ULINT_UNDEFINED) {
-			/* We are in the root node */
-
-			height = btr_page_get_level(page, mtr);
-			ut_a(height >= level);
-		} else {
-			/* TODO: flag the index corrupted if this fails */
-			ut_ad(height == btr_page_get_level(page, mtr));
-		}
-
-		if (from_left) {
-			page_cur_set_before_first(block, page_cursor);
-		} else {
-			page_cur_set_after_last(block, page_cursor);
-		}
-
-		if (height == level) {
-			break;
-		}
-
-		ut_ad(height > 0);
-
-		if (from_left) {
-			page_cur_move_to_next(page_cursor);
-		} else {
-			page_cur_move_to_prev(page_cursor);
-		}
-
-		height--;
-
-		node_ptr = page_cur_get_rec(page_cursor);
-		offsets = rec_get_offsets(node_ptr, cursor->index, offsets,
-					  ULINT_UNDEFINED, &heap);
-
-		/* Go to the child node */
-		page_id.set_page_no(
-			btr_node_ptr_get_child_page_no(node_ptr, offsets));
-
-		n_blocks++;
-	}
-
-	if (heap != NULL) {
-		mem_heap_free(heap);
-	}
-
-	return(err);
-}
-
 /**********************************************************************//**
 Positions a cursor at a randomly chosen position within a B-tree.
 @return true if the index is available and we have put the cursor, false
@@ -3097,11 +2807,8 @@ btr_cur_ins_lock_and_undo(
 		return(err);
 	}
 
-	/* Now we can fill in the roll ptr field in entry
-	(except if table is intrinsic) */
-
-	if (!(flags & BTR_KEEP_SYS_FLAG)
-	    && !dict_table_is_intrinsic(index->table)) {
+	/* Now we can fill in the roll ptr field in entry */
+	if (!(flags & BTR_KEEP_SYS_FLAG)) {
 
 		row_upd_index_entry_sys_field(entry, index,
 					      DATA_ROLL_PTR, roll_ptr);
@@ -3191,8 +2898,6 @@ btr_cur_optimistic_insert(
 	page = buf_block_get_frame(block);
 	index = cursor->index;
 
-	/* Block are not latched for insert if table is intrinsic
-	and index is auto-generated clustered index. */
 	ut_ad(mtr_is_block_fix(mtr, block, MTR_MEMO_PAGE_X_FIX, index->table));
 	ut_ad(!dict_index_is_online_ddl(index)
 	      || dict_index_is_clust(index)
@@ -3311,26 +3016,18 @@ fail_err:
 	{
 		const rec_t*	page_cursor_rec = page_cur_get_rec(page_cursor);
 
-		if (dict_table_is_intrinsic(index->table)) {
-
-			index->rec_cache.rec_size = rec_size;
-
-			*rec = page_cur_tuple_direct_insert(
-				page_cursor, entry, index, n_ext, mtr);
-		} else {
-			/* Check locks and write to the undo log,
-			if specified */
-			err = btr_cur_ins_lock_and_undo(flags, cursor, entry,
-							thr, mtr, &inherit);
-			if (err != DB_SUCCESS) {
-				goto fail_err;
-			}
-
-			*rec = page_cur_tuple_insert(
-				page_cursor, entry, index, offsets, heap,
-				n_ext, mtr);
+		/* Check locks and write to the undo log,
+		if specified */
+		err = btr_cur_ins_lock_and_undo(flags, cursor, entry,
+						thr, mtr, &inherit);
+		if (err != DB_SUCCESS) {
+			goto fail_err;
 		}
 
+		*rec = page_cur_tuple_insert(
+			page_cursor, entry, index, offsets, heap,
+			n_ext, mtr);
+
 		reorg = page_cursor_rec != page_cur_get_rec(page_cursor);
 	}
 
@@ -3347,13 +3044,6 @@ fail_err:
 
 		goto fail;
 	} else {
-
-		/* For intrinsic table we take a consistent path
-		to re-organize using pessimistic path. */
-		if (dict_table_is_intrinsic(index->table)) {
-			goto fail;
-		}
-
 		ut_ad(!reorg);
 
 		/* If the record did not fit, reorganize */
@@ -3378,12 +3068,13 @@ fail_err:
 	}
 
 #ifdef BTR_CUR_HASH_ADAPT
-	if (!index->disable_ahi) {
-		if (!reorg && leaf && (cursor->flag == BTR_CUR_HASH)) {
-			btr_search_update_hash_node_on_insert(cursor);
-		} else {
-			btr_search_update_hash_on_insert(cursor);
-		}
+# ifdef MYSQL_INDEX_DISABLE_AHI
+	if (index->disable_ahi); else
+# endif
+	if (!reorg && leaf && (cursor->flag == BTR_CUR_HASH)) {
+		btr_search_update_hash_node_on_insert(cursor);
+	} else {
+		btr_search_update_hash_on_insert(cursor);
 	}
 #endif /* BTR_CUR_HASH_ADAPT */
 
@@ -3467,9 +3158,8 @@ btr_cur_pessimistic_insert(
 	*big_rec = NULL;
 
 	ut_ad(mtr_memo_contains_flagged(
-		mtr, dict_index_get_lock(btr_cur_get_index(cursor)),
-		MTR_MEMO_X_LOCK | MTR_MEMO_SX_LOCK)
-	      || dict_table_is_intrinsic(cursor->index->table));
+		      mtr, dict_index_get_lock(btr_cur_get_index(cursor)),
+		      MTR_MEMO_X_LOCK | MTR_MEMO_SX_LOCK));
 	ut_ad(mtr_is_block_fix(
 		mtr, btr_cur_get_block(cursor),
 		MTR_MEMO_PAGE_X_FIX, cursor->index->table));
@@ -3489,8 +3179,7 @@ btr_cur_pessimistic_insert(
 		return(err);
 	}
 
-	if (!(flags & BTR_NO_UNDO_LOG_FLAG)
-	    || dict_table_is_intrinsic(index->table)) {
+	if (!(flags & BTR_NO_UNDO_LOG_FLAG)) {
 		/* First reserve enough free space for the file segments
 		of the index tree, so that the insert will not fail because
 		of lack of space */
@@ -3577,9 +3266,10 @@ btr_cur_pessimistic_insert(
 	}
 
 #ifdef BTR_CUR_ADAPT
-	if (!index->disable_ahi) {
-		btr_search_update_hash_on_insert(cursor);
-	}
+# ifdef MYSQL_INDEX_DISABLE_AHI
+	if (index->disable_ahi); else
+# endif
+	btr_search_update_hash_on_insert(cursor);
 #endif
 	if (inherit && !(flags & BTR_NO_LOCKING_FLAG)) {
 
@@ -3921,9 +3611,7 @@ btr_cur_update_in_place(
 	index = cursor->index;
 	ut_ad(rec_offs_validate(rec, index, offsets));
 	ut_ad(!!page_rec_is_comp(rec) == dict_table_is_comp(index->table));
-	ut_ad(trx_id > 0
-	      || (flags & BTR_KEEP_SYS_FLAG)
-	      || dict_table_is_intrinsic(index->table));
+	ut_ad(trx_id > 0 || (flags & BTR_KEEP_SYS_FLAG));
 	/* The insert buffer tree should never be updated in place. */
 	ut_ad(!dict_index_is_ibuf(index));
 	ut_ad(dict_index_is_online_ddl(index) == !!(flags & BTR_CREATE_FLAG)
@@ -3970,8 +3658,7 @@ btr_cur_update_in_place(
 		goto func_exit;
 	}
 
-	if (!(flags & BTR_KEEP_SYS_FLAG)
-	    && !dict_table_is_intrinsic(index->table)) {
+	if (!(flags & BTR_KEEP_SYS_FLAG)) {
 		row_upd_rec_sys_fields(rec, NULL, index, offsets,
 				       thr_get_trx(thr), roll_ptr);
 	}
@@ -4087,9 +3774,7 @@ btr_cur_optimistic_update(
 	page = buf_block_get_frame(block);
 	rec = btr_cur_get_rec(cursor);
 	index = cursor->index;
-	ut_ad(trx_id > 0
-	      || (flags & BTR_KEEP_SYS_FLAG)
-	      || dict_table_is_intrinsic(index->table));
+	ut_ad(trx_id > 0 || (flags & BTR_KEEP_SYS_FLAG));
 	ut_ad(!!page_rec_is_comp(rec) == dict_table_is_comp(index->table));
 	ut_ad(mtr_is_block_fix(mtr, block, MTR_MEMO_PAGE_X_FIX, index->table));
 	/* This is intended only for leaf page updates */
@@ -4275,8 +3960,7 @@ any_extern:
 
 	page_cur_move_to_prev(page_cursor);
 
-	if (!(flags & BTR_KEEP_SYS_FLAG)
-	    && !dict_table_is_intrinsic(index->table)) {
+	if (!(flags & BTR_KEEP_SYS_FLAG)) {
 		row_upd_index_entry_sys_field(new_entry, index, DATA_ROLL_PTR,
 					      roll_ptr);
 		row_upd_index_entry_sys_field(new_entry, index, DATA_TRX_ID,
@@ -4422,8 +4106,7 @@ btr_cur_pessimistic_update(
 
 	ut_ad(mtr_memo_contains_flagged(mtr, dict_index_get_lock(index),
 					MTR_MEMO_X_LOCK |
-					MTR_MEMO_SX_LOCK)
-	      || dict_table_is_intrinsic(index->table));
+					MTR_MEMO_SX_LOCK));
 	ut_ad(mtr_is_block_fix(mtr, block, MTR_MEMO_PAGE_X_FIX, index->table));
 #ifdef UNIV_ZIP_DEBUG
 	ut_a(!page_zip || page_zip_validate(page_zip, page, index));
@@ -4431,8 +4114,7 @@ btr_cur_pessimistic_update(
 	/* The insert buffer tree should never be updated in place. */
 	ut_ad(!dict_index_is_ibuf(index));
 	ut_ad(trx_id > 0
-	      || (flags & BTR_KEEP_SYS_FLAG)
-	      || dict_table_is_intrinsic(index->table));
+	      || (flags & BTR_KEEP_SYS_FLAG));
 	ut_ad(dict_index_is_online_ddl(index) == !!(flags & BTR_CREATE_FLAG)
 	      || dict_index_is_clust(index));
 	ut_ad(thr_get_trx(thr)->id == trx_id
@@ -4495,11 +4177,8 @@ btr_cur_pessimistic_update(
 	ut_ad(rec_offs_validate(rec, index, *offsets));
 	n_ext += btr_push_update_extern_fields(new_entry, update, entry_heap);
 
-	/* UNDO logging is also turned-off during normal operation on intrinsic
-	table so condition needs to ensure that table is not intrinsic. */
 	if ((flags & BTR_NO_UNDO_LOG_FLAG)
-	    && rec_offs_any_extern(*offsets)
-	    && !dict_table_is_intrinsic(index->table)) {
+	    && rec_offs_any_extern(*offsets)) {
 		/* We are in a transaction rollback undoing a row
 		update: we must free possible externally stored fields
 		which got new values in the update, if they are not
@@ -4575,8 +4254,7 @@ btr_cur_pessimistic_update(
 		}
 	}
 
-	if (!(flags & BTR_KEEP_SYS_FLAG)
-	    && !dict_table_is_intrinsic(index->table)) {
+	if (!(flags & BTR_KEEP_SYS_FLAG)) {
 		row_upd_index_entry_sys_field(new_entry, index, DATA_ROLL_PTR,
 					      roll_ptr);
 		row_upd_index_entry_sys_field(new_entry, index, DATA_TRX_ID,
@@ -4682,7 +4360,7 @@ btr_cur_pessimistic_update(
 		}
 	}
 
-	if (big_rec_vec != NULL && !dict_table_is_intrinsic(index->table)) {
+	if (big_rec_vec != NULL) {
 		ut_ad(page_is_leaf(page));
 		ut_ad(dict_index_is_clust(index));
 		ut_ad(flags & BTR_KEEP_POS_FLAG);
@@ -4971,12 +4649,6 @@ btr_cur_del_mark_set_clust_rec(
 
 	btr_rec_set_deleted_flag(rec, page_zip, TRUE);
 
-	/* For intrinsic table, roll-ptr is not maintained as there is no UNDO
-	logging. Skip updating it. */
-	if (dict_table_is_intrinsic(index->table)) {
-		return(err);
-	}
-
 	trx = thr_get_trx(thr);
 	/* This function must not be invoked during rollback
 	(of a TRX_STATE_PREPARE transaction or otherwise). */
@@ -5175,16 +4847,9 @@ btr_cur_compress_if_useful(
 				cursor position even if compression occurs */
 	mtr_t*		mtr)	/*!< in/out: mini-transaction */
 {
-	/* Avoid applying compression as we don't accept lot of page garbage
-	given the workload of intrinsic table. */
-	if (dict_table_is_intrinsic(cursor->index->table)) {
-		return(FALSE);
-	}
-
 	ut_ad(mtr_memo_contains_flagged(
 		mtr, dict_index_get_lock(btr_cur_get_index(cursor)),
-		MTR_MEMO_X_LOCK | MTR_MEMO_SX_LOCK)
-	      || dict_table_is_intrinsic(cursor->index->table));
+		MTR_MEMO_X_LOCK | MTR_MEMO_SX_LOCK));
 	ut_ad(mtr_is_block_fix(
 		mtr, btr_cur_get_block(cursor),
 		MTR_MEMO_PAGE_X_FIX, cursor->index->table));
@@ -5368,8 +5033,7 @@ btr_cur_pessimistic_delete(
 	      || (flags & BTR_CREATE_FLAG));
 	ut_ad(mtr_memo_contains_flagged(mtr, dict_index_get_lock(index),
 					MTR_MEMO_X_LOCK
-					| MTR_MEMO_SX_LOCK)
-	      || dict_table_is_intrinsic(index->table));
+					| MTR_MEMO_SX_LOCK));
 	ut_ad(mtr_is_block_fix(mtr, block, MTR_MEMO_PAGE_X_FIX, index->table));
 	ut_ad(mtr->is_named_space(index->space));
 
@@ -6914,13 +6578,11 @@ struct btr_blob_log_check_t {
 
 		ut_ad(m_mtr->memo_contains_page_flagged(
 		      *m_rec,
-		      MTR_MEMO_PAGE_X_FIX | MTR_MEMO_PAGE_SX_FIX)
-		      || dict_table_is_intrinsic(index->table));
+		      MTR_MEMO_PAGE_X_FIX | MTR_MEMO_PAGE_SX_FIX));
 
 		ut_ad(mtr_memo_contains_flagged(m_mtr,
 		      dict_index_get_lock(index),
-		      MTR_MEMO_SX_LOCK | MTR_MEMO_X_LOCK)
-		      || dict_table_is_intrinsic(index->table));
+		      MTR_MEMO_SX_LOCK | MTR_MEMO_X_LOCK));
 	}
 };
 
@@ -6978,9 +6640,7 @@ btr_store_big_rec_extern_fields(
 	ut_ad(rec_offs_any_extern(offsets));
 	ut_ad(btr_mtr);
 	ut_ad(mtr_memo_contains_flagged(btr_mtr, dict_index_get_lock(index),
-					MTR_MEMO_X_LOCK
-					| MTR_MEMO_SX_LOCK)
-	      || dict_table_is_intrinsic(index->table));
+					MTR_MEMO_X_LOCK | MTR_MEMO_SX_LOCK));
 	ut_ad(mtr_is_block_fix(
 		btr_mtr, rec_block, MTR_MEMO_PAGE_X_FIX, index->table));
 	ut_ad(buf_block_get_frame(rec_block) == page_align(rec));
@@ -7479,9 +7139,7 @@ btr_free_externally_stored_field(
 
 	ut_ad(dict_index_is_clust(index));
 	ut_ad(mtr_memo_contains_flagged(local_mtr, dict_index_get_lock(index),
-					MTR_MEMO_X_LOCK
-					| MTR_MEMO_SX_LOCK)
-	      || dict_table_is_intrinsic(index->table));
+					MTR_MEMO_X_LOCK | MTR_MEMO_SX_LOCK));
 	ut_ad(mtr_is_page_fix(
 		local_mtr, field_ref, MTR_MEMO_PAGE_X_FIX, index->table));
 	ut_ad(!rec || rec_offs_validate(rec, index, offsets));