From: Date: September 13 2004 6:05pm
Subject: bk commit into 4.0 tree (heikki:1.2016)
List-Archive: http://lists.mysql.com/internals/16865
Message-Id: <200409131605.i8DG5m4U027899@hundin.mysql.fi>

Below is the list of changes that have just been committed into a local
4.0 repository of heikki. When heikki does a push these changes will
be propagated to the main repository and, within 24 hours after the
push, to the public repository.
For information on how to access the public repository
see http://www.mysql.com/doc/I/n/Installing_source_tree.html

ChangeSet
  1.2016 04/09/13 19:05:39 heikki@stripped +2 -0
  row0mysql.h:
    Improve the comment on stored_select_lock_type
  ha_innodb.cc:
    Let InnoDB remember select_lock_type inside LOCK TABLES, also over plain consistent read SELECTs; fix Bug #5538 : assertion failure when using mysqldump with the -l option; in MERGING this patch to 4.1, there may be PROBLEMS; that is because previous patch was never merged to 4.1; Heikki Tuuri has to polish the code in 4.1 after this patch has been merged.

  innobase/include/row0mysql.h
    1.21 04/09/13 19:01:34 heikki@stripped +5 -3
    Improve the comment on stored_select_lock_type

  sql/ha_innodb.cc
    1.220 04/09/13 19:00:47 heikki@stripped +38 -27
    Let InnoDB remember select_lock_type inside LOCK TABLES, also over plain consistent read SELECTs; fix Bug #5538 : assertion failure when using mysqldump with the -l option; in MERGING this patch to 4.1, there may be PROBLEMS; that is because previous patch was never merged to 4.1; Heikki Tuuri has to polish the code in 4.1 after this patch has been merged.

# This is a BitKeeper patch.  What follows are the unified diffs for the
# set of deltas contained in the patch.  The rest of the patch, the part
# that BitKeeper cares about, is below these diffs.
# User:	heikki
# Host:	hundin.mysql.fi
# Root:	/home/heikki/mysql-4.0

--- 1.20/innobase/include/row0mysql.h	Mon Jul 12 16:47:19 2004
+++ 1.21/innobase/include/row0mysql.h	Mon Sep 13 19:01:34 2004
@@ -508,9 +508,11 @@
 	dtuple_t*	clust_ref;	/* prebuilt dtuple used in
 					sel/upd/del */
 	ulint		select_lock_type;/* LOCK_NONE, LOCK_S, or LOCK_X */
-	ulint		stored_select_lock_type;/* inside LOCK TABLES, either
-					LOCK_S or LOCK_X depending on the lock
-					type */
+	ulint		stored_select_lock_type;/* this field is used to
+					remember the original select_lock_type
+					that was decided in ha_innodb.cc,
+					::store_lock(), ::external_lock(),
+					etc. */
 	ulint		mysql_row_len;	/* length in bytes of a row in the
 					MySQL format */
 	ulint		n_rows_fetched;	/* number of rows fetched after

--- 1.219/sql/ha_innodb.cc	Wed Sep  1 16:41:00 2004
+++ 1.220/sql/ha_innodb.cc	Mon Sep 13 19:00:47 2004
@@ -767,6 +767,7 @@
         if the trx isolation level would have been specified as SERIALIZABLE */
 
         prebuilt->select_lock_type = LOCK_NONE;
+        prebuilt->stored_select_lock_type = LOCK_NONE;
 
         /* Always fetch all columns in the index record */
 
@@ -4562,40 +4563,40 @@
 	  
 	        prebuilt->select_lock_type = LOCK_X;
 	} else {
-		/* When we first come here after LOCK TABLES,
-		select_lock_type is set to LOCK_S or LOCK_X. Store the value
-		in case we run also consistent reads and need to restore the
-		value later. */
+		if (trx->isolation_level != TRX_ISO_SERIALIZABLE
+		    && thd->lex.sql_command == SQLCOM_SELECT
+		    && thd->lex.lock_option == TL_READ) {
+	
+			/* For other than temporary tables, we obtain
+			no lock for consistent read (plain SELECT). */
 
-		if (prebuilt->select_lock_type != LOCK_NONE) {
-			prebuilt->stored_select_lock_type =
-					prebuilt->select_lock_type;
+			prebuilt->select_lock_type = LOCK_NONE;
+		} else {
+			/* Not a consistent read: restore the
+			select_lock_type value. The value of
+			stored_select_lock_type was decided in:
+			1) ::store_lock(),
+			2) ::external_lock(), and
+			3) ::init_table_handle_for_HANDLER(). */
+
+			prebuilt->select_lock_type =
+				prebuilt->stored_select_lock_type;
 		}
 
 		if (prebuilt->stored_select_lock_type != LOCK_S
 		    && prebuilt->stored_select_lock_type != LOCK_X) {
 			fprintf(stderr,
-"InnoDB: Error: select_lock_type is %lu inside ::start_stmt()!\n",
+"InnoDB: Error: stored_select_lock_type is %lu inside ::start_stmt()!\n",
 			prebuilt->stored_select_lock_type);
 
-			ut_error;
-		}
+			/* Set the value to LOCK_X: this is just fault
+			tolerance, we do not know what the correct value
+			should be! */
 
-		if (thd->lex.sql_command == SQLCOM_SELECT
-					&& thd->lex.lock_option == TL_READ) {
-	
-			/* For other than temporary tables, we obtain
-			no lock for consistent read (plain SELECT) */
-
-			prebuilt->select_lock_type = LOCK_NONE;
-		} else {
-			/* Not a consistent read: restore the
-			select_lock_type value */
-			prebuilt->select_lock_type =
-				prebuilt->stored_select_lock_type;
+			prebuilt->select_lock_type = LOCK_X;
 		}
 	}
-	
+
 	/* Set the MySQL flag to mark that there is an active transaction */
 	thd->transaction.all.innodb_active_trans = 1;
 
@@ -4656,6 +4657,7 @@
 		/* If this is a SELECT, then it is in UPDATE TABLE ...
 		or SELECT ... FOR UPDATE */
 		prebuilt->select_lock_type = LOCK_X;
+		prebuilt->stored_select_lock_type = LOCK_X;
 	}
 
 	if (lock_type != F_UNLCK) {
@@ -4910,14 +4912,22 @@
 {
 	row_prebuilt_t* prebuilt	= (row_prebuilt_t*) innobase_prebuilt;
 
-	if (lock_type == TL_READ_WITH_SHARED_LOCKS ||
+	if ((lock_type == TL_READ && thd->in_lock_tables) ||
+	    (lock_type == TL_READ_HIGH_PRIORITY && thd->in_lock_tables) ||
+	    lock_type == TL_READ_WITH_SHARED_LOCKS ||
 	    lock_type == TL_READ_NO_INSERT) {
-		/* This is a SELECT ... IN SHARE MODE, or
-		we are doing a complex SQL statement like
+		/* The OR cases above are in this order:
+		1) MySQL is doing LOCK TABLES ... READ LOCAL, or
+		2) (we do not know when TL_READ_HIGH_PRIORITY is used), or
+		3) this is a SELECT ... IN SHARE MODE, or
+		4) we are doing a complex SQL statement like
 		INSERT INTO ... SELECT ... and the logical logging (MySQL
-		binlog) requires the use of a locking read */
+		binlog) requires the use of a locking read, or
+		MySQL is doing LOCK TABLES ... READ. */
 
 		prebuilt->select_lock_type = LOCK_S;
+		prebuilt->stored_select_lock_type = LOCK_S;
+
 	} else if (lock_type != TL_IGNORE) {
 
 	        /* In ha_berkeley.cc there is a comment that MySQL
@@ -4928,6 +4938,7 @@
 		here even if this would be SELECT ... FOR UPDATE */
 
 		prebuilt->select_lock_type = LOCK_NONE;
+		prebuilt->stored_select_lock_type = LOCK_NONE;
 	}
 
 	if (lock_type != TL_IGNORE && lock.type == TL_UNLOCK) {