component/mariadb/mroonga-4.01-mariadb-10.0.10.patch

   1 diff --git a/ha_mroonga.cpp b/ha_mroonga.cpp
   2 index 20d251a..2504599 100644
   3 --- a/ha_mroonga.cpp
   4 +++ b/ha_mroonga.cpp
   5 @@ -101,22 +101,38 @@
   6  #define MRN_TEXT_SIZE       (1 << 16) // 64Kbytes
   7  #define MRN_LONG_TEXT_SIZE  (1 << 31) //  2Gbytes
   8
   9 -#if MYSQL_VERSION_ID >= 50500
  10 -#  ifdef DBUG_OFF
  11 -#    ifndef _WIN32
  12 +#ifdef MRN_HAVE_TDC_LOCK_TABLE_SHARE
  13 +#  define mrn_open_mutex(share) &((share)->tdc.LOCK_table_share)
  14 +#  define mrn_open_mutex_lock(share) do {       \
  15 +  TABLE_SHARE *share_ = share;                  \
  16 +  if (share_) {                                 \
  17 +    mysql_mutex_lock(mrn_open_mutex(share_));   \
  18 +  }                                             \
  19 +} while (0)
  20 +#  define mrn_open_mutex_unlock(share) do {     \
  21 +  TABLE_SHARE *share_ = share;                  \
  22 +  if (share_) {                                 \
  23 +    mysql_mutex_unlock(mrn_open_mutex(share_)); \
  24 +  }                                             \
  25 +} while (0)
  26 +#else
  27 +#  if MYSQL_VERSION_ID >= 50500
  28 +#    ifdef DBUG_OFF
  29 +#      ifndef _WIN32
  30  extern mysql_mutex_t LOCK_open;
  31 +#      endif
  32  #    endif
  33 -#  endif
  34  mysql_mutex_t *mrn_LOCK_open;
  35 -#  define mrn_open_mutex_lock() mysql_mutex_lock(mrn_LOCK_open)
  36 -#  define mrn_open_mutex_unlock() mysql_mutex_unlock(mrn_LOCK_open)
  37 -#else
  38 -#  ifndef _WIN32
  39 +#    define mrn_open_mutex_lock(share) mysql_mutex_lock(mrn_LOCK_open)
  40 +#    define mrn_open_mutex_unlock(share) mysql_mutex_unlock(mrn_LOCK_open)
  41 +#  else
  42 +#    ifndef _WIN32
  43  extern pthread_mutex_t LOCK_open;
  44 -#  endif
  45 +#    endif
  46  pthread_mutex_t *mrn_LOCK_open;
  47 -#  define mrn_open_mutex_lock()
  48 -#  define mrn_open_mutex_unlock()
  49 +#    define mrn_open_mutex_lock(share)
  50 +#    define mrn_open_mutex_unlock(share)
  51 +#  endif
  52  #endif
  53
  54  #if MYSQL_VERSION_ID >= 50600
  55 @@ -1275,13 +1291,15 @@ static int mrn_init(void *p)
  56    mrn_table_def_cache = (HASH *)GetProcAddress(current_module,
  57      "?table_def_cache@@3Ust_hash@@A");
  58  #  endif
  59 +#  ifndef MRN_HAVE_TDC_LOCK_TABLE_SHARE
  60    mrn_LOCK_open =
  61 -#  if MYSQL_VERSION_ID >= 50500
  62 +#    if MYSQL_VERSION_ID >= 50500
  63      (mysql_mutex_t *)GetProcAddress(current_module,
  64        "?LOCK_open@@3Ust_mysql_mutex@@A");
  65 -#  else
  66 +#    else
  67      (pthread_mutex_t *)GetProcAddress(current_module,
  68        "?LOCK_open@@3U_RTL_CRITICAL_SECTION@@A");
  69 +#    endif
  70  #  endif
  71  #  ifdef MRN_TABLE_SHARE_HAVE_LOCK_SHARE
  72       mrn_table_share_lock_share =
  73 @@ -1297,7 +1315,9 @@ static int mrn_init(void *p)
  74  #  ifdef MRN_HAVE_TABLE_DEF_CACHE
  75    mrn_table_def_cache = &table_def_cache;
  76  #  endif
  77 +#  ifndef MRN_HAVE_TDC_LOCK_TABLE_SHARE
  78    mrn_LOCK_open = &LOCK_open;
  79 +#  endif
  80  #endif
  81
  82    // init groonga
  83 @@ -3033,10 +3053,10 @@ bool ha_mroonga::storage_create_foreign_key(TABLE *table,
  84                                mapper.mysql_table_name(),
  85                                TL_WRITE);
  86  #endif
  87 -    mrn_open_mutex_lock();
  88 +    mrn_open_mutex_lock(table->s);
  89      tmp_ref_table_share =
  90        mrn_create_tmp_table_share(&table_list, ref_path, &error);
  91 -    mrn_open_mutex_unlock();
  92 +    mrn_open_mutex_unlock(table->s);
  93      if (!tmp_ref_table_share) {
  94        grn_obj_unlink(ctx, grn_table_ref);
  95        error = ER_CANT_CREATE_TABLE;
  96 @@ -3048,9 +3068,9 @@ bool ha_mroonga::storage_create_foreign_key(TABLE *table,
  97      }
  98      uint ref_pkey_nr = tmp_ref_table_share->primary_key;
  99      if (ref_pkey_nr == MAX_KEY) {
 100 -      mrn_open_mutex_lock();
 101 +      mrn_open_mutex_lock(table->s);
 102        mrn_free_tmp_table_share(tmp_ref_table_share);
 103 -      mrn_open_mutex_unlock();
 104 +      mrn_open_mutex_unlock(table->s);
 105        grn_obj_unlink(ctx, grn_table_ref);
 106        error = ER_CANT_CREATE_TABLE;
 107        char err_msg[MRN_BUFFER_SIZE];
 108 @@ -3062,9 +3082,9 @@ bool ha_mroonga::storage_create_foreign_key(TABLE *table,
 109      KEY *ref_key_info = &tmp_ref_table_share->key_info[ref_pkey_nr];
 110      uint ref_key_parts = KEY_N_KEY_PARTS(ref_key_info);
 111      if (ref_key_parts > 1) {
 112 -      mrn_open_mutex_lock();
 113 +      mrn_open_mutex_lock(table->s);
 114        mrn_free_tmp_table_share(tmp_ref_table_share);
 115 -      mrn_open_mutex_unlock();
 116 +      mrn_open_mutex_unlock(table->s);
 117        grn_obj_unlink(ctx, grn_table_ref);
 118        error = ER_CANT_CREATE_TABLE;
 119        char err_msg[MRN_BUFFER_SIZE];
 120 @@ -3076,9 +3096,9 @@ bool ha_mroonga::storage_create_foreign_key(TABLE *table,
 121      }
 122      Field *ref_field = &ref_key_info->key_part->field[0];
 123      if (strcmp(ref_field->field_name, ref_field_name.str)) {
 124 -      mrn_open_mutex_lock();
 125 +      mrn_open_mutex_lock(table->s);
 126        mrn_free_tmp_table_share(tmp_ref_table_share);
 127 -      mrn_open_mutex_unlock();
 128 +      mrn_open_mutex_unlock(table->s);
 129        grn_obj_unlink(ctx, grn_table_ref);
 130        error = ER_CANT_CREATE_TABLE;
 131        char err_msg[MRN_BUFFER_SIZE];
 132 @@ -3088,9 +3108,9 @@ bool ha_mroonga::storage_create_foreign_key(TABLE *table,
 133        my_message(error, err_msg, MYF(0));
 134        DBUG_RETURN(false);
 135      }
 136 -    mrn_open_mutex_lock();
 137 +    mrn_open_mutex_lock(table->s);
 138      mrn_free_tmp_table_share(tmp_ref_table_share);
 139 -    mrn_open_mutex_unlock();
 140 +    mrn_open_mutex_unlock(table->s);
 141      grn_obj_flags col_flags = GRN_OBJ_PERSISTENT;
 142      column = grn_column_create(ctx, table_obj, field->field_name,
 143                                 strlen(field->field_name),
 144 @@ -4210,18 +4230,18 @@ int ha_mroonga::close()
 145      table_list.init_one_table(mapper.db_name(), mapper.mysql_table_name(),
 146                                TL_WRITE);
 147  #endif
 148 -    mrn_open_mutex_lock();
 149 +    mrn_open_mutex_lock(NULL);
 150      tmp_table_share =
 151        mrn_create_tmp_table_share(&table_list, share->table_name, &tmp_error);
 152 -    mrn_open_mutex_unlock();
 153 +    mrn_open_mutex_unlock(NULL);
 154      if (!tmp_table_share) {
 155        error = tmp_error;
 156      } else if ((tmp_error = alter_share_add(share->table_name,
 157                                              tmp_table_share))) {
 158        error = tmp_error;
 159 -      mrn_open_mutex_lock();
 160 +      mrn_open_mutex_lock(NULL);
 161        mrn_free_tmp_table_share(tmp_table_share);
 162 -      mrn_open_mutex_unlock();
 163 +      mrn_open_mutex_unlock(NULL);
 164      }
 165    }
 166    bitmap_free(&multiple_column_key_bitmap);
 167 @@ -4394,9 +4414,9 @@ int ha_mroonga::delete_table(const char *name)
 168      table_list.init_one_table(mapper.db_name(), mapper.mysql_table_name(),
 169                                TL_WRITE);
 170  #endif
 171 -    mrn_open_mutex_lock();
 172 +    mrn_open_mutex_lock(NULL);
 173      tmp_table_share = mrn_create_tmp_table_share(&table_list, name, &error);
 174 -    mrn_open_mutex_unlock();
 175 +    mrn_open_mutex_unlock(NULL);
 176      if (!tmp_table_share) {
 177        DBUG_RETURN(error);
 178      }
 179 @@ -4407,9 +4427,9 @@ int ha_mroonga::delete_table(const char *name)
 180  #endif
 181    if (!(tmp_share = mrn_get_share(name, &tmp_table, &error)))
 182    {
 183 -    mrn_open_mutex_lock();
 184 +    mrn_open_mutex_lock(NULL);
 185      mrn_free_tmp_table_share(tmp_table_share);
 186 -    mrn_open_mutex_unlock();
 187 +    mrn_open_mutex_unlock(NULL);
 188      DBUG_RETURN(error);
 189    }
 190
 191 @@ -4425,9 +4445,9 @@ int ha_mroonga::delete_table(const char *name)
 192      tmp_share->long_term_share = NULL;
 193    }
 194    mrn_free_share(tmp_share);
 195 -  mrn_open_mutex_lock();
 196 +  mrn_open_mutex_lock(NULL);
 197    mrn_free_tmp_table_share(tmp_table_share);
 198 -  mrn_open_mutex_unlock();
 199 +  mrn_open_mutex_unlock(NULL);
 200    if (is_temporary_table_name(name)) {
 201      mrn_drop_db(name);
 202    }
 203 @@ -11885,9 +11905,9 @@ int ha_mroonga::rename_table(const char *from, const char *to)
 204                              from_mapper.mysql_table_name(),
 205                              TL_WRITE);
 206  #endif
 207 -  mrn_open_mutex_lock();
 208 +  mrn_open_mutex_lock(NULL);
 209    tmp_table_share = mrn_create_tmp_table_share(&table_list, from, &error);
 210 -  mrn_open_mutex_unlock();
 211 +  mrn_open_mutex_unlock(NULL);
 212    if (!tmp_table_share) {
 213      DBUG_RETURN(error);
 214    }
 215 @@ -11897,9 +11917,9 @@ int ha_mroonga::rename_table(const char *from, const char *to)
 216  #endif
 217    if (!(tmp_share = mrn_get_share(from, &tmp_table, &error)))
 218    {
 219 -    mrn_open_mutex_lock();
 220 +    mrn_open_mutex_lock(NULL);
 221      mrn_free_tmp_table_share(tmp_table_share);
 222 -    mrn_open_mutex_unlock();
 223 +    mrn_open_mutex_unlock(NULL);
 224      DBUG_RETURN(error);
 225    }
 226
 227 @@ -11925,9 +11945,9 @@ int ha_mroonga::rename_table(const char *from, const char *to)
 228    } else if (error && from_mapper.table_name()[0] == '#') {
 229      alter_share_add(from, tmp_table_share);
 230    } else {
 231 -    mrn_open_mutex_lock();
 232 +    mrn_open_mutex_lock(NULL);
 233      mrn_free_tmp_table_share(tmp_table_share);
 234 -    mrn_open_mutex_unlock();
 235 +    mrn_open_mutex_unlock(NULL);
 236    }
 237    DBUG_RETURN(error);
 238  }
 239 @@ -14482,10 +14502,10 @@ char *ha_mroonga::storage_get_foreign_key_create_info()
 240                                ref_table_buff,
 241                                TL_WRITE);
 242  #endif
 243 -    mrn_open_mutex_lock();
 244 +    mrn_open_mutex_lock(table_share);
 245      tmp_ref_table_share =
 246        mrn_create_tmp_table_share(&table_list, ref_path, &error);
 247 -    mrn_open_mutex_unlock();
 248 +    mrn_open_mutex_unlock(table_share);
 249      if (!tmp_ref_table_share) {
 250        DBUG_RETURN(NULL);
 251      }
 252 @@ -14494,9 +14514,9 @@ char *ha_mroonga::storage_get_foreign_key_create_info()
 253      Field *ref_field = &ref_key_info->key_part->field[0];
 254      append_identifier(ha_thd(), &create_info_str, ref_field->field_name,
 255                        strlen(ref_field->field_name));
 256 -    mrn_open_mutex_lock();
 257 +    mrn_open_mutex_lock(table_share);
 258      mrn_free_tmp_table_share(tmp_ref_table_share);
 259 -    mrn_open_mutex_unlock();
 260 +    mrn_open_mutex_unlock(table_share);
 261      if (create_info_str.reserve(39)) {
 262        DBUG_RETURN(NULL);
 263      }
 264 @@ -14694,10 +14714,10 @@ int ha_mroonga::storage_get_foreign_key_list(THD *thd,
 265                                ref_table_buff,
 266                                TL_WRITE);
 267  #endif
 268 -    mrn_open_mutex_lock();
 269 +    mrn_open_mutex_lock(table_share);
 270      tmp_ref_table_share =
 271        mrn_create_tmp_table_share(&table_list, ref_path, &error);
 272 -    mrn_open_mutex_unlock();
 273 +    mrn_open_mutex_unlock(table_share);
 274      if (!tmp_ref_table_share) {
 275        DBUG_RETURN(error);
 276      }
 277 @@ -14709,9 +14729,9 @@ int ha_mroonga::storage_get_foreign_key_list(THD *thd,
 278                                                     strlen(ref_field->field_name),
 279                                                     TRUE);
 280      f_key_info.referenced_fields.push_back(ref_col_name);
 281 -    mrn_open_mutex_lock();
 282 +    mrn_open_mutex_lock(table_share);
 283      mrn_free_tmp_table_share(tmp_ref_table_share);
 284 -    mrn_open_mutex_unlock();
 285 +    mrn_open_mutex_unlock(table_share);
 286      FOREIGN_KEY_INFO *p_f_key_info =
 287        (FOREIGN_KEY_INFO *) thd_memdup(thd, &f_key_info,
 288                                        sizeof(FOREIGN_KEY_INFO));
 289 diff --git a/ha_mroonga.hpp b/ha_mroonga.hpp
 290 index 579210e..d200bca 100644
 291 --- a/ha_mroonga.hpp
 292 +++ b/ha_mroonga.hpp
 293 @@ -172,6 +172,10 @@ extern "C" {
 294  #  define MRN_HANDLER_START_BULK_INSERT_HAS_FLAGS
 295  #endif
 296
 297 +#if (defined(MRN_MARIADB_P) && MYSQL_VERSION_ID >= 100010)
 298 +#  define MRN_HAVE_TDC_LOCK_TABLE_SHARE
 299 +#endif
 300 +
 301  class ha_mroonga;
 302
 303  /* structs */