Remove remnants of the obsolete concept of memoryfixing tables and indexes.

Remove unused dict_table_LRU_trim().

Remove unused 'trx' parameter from the functions dict_table_get_on_id_low,
dict_table_get and dict_table_get_and_increment_handle_count.

dict/dict0dict.c

@@ -607,7 +607,7 @@ dict_index_get_nth_field_pos(
 }
 
 /**************************************************************************
-Returns a table object, based on table id, and memoryfixes it. */
+Returns a table object based on table id. */
 
 dict_table_t*
 dict_table_get_on_id(
@@ -629,12 +629,12 @@ dict_table_get_on_id(
 		ut_ad(mutex_own(&(dict_sys->mutex)));
 #endif /* UNIV_SYNC_DEBUG */
 
-		return(dict_table_get_on_id_low(table_id, trx));
+		return(dict_table_get_on_id_low(table_id));
 	}
 
 	mutex_enter(&(dict_sys->mutex));
 
-	table = dict_table_get_on_id_low(table_id, trx);
+	table = dict_table_get_on_id_low(table_id);
 
 	mutex_exit(&(dict_sys->mutex));
 
@@ -742,22 +742,19 @@ dict_init(void)
 }
 
 /**************************************************************************
-Returns a table object and memoryfixes it. NOTE! This is a high-level
-function to be used mainly from outside the 'dict' directory. Inside this
-directory dict_table_get_low is usually the appropriate function. */
+Returns a table object. NOTE! This is a high-level function to be used
+mainly from outside the 'dict' directory. Inside this directory
+dict_table_get_low is usually the appropriate function. */
 
 dict_table_t*
 dict_table_get(
 /*===========*/
 					/* out: table, NULL if
 					does not exist */
-	const char*	table_name,	/* in: table name */
-	trx_t*		trx)		/* in: transaction handle or NULL */
+	const char*	table_name)	/* in: table name */
 {
 	dict_table_t*	table;
 
-	UT_NOT_USED(trx);
-
 	mutex_enter(&(dict_sys->mutex));
 
 	table = dict_table_get_low(table_name);
@@ -781,13 +778,10 @@ dict_table_get_and_increment_handle_count(
 /*======================================*/
 					/* out: table, NULL if
 					does not exist */
-	const char*	table_name,	/* in: table name */
-	trx_t*		trx)		/* in: transaction handle or NULL */
+	const char*	table_name)	/* in: table name */
 {
 	dict_table_t*	table;
 
-	UT_NOT_USED(trx);
-
 	mutex_enter(&(dict_sys->mutex));
 
 	table = dict_table_get_low(table_name);
@@ -897,10 +891,7 @@ dict_table_add_to_cache(
 	/* Add table to LRU list of tables */
 	UT_LIST_ADD_FIRST(table_LRU, dict_sys->table_LRU, table);
 
-	/* If the dictionary cache grows too big, trim the table LRU list */
-
 	dict_sys->size += mem_heap_get_size(table->heap);
-	/* dict_table_LRU_trim(); */
 }
 
 /**************************************************************************
@@ -1265,38 +1256,6 @@ dict_table_remove_from_cache(
 	dict_mem_table_free(table);
 }
 
-/**************************************************************************
-Frees tables from the end of table_LRU if the dictionary cache occupies
-too much space. Currently not used! */
-
-void
-dict_table_LRU_trim(void)
-/*=====================*/
-{
-	dict_table_t*	table;
-	dict_table_t*	prev_table;
-
-	ut_error;
-
-#ifdef UNIV_SYNC_DEBUG
-	ut_ad(mutex_own(&(dict_sys->mutex)));
-#endif /* UNIV_SYNC_DEBUG */
-
-	table = UT_LIST_GET_LAST(dict_sys->table_LRU);
-
-	while (table && (dict_sys->size >
-			 buf_pool_get_max_size() / DICT_POOL_PER_VARYING)) {
-
-		prev_table = UT_LIST_GET_PREV(table_LRU, table);
-
-		if (table->mem_fix == 0) {
-			dict_table_remove_from_cache(table);
-		}
-
-		table = prev_table;
-	}
-}
-
 /**************************************************************************
 Adds a column to the data dictionary hash table. */
 static
@@ -1526,10 +1485,7 @@ dict_index_add_to_cache(
 	/* Add the index to the list of indexes stored in the tree */
 	tree->tree_index = new_index;
 
-	/* If the dictionary cache grows too big, trim the table LRU list */
-
 	dict_sys->size += mem_heap_get_size(new_index->heap);
-	/* dict_table_LRU_trim(); */
 
 	dict_mem_index_free(index);
 

dict/dict0mem.c

@@ -58,7 +58,6 @@ dict_mem_table_create(
 	table->tablespace_discarded = FALSE;
 	table->n_def = 0;
 	table->n_cols = n_cols + DATA_N_SYS_COLS;
-	table->mem_fix = 0;
 
 	table->n_mysql_handles_opened = 0;
 	table->n_foreign_key_checks_running = 0;

handler/ha_innodb.cc

@@ -2444,8 +2444,7 @@ ha_innobase::open(
 
 	/* Get pointer to a table object in InnoDB dictionary cache */
 
-	ib_table = dict_table_get_and_increment_handle_count(
-		norm_name, NULL);
+	ib_table = dict_table_get_and_increment_handle_count(norm_name);
 
 	if (NULL == ib_table) {
 		ut_print_timestamp(stderr);
@@ -5026,7 +5025,7 @@ ha_innobase::create(
 
 	log_buffer_flush_to_disk();
 
-	innobase_table = dict_table_get(norm_name, NULL);
+	innobase_table = dict_table_get(norm_name);
 
 	DBUG_ASSERT(innobase_table != 0);
 

include/dict0dict.h

@@ -265,17 +265,16 @@ dict_foreign_parse_drop_constraints(
 	const char***	constraints_to_drop);	/* out: id's of the
 						constraints to drop */
 /**************************************************************************
-Returns a table object and memoryfixes it. NOTE! This is a high-level
-function to be used mainly from outside the 'dict' directory. Inside this
-directory dict_table_get_low is usually the appropriate function. */
+Returns a table object. NOTE! This is a high-level function to be used
+mainly from outside the 'dict' directory. Inside this directory
+dict_table_get_low is usually the appropriate function. */
 
 dict_table_t*
 dict_table_get(
 /*===========*/
 					/* out: table, NULL if
 					does not exist */
-	const char*	table_name,	/* in: table name */
-	trx_t*		trx);		/* in: transaction handle */
+	const char*	table_name);	/* in: table name */
 /**************************************************************************
 Returns a table object and increments MySQL open handle count on the table.
 */
@@ -285,10 +284,9 @@ dict_table_get_and_increment_handle_count(
 /*======================================*/
 					/* out: table, NULL if
 					does not exist */
-	const char*	table_name,	/* in: table name */
-	trx_t*		trx);		/* in: transaction handle or NULL */
+	const char*	table_name);	/* in: table name */
 /**************************************************************************
-Returns a table object, based on table id, and memoryfixes it. */
+Returns a table object based on table id. */
 
 dict_table_t*
 dict_table_get_on_id(
@@ -297,21 +295,13 @@ dict_table_get_on_id(
 	dulint	table_id,	/* in: table id */
 	trx_t*	trx);		/* in: transaction handle */
 /**************************************************************************
-Returns a table object, based on table id, and memoryfixes it. */
+Returns a table object based on table id. */
 UNIV_INLINE
 dict_table_t*
 dict_table_get_on_id_low(
 /*=====================*/
 				/* out: table, NULL if does not exist */
-	dulint	table_id,	/* in: table id */
-	trx_t*	trx);		/* in: transaction handle */
-/**************************************************************************
-Releases a table from being memoryfixed. Currently this has no relevance. */
-UNIV_INLINE
-void
-dict_table_release(
-/*===============*/
-	dict_table_t*	table);	/* in: table to be released */
+	dulint	table_id);	/* in: table id */
 /**************************************************************************
 Checks if a table is in the dictionary cache. */
 UNIV_INLINE

include/dict0dict.ic

@@ -545,14 +545,13 @@ dict_table_get_low(
 }
 
 /**************************************************************************
-Returns a table object, based on table id, and memoryfixes it. */
+Returns a table object based on table id. */
 UNIV_INLINE
 dict_table_t*
 dict_table_get_on_id_low(
 /*=====================*/
 				/* out: table, NULL if does not exist */
-	dulint	table_id,	/* in: table id */
-	trx_t*	trx)		/* in: transaction handle */
+	dulint	table_id)	/* in: table id */
 {
 	dict_table_t*	table;
 	ulint		fold;
@@ -560,7 +559,6 @@ dict_table_get_on_id_low(
 #ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(&(dict_sys->mutex)));
 #endif /* UNIV_SYNC_DEBUG */
-	UT_NOT_USED(trx);
 
 	/* Look for the table name in the hash table */
 	fold = ut_fold_dulint(table_id);
@@ -571,32 +569,11 @@ dict_table_get_on_id_low(
 		table = dict_load_table_on_id(table_id);
 	}
 
-	if (table != NULL) {
-		table->mem_fix++;
-
-		/* lock_push(trx, table, LOCK_DICT_MEM_FIX) */
-	}
-
 	/* TODO: should get the type information from MySQL */
 
 	return(table);
 }
 
-/**************************************************************************
-Releases a table from being memoryfixed. Currently this has no relevance. */
-UNIV_INLINE
-void
-dict_table_release(
-/*===============*/
-	dict_table_t*	table)	/* in: table to be released */
-{
-	mutex_enter(&(dict_sys->mutex));
-
-	table->mem_fix--;
-
-	mutex_exit(&(dict_sys->mutex));
-}
-
 /**************************************************************************
 Returns an index object. */
 UNIV_INLINE

include/dict0mem.h

@@ -169,10 +169,6 @@ struct dict_tree_struct{
 				the same memory cache line */
 	rw_lock_t	lock;	/* read-write lock protecting the upper levels
 				of the index tree */
-	ulint		mem_fix;/* count of how many times this tree
-				struct has been memoryfixed (by mini-
-				transactions wanting to access the index
-				tree) */
 	dict_index_t*	tree_index; /* the index stored in the
 				index tree */
 	ulint		magic_n;/* magic number */
@@ -315,9 +311,6 @@ struct dict_table_struct{
 				which refer to this table */
 	UT_LIST_NODE_T(dict_table_t)
 			table_LRU; /* node of the LRU list of tables */
-	ulint		mem_fix;/* count of how many times the table
-				and its indexes has been fixed in memory;
-				currently NOT used */
 	ulint		n_mysql_handles_opened;
 				/* count of how many handles MySQL has opened
 				to this table; dropping of the table is

include/row0purge.h

@@ -56,9 +56,7 @@ struct purge_node_struct{
 				determined by ref was found in the clustered
 				index, and we were able to position pcur on
 				it */
-	dict_table_t*	table;	/* table where purge is done; NOTE that the
-				table has to be released explicitly with
-				dict_table_release */
+	dict_table_t*	table;	/* table where purge is done */
 	ulint		cmpl_info;/* compiler analysis info of an update */
 	upd_t*		update;	/* update vector for a clustered index record */
 	dtuple_t*	ref;	/* NULL, or row reference to the next row to

include/row0undo.h

@@ -84,9 +84,7 @@ struct undo_node_struct{
 				record */
 	btr_pcur_t	pcur;	/* persistent cursor used in searching the
 				clustered index record */
-	dict_table_t*	table;	/* table where undo is done; NOTE that the
-				table has to be released explicitly with
-				dict_table_release */
+	dict_table_t*	table;	/* table where undo is done */
 	ulint		cmpl_info;/* compiler analysis of an update */
 	upd_t*		update;	/* update vector for a clustered index record */
 	dtuple_t*	ref;	/* row reference to the next row to handle */

row/row0ins.c

@@ -1513,8 +1513,7 @@ row_ins_check_foreign_constraints(
 		if (foreign->foreign_index == index) {
 
 			if (foreign->referenced_table == NULL) {
-				dict_table_get(foreign->referenced_table_name,
-									trx);
+				dict_table_get(foreign->referenced_table_name);
 			}
 
 			if (0 == trx->dict_operation_lock_mode) {

row/row0purge.c

@@ -520,7 +520,7 @@ row_purge_parse_undo_rec(
 
 	mutex_enter(&(dict_sys->mutex));
 
-	node->table = dict_table_get_on_id_low(table_id, trx);
+	node->table = dict_table_get_on_id_low(table_id);
 
 	mutex_exit(&(dict_sys->mutex));
 

row/row0sel.c

@@ -4402,7 +4402,7 @@ row_search_check_if_query_cache_permitted(
 	dict_table_t*	table;
 	ibool		ret	= FALSE;
 
-	table = dict_table_get(norm_name, trx);
+	table = dict_table_get(norm_name);
 
 	if (table == NULL) {
 

row/row0upd.c

@@ -202,8 +202,7 @@ row_upd_check_references_constraints(
 					foreign->n_fields))) {
 
 			if (foreign->foreign_table == NULL) {
-				dict_table_get(foreign->foreign_table_name,
-									trx);
+				dict_table_get(foreign->foreign_table_name);
 			}
 
 			if (foreign->foreign_table) {

trx/trx0roll.c

@@ -540,7 +540,7 @@ loop:
 			(ulong) ut_dulint_get_high(trx->table_id),
 			(ulong) ut_dulint_get_low(trx->table_id));
 
-		table = dict_table_get_on_id_low(trx->table_id, trx);
+		table = dict_table_get_on_id_low(trx->table_id);
 
 		if (table) {
 			fputs("InnoDB: Table found: dropping table ", stderr);