Commit 80d5488f authored by unknown's avatar unknown
Browse files

Merge jlindstrom@bk-internal.mysql.com:/home/bk/mysql-5.0 

into hundin.mysql.fi:/home/jan/mysql-5.0


sql/ha_innodb.cc:
  Auto merged
parents 843f38fc 6dd87671

client/mysqldump.c

+1 −1
Original line number Diff line number Diff line
@@ -1936,7 +1936,7 @@ static int init_dumping(char *database) 
        MYSQL_ROW row;

        MYSQL_RES *dbinfo;



        sprintf(qbuf,"SHOW CREATE DATABASE WITH IF NOT EXISTS %s",

        sprintf(qbuf,"SHOW CREATE DATABASE IF NOT EXISTS %s",

		qdatabase);



        if (mysql_query_with_error_report(sock, &dbinfo, qbuf))

innobase/include/lock0lock.h

+24 −5
Original line number Diff line number Diff line
@@ -463,13 +463,32 @@ lock_rec_hash( 
	ulint	space,	/* in: space */

	ulint	page_no);/* in: page number */

/*************************************************************************

Gets the table covered by an IX table lock. */

Gets the source table of an ALTER TABLE transaction.  The table must be

covered by an IX or IS table lock. */



dict_table_t*

lock_get_ix_table(

/*==============*/

			/* out: the table covered by the lock */

	lock_t*	lock);	/* in: table lock */

lock_get_src_table(

/*===============*/

				/* out: the source table of transaction,

				if it is covered by an IX or IS table lock;

				dest if there is no source table, and

				NULL if the transaction is locking more than

				two tables or an inconsistency is found */

	trx_t*		trx,	/* in: transaction */

	dict_table_t*	dest,	/* in: destination of ALTER TABLE */

	ulint*		mode);	/* out: lock mode of the source table */

/*************************************************************************

Determine if the given table is exclusively "owned" by the given

transaction, i.e., transaction holds LOCK_IX and possibly LOCK_AUTO_INC

on the table. */



ibool

lock_is_table_exclusive(

/*=================*/

				/* out: TRUE if table is only locked by trx,

				with LOCK_IX, and possibly LOCK_AUTO_INC */

	dict_table_t*	table,	/* in: table */

	trx_t*		trx);	/* in: transaction */

/*************************************************************************

Checks that a transaction id is sensible, i.e., not in the future. */

innobase/include/row0mysql.h

+10 −2
Original line number Diff line number Diff line
@@ -177,10 +177,12 @@ row_lock_table_for_mysql( 
					/* out: error code or DB_SUCCESS */

	row_prebuilt_t*	prebuilt,	/* in: prebuilt struct in the MySQL

					table handle */

	dict_table_t*	table);		/* in: table to LOCK_IX, or NULL

	dict_table_t*	table,		/* in: table to lock, or NULL

					if prebuilt->table should be

					locked as LOCK_TABLE_EXP |

					prebuilt->select_lock_type */

	ulint		mode);		/* in: lock mode of table */

					   

/*************************************************************************

Does an insert for MySQL. */
@@ -547,7 +549,10 @@ struct row_prebuilt_struct { 
					format */

	ulint		hint_need_to_fetch_extra_cols;

					/* normally this is set to 0; if this

					is set to ROW_RETRIEVE_PRIMARY_KEY,

					is set to ROW_RETRIEVE_PRIMARY_KEY

					(that value is obsolete starting from

					5.0.2, because we always fetch the

					primary key cols),

					then we should at least retrieve all

					columns in the primary key; if this

					is set to ROW_RETRIEVE_ALL_COLS, then
@@ -620,6 +625,9 @@ struct row_prebuilt_struct { 


/* Values for hint_need_to_fetch_extra_cols */

#define ROW_RETRIEVE_PRIMARY_KEY	1

					/* value 1 is obsolete starting from

					5.0.2, because we always fetch the

					primary key cols */

#define ROW_RETRIEVE_ALL_COLS		2

innobase/lock/lock0lock.c

+137 −27
Original line number Diff line number Diff line
@@ -365,6 +365,21 @@ lock_deadlock_recursive( 
	ulint*	cost);		/* in/out: number of calculation steps thus

				far: if this exceeds LOCK_MAX_N_STEPS_...

				we return TRUE */



/*************************************************************************

Gets the type of a lock. */

UNIV_INLINE

ulint

lock_get_type(

/*==========*/

			/* out: LOCK_TABLE or LOCK_REC */

	lock_t*	lock)	/* in: lock */

{

	ut_ad(lock);



	return(lock->type_mode & LOCK_TYPE_MASK);

}



/*************************************************************************

Gets the nth bit of a record lock. */

UNIV_INLINE
@@ -395,19 +410,6 @@ lock_rec_get_nth_bit( 
	return(ut_bit_get_nth(b, bit_index));

}	



/*************************************************************************

Gets the table covered by an IX table lock. */



dict_table_t*

lock_get_ix_table(

/*==============*/

			/* out: the table covered by the lock */

	lock_t*	lock)	/* in: table lock */

{

	ut_a(lock->type_mode == (LOCK_TABLE | LOCK_IX));

	return(lock->un_member.tab_lock.table);

}



/*************************************************************************/



#define lock_mutex_enter_kernel()	mutex_enter(&kernel_mutex)
@@ -581,20 +583,6 @@ lock_get_mode( 
	return(lock->type_mode & LOCK_MODE_MASK);

}



/*************************************************************************

Gets the type of a lock. */

UNIV_INLINE

ulint

lock_get_type(

/*==========*/

			/* out: LOCK_TABLE or LOCK_REC */

	lock_t*	lock)	/* in: lock */

{

	ut_ad(lock);



	return(lock->type_mode & LOCK_TYPE_MASK);

}



/*************************************************************************

Gets the wait flag of a lock. */

UNIV_INLINE
@@ -614,6 +602,128 @@ lock_get_wait( 
	return(FALSE);

}



/*************************************************************************

Gets the source table of an ALTER TABLE transaction.  The table must be

covered by an IX or IS table lock. */



dict_table_t*

lock_get_src_table(

/*===============*/

				/* out: the source table of transaction,

				if it is covered by an IX or IS table lock;

				dest if there is no source table, and

				NULL if the transaction is locking more than

				two tables or an inconsistency is found */

	trx_t*		trx,	/* in: transaction */

	dict_table_t*	dest,	/* in: destination of ALTER TABLE */

	ulint*		mode)	/* out: lock mode of the source table */

{

	dict_table_t*	src;

	lock_t*		lock;



	src = NULL;

	*mode = LOCK_NONE;



	for (lock = UT_LIST_GET_FIRST(trx->trx_locks);

	     lock;

	     lock = UT_LIST_GET_NEXT(trx_locks, lock)) {

		lock_table_t*	tab_lock;

		ulint		lock_mode;

		if (!(lock_get_type(lock) & LOCK_TABLE)) {

			/* We are only interested in table locks. */

			continue;

		}

		tab_lock = &lock->un_member.tab_lock;

		if (dest == tab_lock->table) {

			/* We are not interested in the destination table. */

			continue;

		} else if (!src) {

			/* This presumably is the source table. */

			src = tab_lock->table;

			if (UT_LIST_GET_LEN(src->locks) != 1 ||

			    UT_LIST_GET_FIRST(src->locks) != lock) {

				/* We only support the case when

				there is only one lock on this table. */

				return(NULL);

			}

		} else if (src != tab_lock->table) {

			/* The transaction is locking more than

			two tables (src and dest): abort */

			return(NULL);

		}



		/* Check that the source table is locked by

		LOCK_IX or LOCK_IS. */

		lock_mode = lock_get_mode(lock);

		switch (lock_mode) {

		case LOCK_IX:

		case LOCK_IS:

			if (*mode != LOCK_NONE && *mode != lock_mode) {

				/* There are multiple locks on src. */

				return(NULL);

			}

			*mode = lock_mode;

			break;

		}

	}



	if (!src) {

		/* No source table lock found: flag the situation to caller */

		src = dest;

	}



	return(src);

}



/*************************************************************************

Determine if the given table is exclusively "owned" by the given

transaction, i.e., transaction holds LOCK_IX and possibly LOCK_AUTO_INC

on the table. */



ibool

lock_is_table_exclusive(

/*====================*/

				/* out: TRUE if table is only locked by trx,

				with LOCK_IX, and possibly LOCK_AUTO_INC */

	dict_table_t*	table,	/* in: table */

	trx_t*		trx)	/* in: transaction */

{

	lock_t*	lock;

	bool	ok	= FALSE;



	ut_ad(table && trx);



	for (lock = UT_LIST_GET_FIRST(table->locks);

	     lock;

	     lock = UT_LIST_GET_NEXT(locks, &lock->un_member.tab_lock)) {

		if (lock->trx != trx) {

			/* A lock on the table is held

			by some other transaction. */

			return(FALSE);

		}



		if (!(lock_get_type(lock) & LOCK_TABLE)) {

			/* We are interested in table locks only. */

			continue;

		}



		switch (lock_get_mode(lock)) {

		case LOCK_IX:

			ok = TRUE;

			break;

		case LOCK_AUTO_INC:

			/* It is allowed for trx to hold an

			auto_increment lock. */

			break;

		default:

			/* Other table locks than LOCK_IX are not allowed. */

			return(FALSE);

		}

	}



	return(ok);

}



/*************************************************************************

Sets the wait flag of a lock and the back pointer in trx to lock. */

UNIV_INLINE

innobase/row/row0mysql.c

+3 −2
Original line number Diff line number Diff line
@@ -782,10 +782,11 @@ row_lock_table_for_mysql( 
					/* out: error code or DB_SUCCESS */

	row_prebuilt_t*	prebuilt,	/* in: prebuilt struct in the MySQL

					table handle */

	dict_table_t*	table)		/* in: table to LOCK_IX, or NULL

	dict_table_t*	table,		/* in: table to lock, or NULL

					if prebuilt->table should be

					locked as LOCK_TABLE_EXP |

					prebuilt->select_lock_type */

	ulint		mode)		/* in: lock mode of table */

{

	trx_t*		trx 		= prebuilt->trx;

	que_thr_t*	thr;
@@ -819,7 +820,7 @@ row_lock_table_for_mysql( 
	trx_start_if_not_started(trx);



	if (table) {

		err = lock_table(0, table, LOCK_IX, thr);

		err = lock_table(0, table, mode, thr);

	} else {

		err = lock_table(LOCK_TABLE_EXP, prebuilt->table,

			prebuilt->select_lock_type, thr);