1 files changed, 167 insertions, 189 deletions

diff --git a/storage/mroonga/ha_mroonga.cpp b/storage/mroonga/ha_mroonga.cpp
index a176ccf3..d5f150de 100644
--- a/storage/mroonga/ha_mroonga.cpp
+++ b/storage/mroonga/ha_mroonga.cpp
@@ -4351,9 +4351,9 @@ int ha_mroonga::wrapper_open(const char *name, int mode, uint open_options)
             // TODO: implemented by "reindex" instead of "remove and recreate".
             // Because "remove and recreate" invalidates opened indexes by
             // other threads.
-            error = wrapper_disable_indexes_mroonga(HA_KEY_SWITCH_ALL);
+            error = wrapper_disable_indexes_mroonga(key_map(table->s->keys), false);
             if (!error) {
-              error = wrapper_enable_indexes_mroonga(HA_KEY_SWITCH_ALL);
+              error = wrapper_enable_indexes_mroonga(key_map(table->s->keys), false);
             }
           }
         }
@@ -13639,197 +13639,184 @@ int ha_mroonga::generic_disable_index(int i, KEY *key_info)
   DBUG_RETURN(error);
 }
 
-int ha_mroonga::wrapper_disable_indexes_mroonga(uint mode)
+int ha_mroonga::wrapper_disable_indexes_mroonga(key_map map, bool persist)
 {
   int error = 0;
   MRN_DBUG_ENTER_METHOD();
-  if (mode == HA_KEY_SWITCH_NONUNIQ_SAVE || mode == HA_KEY_SWITCH_ALL) {
-    uint i;
-    for (i = 0; i < table_share->keys; i++) {
-      if (i == table->s->primary_key) {
-        continue;
-      }
-      if (share->wrap_key_nr[i] < MAX_KEY) {
-        continue;
-      }
-      if (!grn_index_tables[i]) {
-        DBUG_PRINT("info", ("mroonga: keys are disabled already %u", i));
-        DBUG_RETURN(0);
-      }
+  uint i;
+  for (i = 0; i < table_share->keys; i++) {
+    if (i == table->s->primary_key) {
+      continue;
+    }
+    if (share->wrap_key_nr[i] < MAX_KEY) {
+      continue;
+    }
+    if (!grn_index_tables[i]) {
+      DBUG_PRINT("info", ("mroonga: keys are disabled already %u", i));
+      DBUG_RETURN(0);
+    }
+  }
+  KEY *key_info = table_share->key_info;
+  for (i = 0; i < table_share->keys; i++) {
+    if (!(key_info[i].flags & HA_FULLTEXT) &&
+        !mrn_is_geo_key(&key_info[i])) {
+      continue;
     }
-    KEY *key_info = table_share->key_info;
-    for (i = 0; i < table_share->keys; i++) {
-      if (!(key_info[i].flags & HA_FULLTEXT) &&
-          !mrn_is_geo_key(&key_info[i])) {
-        continue;
-      }
 
-      int sub_error = generic_disable_index(i, key_info);
-      if (error != 0 && sub_error != 0) {
-        error = sub_error;
-      }
+    int sub_error = generic_disable_index(i, key_info);
+    if (error != 0 && sub_error != 0) {
+      error = sub_error;
     }
-  } else {
-    error = HA_ERR_WRONG_COMMAND;
   }
   DBUG_RETURN(error);
 }
 
-int ha_mroonga::wrapper_disable_indexes(uint mode)
+int ha_mroonga::wrapper_disable_indexes(key_map map, bool persist)
 {
   int error = 0;
   MRN_DBUG_ENTER_METHOD();
   MRN_SET_WRAP_SHARE_KEY(share, table->s);
   MRN_SET_WRAP_TABLE_KEY(this, table);
-  error = wrap_handler->ha_disable_indexes(mode);
+  error = wrap_handler->ha_disable_indexes(map, persist);
   MRN_SET_BASE_SHARE_KEY(share, table->s);
   MRN_SET_BASE_TABLE_KEY(this, table);
   if (error == HA_ERR_WRONG_COMMAND) {
     error = 0;
   }
   if (!error) {
-    error = wrapper_disable_indexes_mroonga(mode);
+    error = wrapper_disable_indexes_mroonga(map, persist);
   }
   DBUG_RETURN(error);
 }
 
-int ha_mroonga::storage_disable_indexes(uint mode)
+int ha_mroonga::storage_disable_indexes(key_map map, bool persist)
 {
   int error = 0;
   MRN_DBUG_ENTER_METHOD();
-  if (mode == HA_KEY_SWITCH_NONUNIQ_SAVE || mode == HA_KEY_SWITCH_ALL) {
-    uint i;
-    for (i = 0; i < table_share->keys; i++) {
-      if (i == table->s->primary_key) {
-        continue;
-      }
-      if (!grn_index_tables[i]) {
-        DBUG_PRINT("info", ("mroonga: keys are disabled already %u", i));
-        DBUG_RETURN(0);
-      }
+  uint i;
+  for (i = 0; i < table_share->keys; i++) {
+    if (i == table->s->primary_key) {
+      continue;
+    }
+    if (!grn_index_tables[i]) {
+      DBUG_PRINT("info", ("mroonga: keys are disabled already %u", i));
+      DBUG_RETURN(0);
+    }
+  }
+  KEY *key_info = table_share->key_info;
+  for (i = 0; i < table_share->keys; i++) {
+    if (i == table->s->primary_key) {
+      continue;
+    }
+    if (map.is_set(i)) {
+      continue;
     }
-    KEY *key_info = table_share->key_info;
-    for (i = 0; i < table_share->keys; i++) {
-      if (i == table->s->primary_key) {
-        continue;
-      }
-      if (mode == HA_KEY_SWITCH_NONUNIQ_SAVE &&
-          (key_info[i].flags & HA_NOSAME)) {
-        continue;
-      }
 
-      int sub_error = generic_disable_index(i, key_info);
-      if (error != 0 && sub_error != 0) {
-        error = sub_error;
-      }
+    int sub_error = generic_disable_index(i, key_info);
+    if (error != 0 && sub_error != 0) {
+      error = sub_error;
     }
-  } else {
-    DBUG_RETURN(HA_ERR_WRONG_COMMAND);
   }
   DBUG_RETURN(error);
 }
 
-int ha_mroonga::disable_indexes(uint mode)
+int ha_mroonga::disable_indexes(key_map map, bool persist)
 {
   int error = 0;
   MRN_DBUG_ENTER_METHOD();
   if (share->wrapper_mode)
   {
-    error = wrapper_disable_indexes(mode);
+    error = wrapper_disable_indexes(map, persist);
   } else {
-    error = storage_disable_indexes(mode);
+    error = storage_disable_indexes(map, persist);
   }
   DBUG_RETURN(error);
 }
 
-int ha_mroonga::wrapper_enable_indexes_mroonga(uint mode)
+int ha_mroonga::wrapper_enable_indexes_mroonga(key_map map, bool persist)
 {
   int error = 0;
   MRN_DBUG_ENTER_METHOD();
-  if (mode == HA_KEY_SWITCH_NONUNIQ_SAVE || mode == HA_KEY_SWITCH_ALL) {
-    uint i, j;
-    for (i = 0; i < table_share->keys; i++) {
-      if (i == table->s->primary_key) {
-        continue;
-      }
-      if (share->wrap_key_nr[i] < MAX_KEY) {
-        continue;
-      }
-      if (!grn_index_columns[i]) {
-        break;
-      }
+  uint i, j;
+  for (i = 0; i < table_share->keys; i++) {
+    if (i == table->s->primary_key) {
+      continue;
     }
-    if (i == table_share->keys) {
-      DBUG_PRINT("info", ("mroonga: keys are enabled already"));
-      DBUG_RETURN(0);
+    if (share->wrap_key_nr[i] < MAX_KEY) {
+      continue;
+    }
+    if (!grn_index_columns[i]) {
+      break;
+    }
+  }
+  if (i == table_share->keys) {
+    DBUG_PRINT("info", ("mroonga: keys are enabled already"));
+    DBUG_RETURN(0);
+  }
+  KEY *p_key_info = &table->key_info[table_share->primary_key];
+  KEY *key_info = table_share->key_info;
+  uint n_keys = table_share->keys;
+  MRN_ALLOCATE_VARIABLE_LENGTH_ARRAYS(grn_obj *, index_tables, n_keys);
+  MRN_ALLOCATE_VARIABLE_LENGTH_ARRAYS(grn_obj *, index_columns, n_keys);
+  bitmap_clear_all(table->read_set);
+  mrn_set_bitmap_by_key(table->read_set, p_key_info);
+  mrn::PathMapper mapper(share->table_name);
+  for (i = 0, j = 0; i < n_keys; i++) {
+    if (!(key_info[i].flags & HA_FULLTEXT) &&
+      !mrn_is_geo_key(&key_info[i])) {
+      j++;
+      continue;
     }
-    KEY *p_key_info = &table->key_info[table_share->primary_key];
-    KEY *key_info = table_share->key_info;
-    uint n_keys = table_share->keys;
-    MRN_ALLOCATE_VARIABLE_LENGTH_ARRAYS(grn_obj *, index_tables, n_keys);
-    MRN_ALLOCATE_VARIABLE_LENGTH_ARRAYS(grn_obj *, index_columns, n_keys);
-    bitmap_clear_all(table->read_set);
-    mrn_set_bitmap_by_key(table->read_set, p_key_info);
-    mrn::PathMapper mapper(share->table_name);
-    for (i = 0, j = 0; i < n_keys; i++) {
-      if (!(key_info[i].flags & HA_FULLTEXT) &&
-        !mrn_is_geo_key(&key_info[i])) {
-        j++;
-        continue;
-      }
 
-      if ((error = mrn_add_index_param(share, &key_info[i], i)))
-      {
+    if ((error = mrn_add_index_param(share, &key_info[i], i)))
+    {
+      break;
+    }
+    index_tables[i] = NULL;
+    index_columns[i] = NULL;
+    if (!grn_index_columns[i]) {
+      if (
+        (key_info[i].flags & HA_FULLTEXT) &&
+        (error = wrapper_create_index_fulltext(mapper.table_name(),
+                                               i, &key_info[i],
+                                               index_tables, index_columns,
+                                               share))
+      ) {
+        break;
+      } else if (
+        mrn_is_geo_key(&key_info[i]) &&
+        (error = wrapper_create_index_geo(mapper.table_name(),
+                                          i, &key_info[i],
+                                          index_tables, index_columns,
+                                          share))
+      ) {
         break;
       }
-      index_tables[i] = NULL;
-      index_columns[i] = NULL;
-      if (!grn_index_columns[i]) {
-        if (
-          (key_info[i].flags & HA_FULLTEXT) &&
-          (error = wrapper_create_index_fulltext(mapper.table_name(),
-                                                 i, &key_info[i],
-                                                 index_tables, index_columns,
-                                                 share))
-        ) {
-          break;
-        } else if (
-          mrn_is_geo_key(&key_info[i]) &&
-          (error = wrapper_create_index_geo(mapper.table_name(),
-                                            i, &key_info[i],
-                                            index_tables, index_columns,
-                                            share))
-        ) {
-          break;
-        }
-        grn_index_columns[i] = index_columns[i];
-      }
-      mrn_set_bitmap_by_key(table->read_set, &key_info[i]);
+      grn_index_columns[i] = index_columns[i];
     }
-    if (!error && i > j)
-    {
-      error = wrapper_fill_indexes(ha_thd(), table->key_info, index_columns,
-                                   n_keys);
-    }
-    bitmap_set_all(table->read_set);
-    MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_tables);
-    MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_columns);
-  } else {
-    error = HA_ERR_WRONG_COMMAND;
+    mrn_set_bitmap_by_key(table->read_set, &key_info[i]);
   }
+  if (!error && i > j)
+  {
+    error = wrapper_fill_indexes(ha_thd(), table->key_info, index_columns,
+                                 n_keys);
+  }
+  bitmap_set_all(table->read_set);
+  MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_tables);
+  MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_columns);
   DBUG_RETURN(error);
 }
 
-int ha_mroonga::wrapper_enable_indexes(uint mode)
+int ha_mroonga::wrapper_enable_indexes(key_map map, bool persist)
 {
   int error = 0;
   MRN_DBUG_ENTER_METHOD();
 
-  int mroonga_error = wrapper_enable_indexes_mroonga(mode);
+  int mroonga_error = wrapper_enable_indexes_mroonga(map, persist);
 
   MRN_SET_WRAP_SHARE_KEY(share, table->s);
   MRN_SET_WRAP_TABLE_KEY(this, table);
-  error = wrap_handler->ha_enable_indexes(mode);
+  error = wrap_handler->ha_enable_indexes(map, persist);
   MRN_SET_BASE_SHARE_KEY(share, table->s);
   MRN_SET_BASE_TABLE_KEY(this, table);
   if (error == HA_ERR_WRONG_COMMAND) {
@@ -13838,95 +13825,86 @@ int ha_mroonga::wrapper_enable_indexes(uint mode)
   DBUG_RETURN(error);
 }
 
-int ha_mroonga::storage_enable_indexes(uint mode)
+int ha_mroonga::storage_enable_indexes(key_map map, bool persist)
 {
   int error = 0;
   uint n_keys = table_share->keys;
   MRN_ALLOCATE_VARIABLE_LENGTH_ARRAYS(grn_obj *, index_tables, n_keys);
   MRN_ALLOCATE_VARIABLE_LENGTH_ARRAYS(grn_obj *, index_columns, n_keys);
   bool have_multiple_column_index = false;
-  bool skip_unique_key = (mode == HA_KEY_SWITCH_NONUNIQ_SAVE);
   MRN_DBUG_ENTER_METHOD();
-  if (mode == HA_KEY_SWITCH_NONUNIQ_SAVE || mode == HA_KEY_SWITCH_ALL) {
-    uint i;
-    for (i = 0; i < table_share->keys; i++) {
-      if (i == table->s->primary_key) {
-        continue;
-      }
-      if (!grn_index_columns[i]) {
-        break;
-      }
+  uint i;
+  for (i = 0; i < n_keys; i++) {
+    if (i == table->s->primary_key) {
+      continue;
     }
-    if (i == table_share->keys) {
-      DBUG_PRINT("info", ("mroonga: keys are enabled already"));
-      MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_tables);
-      MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_columns);
-      DBUG_RETURN(0);
+    if (!grn_index_columns[i]) {
+      break;
+    }
+  }
+  if (i == n_keys) {
+    DBUG_PRINT("info", ("mroonga: keys are enabled already"));
+    MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_tables);
+    MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_columns);
+    DBUG_RETURN(0);
+  }
+  KEY *key_info = table->key_info;
+  bitmap_clear_all(table->read_set);
+  mrn::PathMapper mapper(share->table_name);
+  for (; i < n_keys; i++) {
+    if (!map.is_set(i)) {
+      continue;
     }
-    KEY *key_info = table->key_info;
-    bitmap_clear_all(table->read_set);
-    mrn::PathMapper mapper(share->table_name);
-    for (i = 0; i < n_keys; i++) {
-      if (i == table->s->primary_key) {
-        continue;
-      }
-      if (skip_unique_key && (key_info[i].flags & HA_NOSAME)) {
-        continue;
-      }
 
-      if ((error = mrn_add_index_param(share, &key_info[i], i)))
+    if ((error = mrn_add_index_param(share, &key_info[i], i)))
+    {
+      break;
+    }
+    index_tables[i] = NULL;
+    if (!grn_index_columns[i]) {
+      if ((error = storage_create_index(table, mapper.table_name(), grn_table,
+                                        share, &key_info[i], index_tables,
+                                        index_columns, i)))
       {
         break;
       }
-      index_tables[i] = NULL;
-      if (!grn_index_columns[i]) {
-        if ((error = storage_create_index(table, mapper.table_name(), grn_table,
-                                          share, &key_info[i], index_tables,
-                                          index_columns, i)))
-        {
-          break;
-        }
-        if (
-          KEY_N_KEY_PARTS(&(key_info[i])) != 1 &&
-          !(key_info[i].flags & HA_FULLTEXT)
-        ) {
-          mrn_set_bitmap_by_key(table->read_set, &key_info[i]);
-          have_multiple_column_index = true;
-        }
-        grn_index_tables[i] = index_tables[i];
-        grn_index_columns[i] = index_columns[i];
-      } else {
-        index_columns[i] = NULL;
+      if (
+        KEY_N_KEY_PARTS(&(key_info[i])) != 1 &&
+        !(key_info[i].flags & HA_FULLTEXT)
+      ) {
+        mrn_set_bitmap_by_key(table->read_set, &key_info[i]);
+        have_multiple_column_index = true;
       }
+      grn_index_tables[i] = index_tables[i];
+      grn_index_columns[i] = index_columns[i];
+    } else {
+      index_columns[i] = NULL;
     }
-    if (!error && have_multiple_column_index)
-    {
-      error = storage_add_index_multiple_columns(key_info, n_keys,
-                                                 index_tables,
-                                                 index_columns,
-                                                 skip_unique_key);
-    }
-    bitmap_set_all(table->read_set);
-  } else {
-    MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_tables);
-    MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_columns);
-    DBUG_RETURN(HA_ERR_WRONG_COMMAND);
   }
+  if (!error && have_multiple_column_index)
+  {
+    bool skip_unique_key= !table->s->keys_in_use.is_clear_all();
+    error = storage_add_index_multiple_columns(key_info, n_keys,
+                                               index_tables,
+                                               index_columns,
+                                               skip_unique_key);
+  }
+  bitmap_set_all(table->read_set);
   MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_tables);
   MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_columns);
   DBUG_RETURN(error);
 }
 
-int ha_mroonga::enable_indexes(uint mode)
+int ha_mroonga::enable_indexes(key_map map, bool persist)
 {
   int error = 0;
   MRN_DBUG_ENTER_METHOD();
   share->disable_keys = false;
   if (share->wrapper_mode)
   {
-    error = wrapper_enable_indexes(mode);
+    error = wrapper_enable_indexes(map, persist);
   } else {
-    error = storage_enable_indexes(mode);
+    error = storage_enable_indexes(map, persist);
   }
   DBUG_RETURN(error);
 }