Merge lp:~sergei.glushchenko/percona-server/ST-28169-Bug1127008-5.6 into lp:percona-server/5.6

[Sergei Glushchenko]

http://jenkins.percona.com/view/PS%205.6/job/percona-server-5.6-param/42/
Port of fix for bug 1127008 from 5.5 series

[Alexey Kopytov (akopytov)]

Same comments as for 5.5. And I'm not sure we should submit any 5.6 MPs until we fix our 5.6 tree so we can follow the normal merge workflow.

review: Needs Fixing

Unmerged revisions

316. By Sergei Glushchenko on 2013-02-20

Port of fix for bug 1127008 from 5.5 series

=== modified file 'Percona-Server/mysql-test/r/create.result'
--- Percona-Server/mysql-test/r/create.result	2013-01-18 04:53:12 +0000
+++ Percona-Server/mysql-test/r/create.result	2013-02-20 09:38:26 +0000
@@ -2625,3 +2625,31 @@
 ERROR 42000: Identifier name 't01234567890123456789012345678901234567890123456789012345678901234567890123456789' is too long
 CREATE DATABASE t01234567890123456789012345678901234567890123456789012345678901234567890123456789;
 ERROR 42000: Identifier name 't01234567890123456789012345678901234567890123456789012345678901234567890123456789' is too long
+#
+# Checking that CREATE IF NOT EXISTS is not blocked by running SELECT
+#
+create table t1 (a int, b int) engine=myisam;
+create table t2 (a int, b int) engine=myisam;
+insert into t1 values (1,1);
+lock tables t1 read;
+set @@lock_wait_timeout=5;
+create table if not exists t1 (a int, b int);
+Warnings:
+Note	1050	Table 't1' already exists
+create table if not exists t1 (a int, b int) select 2,2;
+Warnings:
+Note	1050	Table 't1' already exists
+create table if not exists t1 like t2;
+Warnings:
+Note	1050	Table 't1' already exists
+create table t1 (a int, b int);
+ERROR 42S01: Table 't1' already exists
+create table t1 (a int, b int) select 2,2;
+ERROR 42S01: Table 't1' already exists
+create table t1 like t2;
+ERROR 42S01: Table 't1' already exists
+select * from t1;
+a	b
+1	1
+unlock tables;
+drop table t1,t2;

=== added file 'Percona-Server/mysql-test/r/create_delayed.result'
--- Percona-Server/mysql-test/r/create_delayed.result	1970-01-01 00:00:00 +0000
+++ Percona-Server/mysql-test/r/create_delayed.result	2013-02-20 09:38:26 +0000
@@ -0,0 +1,3 @@
+drop table if exists t1;
+Starting test
+# All done

=== modified file 'Percona-Server/mysql-test/t/create.test'
--- Percona-Server/mysql-test/t/create.test	2012-08-22 01:40:20 +0000
+++ Percona-Server/mysql-test/t/create.test	2013-02-20 09:38:26 +0000
@@ -2096,3 +2096,28 @@
 CREATE TABLE t01234567890123456789012345678901234567890123456789012345678901234567890123456789(a int);
 --error ER_TOO_LONG_IDENT
 CREATE DATABASE t01234567890123456789012345678901234567890123456789012345678901234567890123456789;
+
+--echo #
+--echo # Checking that CREATE IF NOT EXISTS is not blocked by running SELECT
+--echo #
+
+create table t1 (a int, b int) engine=myisam;
+create table t2 (a int, b int) engine=myisam;
+insert into t1 values (1,1);
+lock tables t1 read;
+connect (user1,localhost,root,,test);
+set @@lock_wait_timeout=5;
+create table if not exists t1 (a int, b int);
+create table if not exists t1 (a int, b int) select 2,2;
+create table if not exists t1 like t2;
+--error ER_TABLE_EXISTS_ERROR
+create table t1 (a int, b int);
+--error ER_TABLE_EXISTS_ERROR
+create table t1 (a int, b int) select 2,2;
+--error ER_TABLE_EXISTS_ERROR
+create table t1 like t2;
+disconnect user1;
+connection default;
+select * from t1;
+unlock tables;
+drop table t1,t2;

=== added file 'Percona-Server/mysql-test/t/create_delayed.test'
--- Percona-Server/mysql-test/t/create_delayed.test	1970-01-01 00:00:00 +0000
+++ Percona-Server/mysql-test/t/create_delayed.test	2013-02-20 09:38:26 +0000
@@ -0,0 +1,34 @@
+#
+# Ensure that INSERT DELAYED works with CREATE TABLE on existing table
+#
+
+-- source include/big_test.inc
+
+--disable_warnings
+drop table if exists t1;
+--enable_warnings
+
+--disable_query_log
+--disable_result_log
+
+--let $run=1000
+
+--echo Starting test
+
+while ($run)
+{
+# --echo # $run attempts left...
+  CREATE TABLE t1 ( f1 INTEGER AUTO_INCREMENT, PRIMARY KEY (f1)) ENGINE=MyISAM;
+  INSERT DELAYED t1 VALUES (4);
+--error ER_TABLE_EXISTS_ERROR
+  CREATE TABLE t1 AS SELECT 1 AS f1;
+
+  REPLACE DELAYED t1 VALUES (5);
+  DROP TABLE t1;
+--dec $run
+}
+
+--enable_query_log
+--enable_result_log
+
+--echo # All done

=== modified file 'Percona-Server/sql/mdl.cc'
--- Percona-Server/sql/mdl.cc	2012-12-04 08:24:59 +0000
+++ Percona-Server/sql/mdl.cc	2013-02-20 09:38:26 +0000
@@ -2200,7 +2200,11 @@
   */
   m_wait.reset_status();
 
-  if (lock->needs_notification(ticket))
+  /*
+    Don't break conflicting locks if timeout is 0 as 0 is used
+    To check if there is any conflicting locks...
+  */
+  if (lock->needs_notification(ticket) && lock_wait_timeout)
     lock->notify_conflicting_locks(this);
 
   mysql_prlock_unlock(&lock->m_rwlock);

=== modified file 'Percona-Server/sql/sql_base.cc'
--- Percona-Server/sql/sql_base.cc	2013-02-12 07:47:19 +0000
+++ Percona-Server/sql/sql_base.cc	2013-02-20 09:38:26 +0000
@@ -2271,10 +2271,11 @@
     Check that table exists in table definition cache, on disk
     or in some storage engine.
 
-    @param       thd     Thread context
-    @param       table   Table list element
-    @param[out]  exists  Out parameter which is set to TRUE if table
-                         exists and to FALSE otherwise.
+    @param       thd        Thread context
+    @param       table      Table list element
+    @param       fast_check Check only if share or .frm file exists 
+    @param[out]  exists     Out parameter which is set to TRUE if table
+                            exists and to FALSE otherwise.
 
     @note This function acquires LOCK_open internally.
 
@@ -2286,7 +2287,8 @@
     @retval  FALSE  No error. 'exists' out parameter set accordingly.
 */
 
-bool check_if_table_exists(THD *thd, TABLE_LIST *table, bool *exists)
+bool check_if_table_exists(THD *thd, TABLE_LIST *table, bool fast_check,
+                           bool *exists)
 {
   char path[FN_REFLEN + 1];
   TABLE_SHARE *share;
@@ -2294,7 +2296,8 @@
 
   *exists= TRUE;
 
-  DBUG_ASSERT(thd->mdl_context.
+  DBUG_ASSERT(fast_check ||
+              thd->mdl_context.
               is_lock_owner(MDL_key::TABLE, table->db,
                             table->table_name, MDL_SHARED));
 
@@ -2311,6 +2314,12 @@
   if (!access(path, F_OK))
     goto end;
 
+  if (fast_check)
+  {
+    *exists= FALSE;
+    goto end;
+  }
+
   /* .FRM file doesn't exist. Check if some engine can provide it. */
   if (ha_check_if_table_exists(thd, table->db, table->table_name, exists))
   {
@@ -2819,7 +2828,7 @@
   {
     bool exists;
 
-    if (check_if_table_exists(thd, table_list, &exists))
+    if (check_if_table_exists(thd, table_list, 0, &exists))
       DBUG_RETURN(TRUE);
 
     if (!exists)
@@ -4688,7 +4697,18 @@
                            open, see open_table() description for details.
 
   @retval FALSE  Success.
-  @retval TRUE   Failure (e.g. connection was killed)
+  @retval TRUE   Failure (e.g. connection was killed) or table existed
+	         for a CREATE TABLE.
+
+  @notes
+  In case of CREATE TABLE we avoid a wait for tables that are in use
+  by first trying to do a meta data lock with timeout == 0.  If we get a
+  timeout we will check if table exists (it should) and retry with
+  normal timeout if it didn't exists.
+  Note that for CREATE TABLE IF EXISTS we only generate a warning
+  but still return TRUE (to abort the calling open_table() function).
+  On must check THD->is_error() if one wants to distinguish between warning
+  and error.
 */
 
 bool
@@ -4700,6 +4720,10 @@
   TABLE_LIST *table;
   MDL_request global_request;
   Hash_set<TABLE_LIST, schema_set_get_key> schema_set;
+  ulong org_lock_wait_timeout= lock_wait_timeout;
+  /* Check if we are using CREATE TABLE ... IF NOT EXISTS */
+  bool create_table;
+  Dummy_error_handler error_handler;
 
   DBUG_ASSERT(!thd->locked_tables_mode);
 
@@ -4726,8 +4750,14 @@
     mdl_requests.push_front(&table->mdl_request);
   }
 
-  if (! (flags & MYSQL_OPEN_SKIP_SCOPED_MDL_LOCK) &&
-      ! mdl_requests.is_empty())
+  if (mdl_requests.is_empty())
+    return FALSE;
+
+  /* Check if CREATE TABLE IF NOT EXISTS was used */
+  create_table= (tables_start && tables_start->open_strategy ==
+                 TABLE_LIST::OPEN_IF_EXISTS);
+
+  if (!(flags & MYSQL_OPEN_SKIP_SCOPED_MDL_LOCK))
   {
     /*
       Scoped locks: Take intention exclusive locks on all involved
@@ -4755,12 +4785,58 @@
     global_request.init(MDL_key::GLOBAL, "", "", MDL_INTENTION_EXCLUSIVE,
                         MDL_STATEMENT);
     mdl_requests.push_front(&global_request);
-  }
-
-  if (thd->mdl_context.acquire_locks(&mdl_requests, lock_wait_timeout))
-    return TRUE;
-
-  return FALSE;
+
+    if (create_table)
+      lock_wait_timeout= 0;                     // Don't wait for timeout
+  }
+
+  for (;;)
+  {
+    bool exists= TRUE;
+    bool res;
+
+    if (create_table)
+      thd->push_internal_handler(&error_handler);  // Avoid warnings & errors
+    res= thd->mdl_context.acquire_locks(&mdl_requests, lock_wait_timeout);
+    if (create_table)
+      thd->pop_internal_handler();
+    if (!res)
+      return FALSE;                             // Got locks
+
+    if (!create_table)
+      return TRUE;                              // Return original error
+
+    /*
+      We come here in the case of lock timeout when executing
+      CREATE TABLE IF NOT EXISTS.
+      Verify that table really exists (it should as we got a lock conflict)
+    */
+    if (check_if_table_exists(thd, tables_start, 1, &exists))
+      return TRUE;                              // Should never happen
+    if (exists)
+    {
+      if (thd->lex->create_info.options & HA_LEX_CREATE_IF_NOT_EXISTS)
+      {
+        push_warning_printf(thd, Sql_condition::WARN_LEVEL_NOTE,
+                            ER_TABLE_EXISTS_ERROR, ER(ER_TABLE_EXISTS_ERROR),
+                            tables_start->table_name);
+      }
+      else
+        my_error(ER_TABLE_EXISTS_ERROR, MYF(0), tables_start->table_name);
+      return TRUE;
+    }
+    /* purecov: begin inspected */
+    /*
+      We got error from acquire_locks but table didn't exists.
+      In theory this should never happen, except maybe in
+      CREATE or DROP DATABASE scenario.
+      We play safe and restart the original acquire_locks with the
+      original timeout
+    */
+    create_table= 0;
+    lock_wait_timeout= org_lock_wait_timeout;
+    /* purecov: end */
+  }
 }
 
 

=== modified file 'Percona-Server/sql/sql_base.h'
--- Percona-Server/sql/sql_base.h	2013-02-12 07:47:19 +0000
+++ Percona-Server/sql/sql_base.h	2013-02-20 09:38:26 +0000
@@ -300,7 +300,8 @@
                                   const char *table_name,
                                   bool no_error);
 void mark_tmp_table_for_reuse(TABLE *table);
-bool check_if_table_exists(THD *thd, TABLE_LIST *table, bool *exists);
+bool check_if_table_exists(THD *thd, TABLE_LIST *table, bool fast_check,
+                           bool *exists);
 
 extern Item **not_found_item;
 extern Field *not_found_field;

=== modified file 'Percona-Server/sql/sql_db.cc'
--- Percona-Server/sql/sql_db.cc	2013-02-12 07:47:19 +0000
+++ Percona-Server/sql/sql_db.cc	2013-02-20 09:38:26 +0000
@@ -958,7 +958,7 @@
       bool exists;
 
       // Only write drop table to the binlog for tables that no longer exist.
-      if (check_if_table_exists(thd, tbl, &exists))
+      if (check_if_table_exists(thd, tbl, 0, &exists))
       {
         error= true;
         goto exit;

=== modified file 'Percona-Server/sql/sql_insert.cc'
--- Percona-Server/sql/sql_insert.cc	2013-01-18 04:53:12 +0000
+++ Percona-Server/sql/sql_insert.cc	2013-02-20 09:38:26 +0000
@@ -2896,8 +2896,12 @@
         set_timespec(abstime, delayed_insert_timeout);
 
         /* Information for pthread_kill */
+        mysql_mutex_unlock(&di->mutex);
+        mysql_mutex_lock(&di->thd.mysys_var->mutex);
         di->thd.mysys_var->current_mutex= &di->mutex;
         di->thd.mysys_var->current_cond= &di->cond;
+        mysql_mutex_unlock(&di->thd.mysys_var->mutex);
+        mysql_mutex_lock(&di->mutex);
         THD_STAGE_INFO(&(di->thd), stage_waiting_for_insert);
 
         DBUG_PRINT("info",("Waiting for someone to insert rows"));

=== modified file 'Percona-Server/sql/sql_parse.cc'
--- Percona-Server/sql/sql_parse.cc	2013-02-12 07:47:19 +0000
+++ Percona-Server/sql/sql_parse.cc	2013-02-20 09:38:26 +0000
@@ -2924,7 +2924,14 @@
         goto end_with_restore_list;
       }
 
-      if (!(res= open_normal_and_derived_tables(thd, all_tables, 0)))
+      res= open_normal_and_derived_tables(thd, all_tables, 0);
+      if (res)
+      {
+        /* Got error or warning. Set res to 1 if error */
+        if (!(res= thd->is_error()))
+          my_ok(thd);                           // CREATE ... IF NOT EXISTS
+      }
+      else
       {
         /* The table already exists */
         if (create_table->table || create_table->view)

=== modified file 'Percona-Server/sql/sql_table.cc'
--- Percona-Server/sql/sql_table.cc	2013-02-12 07:47:19 +0000
+++ Percona-Server/sql/sql_table.cc	2013-02-20 09:38:26 +0000
@@ -4949,7 +4949,8 @@
   */
   if (open_and_lock_tables(thd, thd->lex->query_tables, FALSE, 0))
   {
-    result= TRUE;
+    /* is_error() may be 0 if table existed and we generated a warning */
+    result= thd->is_error();
     goto end;
   }
 
@@ -5199,7 +5200,10 @@
     properly isolated from all concurrent operations which matter.
   */
   if (open_tables(thd, &thd->lex->query_tables, &not_used, 0))
+  {
+    res= thd->is_error();
     goto err;
+  }
   src_table->table->use_all_columns();
 
   DEBUG_SYNC(thd, "create_table_like_after_open");