bk commit into 5.0 tree (gkodinov:1.2504) BUG#26162

[kgeorge]

Below is the list of changes that have just been committed into a local
5.0 repository of kgeorge. When kgeorge 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://dev.mysql.com/doc/mysql/en/installing-source-tree.html

ChangeSet@stripped, 2007-05-29 10:59:06+03:00, gkodinov@stripped +6 -0
  Bug #26162: Trigger DML ignores low_priority_updates setting
  
  The value of "low-priority-updates" option and the LOW PRIORITY
  prefix was taken into account at parse time.
  This caused triggers (among others) to ignore this flag (if
  supplied for the DML statement).
  Moved reading of the LOW_PRIORITY flag at run time.
  Fixed an incosistency when handling
  SET GLOBAL LOW_PRIORITY_UPDATES : now it is in effect for
  delayed INSERTs.
  Tested by checking the effect of LOW_PRIORITY flag via a 
  trigger.

  include/thr_lock.h@stripped, 2007-05-29 10:59:04+03:00, gkodinov@stripped +5 -0
    Bug #26162: moved reading of the LOW PRIORITY flag at run time

  mysql-test/r/trigger.result@stripped, 2007-05-29 10:59:04+03:00, gkodinov@stripped +24 -0
    Bug #26162: test case

  mysql-test/t/trigger.test@stripped, 2007-05-29 10:59:04+03:00, gkodinov@stripped +55 -0
    Bug #26162: test case

  sql/set_var.cc@stripped, 2007-05-29 10:59:04+03:00, gkodinov@stripped +5 -1
    Bug #26162: fixed the handling of the "low-priority-updates" option

  sql/sql_base.cc@stripped, 2007-05-29 10:59:04+03:00, gkodinov@stripped +7 -0
    Bug #26162: moved reading of the LOW PRIORITY flag at run time

  sql/sql_yacc.yy@stripped, 2007-05-29 10:59:05+03:00, gkodinov@stripped +6 -6
    Bug #26162: moved reading of the LOW PRIORITY flag at run time

# 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:	gkodinov
# Host:	magare.gmz
# Root:	/home/kgeorge/mysql/work/B26162-5.0-opt

--- 1.19/include/thr_lock.h	2006-12-30 01:44:21 +02:00
+++ 1.20/include/thr_lock.h	2007-05-29 10:59:04 +03:00
@@ -54,6 +54,11 @@ enum thr_lock_type { TL_IGNORE=-1,
 		     TL_WRITE_CONCURRENT_INSERT,
 		     /* Write used by INSERT DELAYED.  Allows READ locks */
 		     TL_WRITE_DELAYED,
+                     /* 
+                       parser only! Late bound low_priority flag. 
+                       At open_tables() becomes thd->update_lock_default.
+                     */
+                     TL_WRITE_DEFAULT,
 		     /* WRITE lock that has lower priority than TL_READ */
 		     TL_WRITE_LOW_PRIORITY,
 		     /* Normal WRITE lock */

--- 1.381/sql/sql_base.cc	2007-05-28 01:05:33 +03:00
+++ 1.382/sql/sql_base.cc	2007-05-29 10:59:04 +03:00
@@ -1505,6 +1505,7 @@ TABLE *open_table(THD *thd, TABLE_LIST *
   HASH_SEARCH_STATE state;
   DBUG_ENTER("open_table");
 
+  DBUG_ASSERT (table_list->lock_type != TL_WRITE_DEFAULT);
   /* find a unused table in the open table cache */
   if (refresh)
     *refresh=0;
@@ -2667,6 +2668,12 @@ int open_tables(THD *thd, TABLE_LIST **s
   for (tables= *start; tables ;tables= tables->next_global)
   {
     safe_to_ignore_table= FALSE;                // 'FALSE', as per coding style
+
+    if (tables->lock_type == TL_WRITE_DEFAULT)
+    {
+      tables->lock_type= thd->update_lock_default;
+      DBUG_ASSERT (tables->lock_type >= TL_WRITE_ALLOW_WRITE);
+    }
     /*
       Ignore placeholders for derived tables. After derived tables
       processing, link to created temporary table will be put here.

--- 1.519/sql/sql_yacc.yy	2007-05-15 12:56:05 +03:00
+++ 1.520/sql/sql_yacc.yy	2007-05-29 10:59:05 +03:00
@@ -6561,7 +6561,7 @@ insert_lock_option:
               insert visible only after the table unlocking but everyone can
               read table.
             */
-            $$= (Lex->sphead ? TL_WRITE :TL_WRITE_CONCURRENT_INSERT);
+            $$= (Lex->sphead ? TL_WRITE_DEFAULT : TL_WRITE_CONCURRENT_INSERT);
 #else
             $$= TL_WRITE_CONCURRENT_INSERT;
 #endif
@@ -6739,7 +6739,7 @@ insert_update_elem:
 	  };
 
 opt_low_priority:
-	/* empty */	{ $$= YYTHD->update_lock_default; }
+	/* empty */	{ $$= TL_WRITE_DEFAULT; }
 	| LOW_PRIORITY	{ $$= TL_WRITE_LOW_PRIORITY; };
 
 /* Delete rows from a table */
@@ -6750,7 +6750,7 @@ delete:
 	  LEX *lex= Lex;
 	  lex->sql_command= SQLCOM_DELETE;
 	  mysql_init_select(lex);
-	  lex->lock_option= lex->thd->update_lock_default;
+	  lex->lock_option= TL_WRITE_DEFAULT;
 	  lex->ignore= 0;
 	  lex->select_lex.init_order();
 	}
@@ -7415,7 +7415,7 @@ opt_local:
 	| LOCAL_SYM	{ $$=1;};
 
 load_data_lock:
-	/* empty */	{ $$= YYTHD->update_lock_default; }
+	/* empty */	{ $$= TL_WRITE_DEFAULT; }
 	| CONCURRENT
           {
 #ifdef HAVE_QUERY_CACHE
@@ -7423,7 +7423,7 @@ load_data_lock:
               Ignore this option in SP to avoid problem with query cache
             */
             if (Lex->sphead != 0)
-              $$= YYTHD->update_lock_default;
+              $$= TL_WRITE_DEFAULT;
             else
 #endif
               $$= TL_WRITE_CONCURRENT_INSERT;
@@ -8736,7 +8736,7 @@ table_lock:
 
 lock_option:
 	READ_SYM	{ $$=TL_READ_NO_INSERT; }
-	| WRITE_SYM     { $$=YYTHD->update_lock_default; }
+	| WRITE_SYM     { $$=TL_WRITE_DEFAULT; }
 	| LOW_PRIORITY WRITE_SYM { $$=TL_WRITE_LOW_PRIORITY; }
 	| READ_SYM LOCAL_SYM { $$= TL_READ; }
         ;

--- 1.58/mysql-test/r/trigger.result	2007-05-11 19:33:10 +03:00
+++ 1.59/mysql-test/r/trigger.result	2007-05-29 10:59:04 +03:00
@@ -1449,4 +1449,28 @@ isave
 1
 2
 drop table t1, t2, t3;
+CREATE TABLE t1 (id INTEGER);
+CREATE TABLE t2 (id INTEGER);
+INSERT INTO t2 VALUES (1),(2);
+CREATE TRIGGER t1_test AFTER INSERT ON t1 FOR EACH ROW 
+INSERT INTO t2 VALUES (new.id);
+SELECT GET_LOCK('B26162',20);
+GET_LOCK('B26162',20)
+1
+SELECT 'rl_acquirer', GET_LOCK('B26162',5), id FROM t2 WHERE id = 1;
+SET SESSION LOW_PRIORITY_UPDATES=1;
+SET GLOBAL LOW_PRIORITY_UPDATES=1;
+INSERT INTO t1 VALUES (5);
+SELECT 'rl_contender', id FROM t2 WHERE id > 1;
+SELECT RELEASE_LOCK('B26162');
+RELEASE_LOCK('B26162')
+0
+rl_acquirer	GET_LOCK('B26162',5)	id
+rl_acquirer	0	1
+rl_contender	id
+rl_contender	2
+DROP TRIGGER t1_test;
+DROP TABLE t1,t2;
+SET SESSION LOW_PRIORITY_UPDATES=DEFAULT;
+SET GLOBAL LOW_PRIORITY_UPDATES=DEFAULT;
 End of 5.0 tests

--- 1.65/mysql-test/t/trigger.test	2007-05-11 19:33:10 +03:00
+++ 1.66/mysql-test/t/trigger.test	2007-05-29 10:59:04 +03:00
@@ -1763,4 +1763,59 @@ select * from t1;
 select * from t3;
 drop table t1, t2, t3;
 
+#
+# Bug #26162: Trigger DML ignores low_priority_updates setting
+#
+CREATE TABLE t1 (id INTEGER);
+CREATE TABLE t2 (id INTEGER);
+
+INSERT INTO t2 VALUES (1),(2);
+
+# trigger that produces the high priority insert, but should be low, adding
+# LOW_PRIORITY fixes this
+CREATE TRIGGER t1_test AFTER INSERT ON t1 FOR EACH ROW 
+  INSERT INTO t2 VALUES (new.id);
+
+CONNECT (rl_acquirer,  localhost, root,,);
+CONNECT (wl_acquirer,  localhost, root,,);
+CONNECT (rl_contender, localhost, root,,);
+
+SELECT GET_LOCK('B26162',20);
+
+CONNECTION rl_acquirer;
+--send
+SELECT 'rl_acquirer', GET_LOCK('B26162',5), id FROM t2 WHERE id = 1;
+
+CONNECTION wl_acquirer;
+SET SESSION LOW_PRIORITY_UPDATES=1;
+SET GLOBAL LOW_PRIORITY_UPDATES=1;
+--send
+INSERT INTO t1 VALUES (5);
+
+CONNECTION rl_contender;
+# must not "see" the row inserted by the INSERT (as it must run before the
+# INSERT)
+--send
+SELECT 'rl_contender', id FROM t2 WHERE id > 1;
+
+CONNECTION default;
+SELECT RELEASE_LOCK('B26162');
+
+CONNECTION wl_acquirer;
+--reap
+CONNECTION rl_acquirer;
+--reap
+CONNECTION rl_contender;
+--reap
+
+CONNECTION default;
+DISCONNECT rl_acquirer;
+DISCONNECT wl_acquirer;
+DISCONNECT rl_contender;
+
+DROP TRIGGER t1_test;
+DROP TABLE t1,t2;
+SET SESSION LOW_PRIORITY_UPDATES=DEFAULT;
+SET GLOBAL LOW_PRIORITY_UPDATES=DEFAULT;
+
 --echo End of 5.0 tests

--- 1.185/sql/set_var.cc	2007-05-15 12:56:04 +03:00
+++ 1.186/sql/set_var.cc	2007-05-29 10:59:04 +03:00
@@ -1226,7 +1226,11 @@ static void sys_default_ftb_syntax(THD *
 
 static void fix_low_priority_updates(THD *thd, enum_var_type type)
 {
-  if (type != OPT_GLOBAL)
+  if (type == OPT_GLOBAL)
+    thr_upgraded_concurrent_insert_lock= 
+      (global_system_variables.low_priority_updates ?
+       TL_WRITE_LOW_PRIORITY : TL_WRITE);
+  else
     thd->update_lock_default= (thd->variables.low_priority_updates ?
 			       TL_WRITE_LOW_PRIORITY : TL_WRITE);
 }