Merge (5368ba56) · Commits · Software / OSDI20 Artifacts / mariadb

sql/ha_ndbcluster.cc

+145 −52

Original line number	Diff line number	Diff line
		@@ -39,9 +39,6 @@ static const int parallelism= 240;
		// createable against NDB from this handler
		static const int max_transactions= 256;

		// Default value for prefetch of autoincrement values
		static const ha_rows autoincrement_prefetch= 32;

		// connectstring to cluster if given by mysqld
		const char *ndbcluster_connectstring= 0;

		@@ -103,51 +100,52 @@ struct err_code_mapping
		{
		int ndb_err;
		int my_err;
		int show_warning;
		};

		static const err_code_mapping err_map[]=
		{
		{ 626, HA_ERR_KEY_NOT_FOUND },
		{ 630, HA_ERR_FOUND_DUPP_KEY },
		{ 893, HA_ERR_FOUND_DUPP_UNIQUE },
		{ 721, HA_ERR_TABLE_EXIST },
		{ 4244, HA_ERR_TABLE_EXIST },
		{ 626, HA_ERR_KEY_NOT_FOUND, 0 },
		{ 630, HA_ERR_FOUND_DUPP_KEY, 0 },
		{ 893, HA_ERR_FOUND_DUPP_UNIQUE, 0 },
		{ 721, HA_ERR_TABLE_EXIST, 1 },
		{ 4244, HA_ERR_TABLE_EXIST, 1 },

		{ 709, HA_ERR_NO_SUCH_TABLE },
		{ 284, HA_ERR_NO_SUCH_TABLE },
		{ 709, HA_ERR_NO_SUCH_TABLE, 1 },
		{ 284, HA_ERR_NO_SUCH_TABLE, 1 },

		{ 266, HA_ERR_LOCK_WAIT_TIMEOUT },
		{ 274, HA_ERR_LOCK_WAIT_TIMEOUT },
		{ 296, HA_ERR_LOCK_WAIT_TIMEOUT },
		{ 297, HA_ERR_LOCK_WAIT_TIMEOUT },
		{ 237, HA_ERR_LOCK_WAIT_TIMEOUT },
		{ 266, HA_ERR_LOCK_WAIT_TIMEOUT, 1 },
		{ 274, HA_ERR_LOCK_WAIT_TIMEOUT, 1 },
		{ 296, HA_ERR_LOCK_WAIT_TIMEOUT, 1 },
		{ 297, HA_ERR_LOCK_WAIT_TIMEOUT, 1 },
		{ 237, HA_ERR_LOCK_WAIT_TIMEOUT, 1 },

		{ 623, HA_ERR_RECORD_FILE_FULL },
		{ 624, HA_ERR_RECORD_FILE_FULL },
		{ 625, HA_ERR_RECORD_FILE_FULL },
		{ 826, HA_ERR_RECORD_FILE_FULL },
		{ 827, HA_ERR_RECORD_FILE_FULL },
		{ 832, HA_ERR_RECORD_FILE_FULL },
		{ 623, HA_ERR_RECORD_FILE_FULL, 1 },
		{ 624, HA_ERR_RECORD_FILE_FULL, 1 },
		{ 625, HA_ERR_RECORD_FILE_FULL, 1 },
		{ 826, HA_ERR_RECORD_FILE_FULL, 1 },
		{ 827, HA_ERR_RECORD_FILE_FULL, 1 },
		{ 832, HA_ERR_RECORD_FILE_FULL, 1 },

		{ 0, 1 },
		{ 0, 1, 0 },

		{ -1, -1 }
		{ -1, -1, 1 }
		};


		static int ndb_to_mysql_error(const NdbError *err)
		{
		uint i;
		for (i=0 ; err_map[i].ndb_err != err->code ; i++)
		for (i=0; err_map[i].ndb_err != err->code && err_map[i].my_err != -1; i++);
		if (err_map[i].show_warning)
		{
		if (err_map[i].my_err == -1){
		// Push the NDB error message as warning
		push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_ERROR,
		ER_GET_ERRMSG, ER(ER_GET_ERRMSG),
		err->code, err->message, "NDB");
		return err->code;
		}
		}
		if (err_map[i].my_err == -1)
		return err->code;
		return err_map[i].my_err;
		}

		@@ -161,7 +159,7 @@ int execute_no_commit(ha_ndbcluster h, NdbConnection trans)
		if (m_batch_execute)
		return 0;
		#endif
		return trans->execute(NoCommit,AbortOnError,1);
		return trans->execute(NoCommit,AbortOnError,h->m_force_send);
		}

		inline
		@@ -172,7 +170,18 @@ int execute_commit(ha_ndbcluster h, NdbConnection trans)
		if (m_batch_execute)
		return 0;
		#endif
		return trans->execute(Commit,AbortOnError,1);
		return trans->execute(Commit,AbortOnError,h->m_force_send);
		}

		inline
		int execute_commit(THD thd, NdbConnection trans)
		{
		int m_batch_execute= 0;
		#ifdef NOT_USED
		if (m_batch_execute)
		return 0;
		#endif
		return trans->execute(Commit,AbortOnError,thd->variables.ndb_force_send);
		}

		inline
		@@ -183,7 +192,7 @@ int execute_no_commit_ie(ha_ndbcluster h, NdbConnection trans)
		if (m_batch_execute)
		return 0;
		#endif
		return trans->execute(NoCommit,IgnoreError,1);
		return trans->execute(NoCommit,IgnoreError,h->m_force_send);
		}

		/*
		@@ -226,6 +235,8 @@ void ha_ndbcluster::set_rec_per_key()

		void ha_ndbcluster::records_update()
		{
		if (m_ha_not_exact_count)
		return;
		DBUG_ENTER("ha_ndbcluster::records_update");
		struct Ndb_table_local_info info= (struct Ndb_table_local_info )m_table_info;
		DBUG_PRINT("info", ("id=%d, no_uncommitted_rows_count=%d",
		@@ -249,6 +260,8 @@ void ha_ndbcluster::records_update()

		void ha_ndbcluster::no_uncommitted_rows_execute_failure()
		{
		if (m_ha_not_exact_count)
		return;
		DBUG_ENTER("ha_ndbcluster::no_uncommitted_rows_execute_failure");
		THD *thd= current_thd;
		((Thd_ndb*)(thd->transaction.thd_ndb))->error= 1;
		@@ -257,6 +270,8 @@ void ha_ndbcluster::no_uncommitted_rows_execute_failure()

		void ha_ndbcluster::no_uncommitted_rows_init(THD *thd)
		{
		if (m_ha_not_exact_count)
		return;
		DBUG_ENTER("ha_ndbcluster::no_uncommitted_rows_init");
		struct Ndb_table_local_info info= (struct Ndb_table_local_info )m_table_info;
		Thd_ndb thd_ndb= (Thd_ndb )thd->transaction.thd_ndb;
		@@ -274,6 +289,8 @@ void ha_ndbcluster::no_uncommitted_rows_init(THD *thd)

		void ha_ndbcluster::no_uncommitted_rows_update(int c)
		{
		if (m_ha_not_exact_count)
		return;
		DBUG_ENTER("ha_ndbcluster::no_uncommitted_rows_update");
		struct Ndb_table_local_info *info=
		(struct Ndb_table_local_info *)m_table_info;
		@@ -286,6 +303,8 @@ void ha_ndbcluster::no_uncommitted_rows_update(int c)

		void ha_ndbcluster::no_uncommitted_rows_reset(THD *thd)
		{
		if (m_ha_not_exact_count)
		return;
		DBUG_ENTER("ha_ndbcluster::no_uncommitted_rows_reset");
		((Thd_ndb*)(thd->transaction.thd_ndb))->count++;
		((Thd_ndb*)(thd->transaction.thd_ndb))->error= 0;
		@@ -1222,7 +1241,8 @@ inline int ha_ndbcluster::next_result(byte *buf)
		DBUG_PRINT("info", ("ops_pending: %d", m_ops_pending));
		if (m_ops_pending)
		{
		if (current_thd->transaction.on)
		// if (current_thd->transaction.on)
		if (m_transaction_on)
		{
		if (execute_no_commit(this,trans) != 0)
		DBUG_RETURN(ndb_err(trans));
		@@ -1708,7 +1728,8 @@ int ha_ndbcluster::write_row(byte *record)
		(int)m_rows_inserted, (int)m_bulk_insert_rows));

		m_bulk_insert_not_flushed= FALSE;
		if (thd->transaction.on)
		// if (thd->transaction.on)
		if (m_transaction_on)
		{
		if (execute_no_commit(this,trans) != 0)
		{
		@@ -1881,7 +1902,7 @@ int ha_ndbcluster::update_row(const byte old_data, byte new_data)
		for (i= 0; i < table->fields; i++)
		{
		Field *field= table->field[i];
		if ((thd->query_id == field->query_id) &&
		if (((thd->query_id == field->query_id) \|\| m_retrieve_all_fields) &&
		(!(field->flags & PRI_KEY_FLAG)) &&
		set_ndb_value(op, field, i))
		ERR_RETURN(op->getNdbError());
		@@ -2540,16 +2561,19 @@ void ha_ndbcluster::info(uint flag)
		DBUG_PRINT("info", ("HA_STATUS_VARIABLE"));
		if (m_table_info)
		{
		if (m_ha_not_exact_count)
		records= 100;
		else
		records_update();
		}
		else
		{
		Uint64 rows;
		if(ndb_get_table_statistics(m_ndb, m_tabname, &rows, 0) == 0){
		Uint64 rows= 100;
		if (current_thd->variables.ndb_use_exact_count)
		ndb_get_table_statistics(m_ndb, m_tabname, &rows, 0);
		records= rows;
		}
		}
		}
		if (flag & HA_STATUS_CONST)
		{
		DBUG_PRINT("info", ("HA_STATUS_CONST"));
		@@ -2936,6 +2960,15 @@ int ha_ndbcluster::external_lock(THD *thd, int lock_type)
		pointer to point to the NDB transaction.
		*/

		// store thread specific data first to set the right context
		m_force_send= thd->variables.ndb_force_send;
		m_ha_not_exact_count= !thd->variables.ndb_use_exact_count;
		m_autoincrement_prefetch= thd->variables.ndb_autoincrement_prefetch_sz;
		if (!thd->transaction.on)
		m_transaction_on= FALSE;
		else
		m_transaction_on= thd->variables.ndb_use_transactions;

		m_active_trans= thd->transaction.all.ndb_tid ?
		(NdbConnection*)thd->transaction.all.ndb_tid:
		(NdbConnection*)thd->transaction.stmt.ndb_tid;
		@@ -3056,7 +3089,7 @@ int ndbcluster_commit(THD thd, void ndb_transaction)
		"stmt" : "all"));
		DBUG_ASSERT(ndb && trans);

		if (execute_commit(0,trans) != 0)
		if (execute_commit(thd,trans) != 0)
		{
		const NdbError err= trans->getNdbError();
		const NdbOperation *error_op= trans->getNdbErrorOperation();
		@@ -3610,11 +3643,11 @@ longlong ha_ndbcluster::get_auto_increment()
		DBUG_ENTER("get_auto_increment");
		DBUG_PRINT("enter", ("m_tabname: %s", m_tabname));
		int cache_size=
		(m_rows_to_insert - m_rows_inserted < autoincrement_prefetch) ?
		(m_rows_to_insert - m_rows_inserted < m_autoincrement_prefetch) ?
		m_rows_to_insert - m_rows_inserted
		: (m_rows_to_insert > autoincrement_prefetch) ?
		: (m_rows_to_insert > m_autoincrement_prefetch) ?
		m_rows_to_insert
		: autoincrement_prefetch;
		: m_autoincrement_prefetch;
		Uint64 auto_value=
		(m_skip_auto_increment) ?
		m_ndb->readAutoIncrementValue((const NDBTAB *) m_table)
		@@ -3652,7 +3685,11 @@ ha_ndbcluster::ha_ndbcluster(TABLE *table_arg):
		m_blobs_pending(0),
		m_blobs_buffer(0),
		m_blobs_buffer_size(0),
		m_dupkey((uint) -1)
		m_dupkey((uint) -1),
		m_ha_not_exact_count(FALSE),
		m_force_send(TRUE),
		m_autoincrement_prefetch(32),
		m_transaction_on(TRUE)
		{
		int i;

		@@ -4302,6 +4339,62 @@ ha_ndbcluster::records_in_range(uint inx, key_range *min_key,
		DBUG_RETURN(10); /* Good guess when you don't know anything */
		}

		ulong ha_ndbcluster::table_flags(void) const
		{
		if (m_ha_not_exact_count)
		return m_table_flags \| HA_NOT_EXACT_COUNT;
		else
		return m_table_flags;
		}
		const char * ha_ndbcluster::table_type() const
		{
		return("ndbcluster");
		}
		uint ha_ndbcluster::max_supported_record_length() const
		{
		return NDB_MAX_TUPLE_SIZE;
		}
		uint ha_ndbcluster::max_supported_keys() const
		{
		return MAX_KEY;
		}
		uint ha_ndbcluster::max_supported_key_parts() const
		{
		return NDB_MAX_NO_OF_ATTRIBUTES_IN_KEY;
		}
		uint ha_ndbcluster::max_supported_key_length() const
		{
		return NDB_MAX_KEY_SIZE;
		}
		bool ha_ndbcluster::low_byte_first() const
		{
		#ifdef WORDS_BIGENDIAN
		return FALSE;
		#else
		return TRUE;
		#endif
		}
		bool ha_ndbcluster::has_transactions()
		{
		return TRUE;
		}
		const char* ha_ndbcluster::index_type(uint key_number)
		{
		switch (get_index_type(key_number)) {
		case ORDERED_INDEX:
		case UNIQUE_ORDERED_INDEX:
		case PRIMARY_KEY_ORDERED_INDEX:
		return "BTREE";
		case UNIQUE_INDEX:
		case PRIMARY_KEY_INDEX:
		default:
		return "HASH";
		}
		}
		uint8 ha_ndbcluster::table_cache_type()
		{
		return HA_CACHE_TBL_NOCACHE;
		}

		/*
		Handling the shared NDB_SHARE structure that is needed to

sql/ha_ndbcluster.h

+16 −30

Original line number	Diff line number	Diff line
		@@ -118,15 +118,14 @@ class ha_ndbcluster: public handler
		int reset();
		int external_lock(THD *thd, int lock_type);
		int start_stmt(THD *thd);
		const char * table_type() const { return("ndbcluster");}
		const char * table_type() const;
		const char ** bas_ext() const;
		ulong table_flags(void) const { return m_table_flags; }
		ulong table_flags(void) const;
		ulong index_flags(uint idx, uint part, bool all_parts) const;
		uint max_supported_record_length() const { return NDB_MAX_TUPLE_SIZE; };
		uint max_supported_keys() const { return MAX_KEY; }
		uint max_supported_key_parts() const
		{ return NDB_MAX_NO_OF_ATTRIBUTES_IN_KEY; };
		uint max_supported_key_length() const { return NDB_MAX_KEY_SIZE;};
		uint max_supported_record_length() const;
		uint max_supported_keys() const;
		uint max_supported_key_parts() const;
		uint max_supported_key_length() const;

		int rename_table(const char from, const char to);
		int delete_table(const char *name);
		@@ -135,28 +134,9 @@ class ha_ndbcluster: public handler
		THR_LOCK_DATA **to,
		enum thr_lock_type lock_type);

		bool low_byte_first() const
		{
		#ifdef WORDS_BIGENDIAN
		return FALSE;
		#else
		return TRUE;
		#endif
		}
		bool has_transactions() { return TRUE; }

		const char* index_type(uint key_number) {
		switch (get_index_type(key_number)) {
		case ORDERED_INDEX:
		case UNIQUE_ORDERED_INDEX:
		case PRIMARY_KEY_ORDERED_INDEX:
		return "BTREE";
		case UNIQUE_INDEX:
		case PRIMARY_KEY_INDEX:
		default:
		return "HASH";
		}
		}
		bool low_byte_first() const;
		bool has_transactions();
		const char* index_type(uint key_number);

		double scan_time();
		ha_rows records_in_range(uint inx, key_range min_key, key_range max_key);
		@@ -165,7 +145,7 @@ class ha_ndbcluster: public handler

		static Thd_ndb* seize_thd_ndb();
		static void release_thd_ndb(Thd_ndb* thd_ndb);
		uint8 table_cache_type() { return HA_CACHE_TBL_NOCACHE; }
		uint8 table_cache_type();

		private:
		int alter_table_name(const char from, const char to);
		@@ -256,6 +236,10 @@ class ha_ndbcluster: public handler
		char *m_blobs_buffer;
		uint32 m_blobs_buffer_size;
		uint m_dupkey;
		bool m_ha_not_exact_count;
		bool m_force_send;
		ha_rows m_autoincrement_prefetch;
		bool m_transaction_on;

		void set_rec_per_key();
		void records_update();
		@@ -265,6 +249,8 @@ class ha_ndbcluster: public handler
		void no_uncommitted_rows_reset(THD *);

		friend int execute_no_commit(ha_ndbcluster, NdbConnection);
		friend int execute_commit(ha_ndbcluster, NdbConnection);
		friend int execute_no_commit_ie(ha_ndbcluster, NdbConnection);
		};

		bool ndbcluster_init(void);

sql/mysqld.cc

+30 −4

Original line number	Diff line number	Diff line
		@@ -3947,7 +3947,11 @@ enum options_mysqld
		OPT_INNODB_FILE_PER_TABLE, OPT_CRASH_BINLOG_INNODB,
		OPT_INNODB_LOCKS_UNSAFE_FOR_BINLOG,
		OPT_SAFE_SHOW_DB, OPT_INNODB_SAFE_BINLOG,
		OPT_INNODB, OPT_ISAM, OPT_NDBCLUSTER, OPT_NDB_CONNECTSTRING, OPT_SKIP_SAFEMALLOC,
		OPT_INNODB, OPT_ISAM,
		OPT_NDBCLUSTER, OPT_NDB_CONNECTSTRING, OPT_NDB_USE_EXACT_COUNT,
		OPT_NDB_FORCE_SEND, OPT_NDB_AUTOINCREMENT_PREFETCH_SZ,
		OPT_NDB_USE_TRANSACTIONS,
		OPT_SKIP_SAFEMALLOC,
		OPT_TEMP_POOL, OPT_TX_ISOLATION,
		OPT_SKIP_STACK_TRACE, OPT_SKIP_SYMLINKS,
		OPT_MAX_BINLOG_DUMP_EVENTS, OPT_SPORADIC_BINLOG_DUMP_FAIL,
		@@ -4386,9 +4390,31 @@ Disable with --skip-ndbcluster (will save memory).",
		(gptr) &opt_ndbcluster, (gptr) &opt_ndbcluster, 0, GET_BOOL, NO_ARG, 1, 0, 0,
		0, 0, 0},
		#ifdef HAVE_NDBCLUSTER_DB
		{"ndb-connectstring", OPT_NDB_CONNECTSTRING, "Connect string for ndbcluster.",
		(gptr) &ndbcluster_connectstring, (gptr) &ndbcluster_connectstring, 0, GET_STR,
		REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
		{"ndb-connectstring", OPT_NDB_CONNECTSTRING,
		"Connect string for ndbcluster.",
		(gptr) &ndbcluster_connectstring, (gptr) &ndbcluster_connectstring,
		0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
		{"ndb_autoincrement_prefetch_sz", OPT_NDB_AUTOINCREMENT_PREFETCH_SZ,
		"Specify number of autoincrement values that are prefetched",
		(gptr*) &global_system_variables.ndb_autoincrement_prefetch_sz,
		(gptr*) &global_system_variables.ndb_autoincrement_prefetch_sz,
		0, GET_INT, REQUIRED_ARG, 32, 1, 256, 0, 0, 0},
		{"ndb_force_send", OPT_NDB_FORCE_SEND,
		"Force send of buffers to ndb immediately without waiting for other threads",
		(gptr*) &global_system_variables.ndb_force_send,
		(gptr*) &global_system_variables.ndb_force_send,
		0, GET_BOOL, OPT_ARG, 1, 0, 0, 0, 0, 0},
		{"ndb_use_exact_count", OPT_NDB_USE_EXACT_COUNT,
		"Use exact records count during query planning and for "
		"fast select count(*)",
		(gptr*) &global_system_variables.ndb_use_exact_count,
		(gptr*) &global_system_variables.ndb_use_exact_count,
		0, GET_BOOL, OPT_ARG, 1, 0, 0, 0, 0, 0},
		{"ndb_use_transactions", OPT_NDB_USE_TRANSACTIONS,
		"Use transactions in ndb",
		(gptr*) &global_system_variables.ndb_use_transactions,
		(gptr*) &global_system_variables.ndb_use_transactions,
		0, GET_BOOL, OPT_ARG, 1, 0, 0, 0, 0, 0},
		#endif
		{"new", 'n', "Use very new possible 'unsafe' functions.",
		(gptr*) &global_system_variables.new_mode,

sql/set_var.cc

+31 −1

Original line number	Diff line number	Diff line
		@@ -359,6 +359,23 @@ sys_var_thd_bool sys_innodb_table_locks("innodb_table_locks",
		sys_var_long_ptr sys_innodb_autoextend_increment("innodb_autoextend_increment",
		&srv_auto_extend_increment);
		#endif
		#ifdef HAVE_NDBCLUSTER_DB
		// ndb thread specific variable settings
		sys_var_thd_ulong
		sys_ndb_autoincrement_prefetch_sz("ndb_autoincrement_prefetch_sz",
		&SV::ndb_autoincrement_prefetch_sz);
		sys_var_thd_bool
		sys_ndb_force_send("ndb_force_send",
		&SV::ndb_force_send);
		sys_var_thd_bool
		sys_ndb_use_exact_count("ndb_use_exact_count",
		&SV::ndb_use_exact_count);
		sys_var_thd_bool
		sys_ndb_use_transactions("ndb_use_transactions",
		&SV::ndb_use_transactions);
		// ndb server global variable settings
		// none
		#endif

		/* Time/date/datetime formats */

		@@ -612,6 +629,12 @@ sys_var *sys_variables[]=
		&sys_innodb_table_locks,
		&sys_innodb_max_purge_lag,
		&sys_innodb_autoextend_increment,
		#endif
		#ifdef HAVE_NDBCLUSTER_DB
		&sys_ndb_autoincrement_prefetch_sz,
		&sys_ndb_force_send,
		&sys_ndb_use_exact_count,
		&sys_ndb_use_transactions,
		#endif
		&sys_unique_checks,
		&sys_warning_count
		@@ -772,6 +795,13 @@ struct show_var_st init_vars[]= {
		{sys_myisam_sort_buffer_size.name, (char*) &sys_myisam_sort_buffer_size, SHOW_SYS},
		#ifdef __NT__
		{"named_pipe", (char*) &opt_enable_named_pipe, SHOW_MY_BOOL},
		#endif
		#ifdef HAVE_NDBCLUSTER_DB
		{sys_ndb_autoincrement_prefetch_sz.name,
		(char*) &sys_ndb_autoincrement_prefetch_sz, SHOW_SYS},
		{sys_ndb_force_send.name, (char*) &sys_ndb_force_send, SHOW_SYS},
		{sys_ndb_use_exact_count.name,(char*) &sys_ndb_use_exact_count, SHOW_SYS},
		{sys_ndb_use_transactions.name,(char*) &sys_ndb_use_transactions, SHOW_SYS},
		#endif
		{sys_net_buffer_length.name,(char*) &sys_net_buffer_length, SHOW_SYS},
		{sys_net_read_timeout.name, (char*) &sys_net_read_timeout, SHOW_SYS},

sql/sql_acl.cc

+27 −10

Original line number	Diff line number	Diff line
		@@ -1384,8 +1384,10 @@ static bool update_user_table(THD thd, const char host, const char *user,
		table->field[0]->store(host,(uint) strlen(host), &my_charset_latin1);
		table->field[1]->store(user,(uint) strlen(user), &my_charset_latin1);

		table->file->extra(HA_EXTRA_RETRIEVE_ALL_COLS);
		if (table->file->index_read_idx(table->record[0],0,
		(byte*) table->field[0]->ptr,0,
		(byte*) table->field[0]->ptr,
		table->key_info[0].key_length,
		HA_READ_KEY_EXACT))
		{
		my_error(ER_PASSWORD_NO_MATCH,MYF(0)); /* purecov: deadcode */
		@@ -1463,8 +1465,10 @@ static int replace_user_table(THD thd, TABLE table, const LEX_USER &combo,

		table->field[0]->store(combo.host.str,combo.host.length, &my_charset_latin1);
		table->field[1]->store(combo.user.str,combo.user.length, &my_charset_latin1);
		table->file->extra(HA_EXTRA_RETRIEVE_ALL_COLS);
		if (table->file->index_read_idx(table->record[0], 0,
		(byte*) table->field[0]->ptr,0,
		(byte*) table->field[0]->ptr,
		table->key_info[0].key_length,
		HA_READ_KEY_EXACT))
		{
		if (!create_user)
		@@ -1568,6 +1572,7 @@ static int replace_user_table(THD thd, TABLE table, const LEX_USER &combo,
		We should NEVER delete from the user table, as a uses can still
		use mysqld even if he doesn't have any privileges in the user table!
		*/
		table->file->extra(HA_EXTRA_RETRIEVE_ALL_COLS);
		if (cmp_record(table,record[1]) &&
		(error=table->file->update_row(table->record[1],table->record[0])))
		{ // This should never happen
		@@ -1645,7 +1650,10 @@ static int replace_db_table(TABLE table, const char db,
		table->field[0]->store(combo.host.str,combo.host.length, &my_charset_latin1);
		table->field[1]->store(db,(uint) strlen(db), &my_charset_latin1);
		table->field[2]->store(combo.user.str,combo.user.length, &my_charset_latin1);
		if (table->file->index_read_idx(table->record[0],0,(byte*) table->field[0]->ptr,0,
		table->file->extra(HA_EXTRA_RETRIEVE_ALL_COLS);
		if (table->file->index_read_idx(table->record[0],0,
		(byte*) table->field[0]->ptr,
		table->key_info[0].key_length,
		HA_READ_KEY_EXACT))
		{
		if (what == 'N')
		@@ -1679,6 +1687,7 @@ static int replace_db_table(TABLE table, const char db,
		/* update old existing row */
		if (rights)
		{
		table->file->extra(HA_EXTRA_RETRIEVE_ALL_COLS);
		if ((error=table->file->update_row(table->record[1],table->record[0])))
		goto table_error; /* purecov: deadcode */
		}
		@@ -1953,8 +1962,10 @@ static int replace_column_table(GRANT_TABLE *g_t,
		table->field[4]->store(xx->column.ptr(),xx->column.length(),
		&my_charset_latin1);

		table->file->extra(HA_EXTRA_RETRIEVE_ALL_COLS);
		if (table->file->index_read(table->record[0],(byte*) table->field[0]->ptr,
		0, HA_READ_KEY_EXACT))
		table->key_info[0].key_length,
		HA_READ_KEY_EXACT))
		{
		if (revoke_grant)
		{
		@@ -2022,8 +2033,10 @@ static int replace_column_table(GRANT_TABLE *g_t,

		if (revoke_grant)
		{
		table->file->extra(HA_EXTRA_RETRIEVE_ALL_COLS);
		if (table->file->index_read(table->record[0], (byte*) table->field[0]->ptr,
		key_length, HA_READ_KEY_EXACT))
		table->key_info[0].key_length,
		HA_READ_KEY_EXACT))
		goto end;

		/* Scan through all rows with the same host,db,user and table */
		@@ -2112,9 +2125,10 @@ static int replace_table_table(THD thd, GRANT_TABLE grant_table,
		table->field[2]->store(combo.user.str,combo.user.length, &my_charset_latin1);
		table->field[3]->store(table_name,(uint) strlen(table_name), &my_charset_latin1);
		store_record(table,record[1]); // store at pos 1

		table->file->extra(HA_EXTRA_RETRIEVE_ALL_COLS);
		if (table->file->index_read_idx(table->record[0],0,
		(byte*) table->field[0]->ptr,0,
		(byte*) table->field[0]->ptr,
		table->key_info[0].key_length,
		HA_READ_KEY_EXACT))
		{
		/*
		@@ -3571,9 +3585,12 @@ int mysql_drop_user(THD *thd, List <LEX_USER> &list)
		tables[0].table->field[1]->store(user_name->user.str,(uint)
		user_name->user.length,
		system_charset_info);
		tables[0].table->file->extra(HA_EXTRA_RETRIEVE_ALL_COLS);
		if (!tables[0].table->file->index_read_idx(tables[0].table->record[0],0,
		(byte*) tables[0].table->
		field[0]->ptr,0,
		field[0]->ptr,
		tables[0].table->
		key_info[0].key_length,
		HA_READ_KEY_EXACT))
		{
		int error;