Bug#51851: Server with SBR locks mutex twice on LOAD DATA

into partitioned MyISAM table

Problem was that the ha_data structure was introduced in 5.1
and only used for partitioning first, but with the intention
of be of use for others engines as well, and when used by other
engines it would clash if it also was partitioned.

Solution is to move the partitioning specific data to a separate
structure, with its own mutex (which is used for auto_increment).

Also did rename PARTITION_INFO to PARTITION_STATS since there
already exist a class named partition_info, also cleaned up
some related variables.

1 files changed, 16 insertions, 26 deletions

diff --git a/sql/ha_partition.h b/sql/ha_partition.h
index b3a347612f3..34aeb7d357b 100644
--- a/sql/ha_partition.h
+++ b/sql/ha_partition.h
@@ -26,30 +26,15 @@ enum partition_keywords
   PKW_COLUMNS
 };
 
-/*
-  PARTITION_SHARE is a structure that will be shared amoung all open handlers
-  The partition implements the minimum of what you will probably need.
-*/
-
-#ifdef NOT_USED
-typedef struct st_partition_share
-{
-  char *table_name;
-  uint table_name_length, use_count;
-  mysql_mutex_t mutex;
-  THR_LOCK lock;
-} PARTITION_SHARE;
-#endif
 
 /**
   Partition specific ha_data struct.
-  @todo: move all partition specific data from TABLE_SHARE here.
 */
 typedef struct st_ha_data_partition
 {
-  ulonglong next_auto_inc_val;                 /**< first non reserved value */
   bool auto_inc_initialized;
-  pthread_mutex_t mutex;
+  mysql_mutex_t LOCK_auto_inc;                 /**< protecting auto_inc val */
+  ulonglong next_auto_inc_val;                 /**< first non reserved value */
 } HA_DATA_PARTITION;
 
 #define PARTITION_BYTES_IN_POS 2
@@ -519,7 +504,7 @@ public:
     -------------------------------------------------------------------------
   */
   virtual int info(uint);
-  void get_dynamic_partition_info(PARTITION_INFO *stat_info,
+  void get_dynamic_partition_info(PARTITION_STATS *stat_info,
                                   uint part_id);
   virtual int extra(enum ha_extra_function operation);
   virtual int extra_opt(enum ha_extra_function operation, ulong cachesize);
@@ -938,19 +923,23 @@ private:
   virtual int reset_auto_increment(ulonglong value);
   virtual void lock_auto_increment()
   {
+    HA_DATA_PARTITION *ha_part_data;
     /* lock already taken */
     if (auto_increment_safe_stmt_log_lock)
       return;
-    DBUG_ASSERT(table_share->ha_data && !auto_increment_lock);
+    ha_part_data= (HA_DATA_PARTITION*) table_share->ha_part_data;
+    DBUG_ASSERT(ha_part_data && !auto_increment_lock);
     if(table_share->tmp_table == NO_TMP_TABLE)
     {
       auto_increment_lock= TRUE;
-      mysql_mutex_lock(&table_share->LOCK_ha_data);
+      mysql_mutex_lock(&ha_part_data->LOCK_auto_inc);
     }
   }
   virtual void unlock_auto_increment()
   {
-    DBUG_ASSERT(table_share->ha_data);
+    HA_DATA_PARTITION *ha_part_data= (HA_DATA_PARTITION*)
+                                              table_share->ha_part_data;
+    DBUG_ASSERT(ha_part_data);
     /*
       If auto_increment_safe_stmt_log_lock is true, we have to keep the lock.
       It will be set to false and thus unlocked at the end of the statement by
@@ -958,20 +947,21 @@ private:
     */
     if(auto_increment_lock && !auto_increment_safe_stmt_log_lock)
     {
-      mysql_mutex_unlock(&table_share->LOCK_ha_data);
+      mysql_mutex_unlock(&ha_part_data->LOCK_auto_inc);
       auto_increment_lock= FALSE;
     }
   }
   virtual void set_auto_increment_if_higher(Field *field)
   {
-    HA_DATA_PARTITION *ha_data= (HA_DATA_PARTITION*) table_share->ha_data;
+    HA_DATA_PARTITION *ha_part_data= (HA_DATA_PARTITION*)
+                                              table_share->ha_part_data;
     ulonglong nr= (((Field_num*) field)->unsigned_flag ||
                    field->val_int() > 0) ? field->val_int() : 0;
     lock_auto_increment();
-    DBUG_ASSERT(ha_data->auto_inc_initialized == TRUE);
+    DBUG_ASSERT(ha_part_data->auto_inc_initialized == TRUE);
     /* must check when the mutex is taken */
-    if (nr >= ha_data->next_auto_inc_val)
-      ha_data->next_auto_inc_val= nr + 1;
+    if (nr >= ha_part_data->next_auto_inc_val)
+      ha_part_data->next_auto_inc_val= nr + 1;
     unlock_auto_increment();
   }