Manual merge after improving concurrency for key cache reassignment

5 files changed, 144 insertions, 23 deletions

diff --git a/sql/handler.cc b/sql/handler.cc
index e14e326792d..1d12171cbd0 100644
--- a/sql/handler.cc
+++ b/sql/handler.cc
@@ -739,6 +739,11 @@ int handler::analyze(THD* thd, HA_CHECK_OPT* check_opt)
   return HA_ADMIN_NOT_IMPLEMENTED;
 }
 
+int handler::assign_to_keycache(THD* thd, HA_CHECK_OPT* check_opt)
+{
+  return HA_ADMIN_NOT_IMPLEMENTED;
+}
+
 int handler::preload_keys(THD* thd, HA_CHECK_OPT* check_opt)
 {
   return HA_ADMIN_NOT_IMPLEMENTED;
@@ -1105,27 +1110,61 @@ int ha_create_table(const char *name, HA_CREATE_INFO *create_info,
 
 	/* Use key cacheing on all databases */
 
-void ha_key_cache(void)
+int ha_key_cache(KEY_CACHE_VAR *key_cache)
 {
-  /*
-    The following mutex is not really needed as long as keybuff_size is
-    treated as a long value, but we use the mutex here to guard for future
-    changes.
-  */
-  pthread_mutex_lock(&LOCK_global_system_variables);
-  long tmp= (long) keybuff_size;
-  pthread_mutex_unlock(&LOCK_global_system_variables);
-  if (tmp)
-    (void) init_key_cache(tmp);
+  if (!key_cache->cache)
+  {
+    /*
+      The following mutex is not really needed as long as keybuff_size is
+      treated as a long value, but we use the mutex here to guard for future
+      changes.
+    */
+    pthread_mutex_lock(&LOCK_global_system_variables);
+    if (!key_cache->block_size)
+      key_cache->block_size= dflt_key_cache_block_size;
+    if (!key_cache->buff_size)
+      key_cache->buff_size= dflt_key_buff_size;
+    long tmp_buff_size= (long) key_cache->buff_size;
+    long tmp_block_size= (long) key_cache->block_size;
+    pthread_mutex_unlock(&LOCK_global_system_variables);
+    return !init_key_cache(&key_cache->cache,
+			   tmp_block_size,
+			   tmp_buff_size,
+                           key_cache);
+  }
+  return 0;
 }
 
 
-void ha_resize_key_cache(void)
+  if (key_cache->cache)
+  {
+    pthread_mutex_lock(&LOCK_global_system_variables);
+    long tmp_buff_size= (long) key_cache->buff_size;
+    long tmp_block_size= (long) key_cache->block_size;
+    pthread_mutex_unlock(&LOCK_global_system_variables);
+    return !resize_key_cache(&key_cache->cache, tmp_block_size,
+                             tmp_buff_size);
+  }
+  return 0;
+}
+
+int ha_change_key_cache_param(KEY_CACHE_VAR *key_cache)
+{
+  if (key_cache->cache)
+  {
+    change_key_cache_param(key_cache->cache);
+  }
+  return 0;
+}
+
+int ha_end_key_cache(KEY_CACHE_VAR *key_cache)
 {
-  pthread_mutex_lock(&LOCK_global_system_variables);
-  long tmp= (long) keybuff_size;
-  pthread_mutex_unlock(&LOCK_global_system_variables);
-  (void) resize_key_cache(tmp);
+  if (key_cache->cache)
+  {
+    end_key_cache(&key_cache->cache, 1);
+    return key_cache->cache ? 1 : 0;
+  }
+  return 0;
 }
 
 
diff --git a/sql/handler.h b/sql/handler.h
index b74e06c6edf..1fcc0da24f8 100644
--- a/sql/handler.h
+++ b/sql/handler.h
@@ -307,6 +307,7 @@ public:
   virtual bool check_and_repair(THD *thd) {return 1;}
   virtual int optimize(THD* thd,HA_CHECK_OPT* check_opt);
   virtual int analyze(THD* thd, HA_CHECK_OPT* check_opt);
+  virtual int assign_to_keycache(THD* thd, HA_CHECK_OPT* check_opt);
   virtual int preload_keys(THD* thd, HA_CHECK_OPT* check_opt);
   virtual int backup(THD* thd, HA_CHECK_OPT* check_opt);
   /*
@@ -389,8 +390,10 @@ int ha_create_table(const char *name, HA_CREATE_INFO *create_info,
 		    bool update_create_info);
 int ha_delete_table(enum db_type db_type, const char *path);
 void ha_drop_database(char* path);
-void ha_key_cache(void);
-void ha_resize_key_cache(void);
+int ha_key_cache(KEY_CACHE_VAR *key_cache);
+int ha_resize_key_cache(KEY_CACHE_VAR *key_cache);
+int ha_change_key_cache_param(KEY_CACHE_VAR *key_cache);
+int ha_end_key_cache(KEY_CACHE_VAR *key_cache);
 int ha_start_stmt(THD *thd);
 int ha_report_binlog_offset_and_commit(THD *thd, char *log_file_name,
 				       my_off_t end_offset);
diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h
index 06cee8018f8..4254d01f903 100644
--- a/sql/mysql_priv.h
+++ b/sql/mysql_priv.h
@@ -396,6 +396,10 @@ bool check_stack_overrun(THD *thd,char *dummy);
 void table_cache_init(void);
 void table_cache_free(void);
 uint cached_tables(void);
+void assign_cache_init(void);
+void assign_cache_free(void);
+void reassign_key_cache(KEY_CACHE_ASMT *key_cache_asmt,
+                        KEY_CACHE_VAR *new_key_cache);
 void kill_mysql(void);
 void close_connection(THD *thd, uint errcode, bool lock);
 bool reload_acl_and_cache(THD *thd, ulong options, TABLE_LIST *tables, 
@@ -425,7 +429,10 @@ int mysql_analyze_table(THD* thd, TABLE_LIST* table_list,
 			HA_CHECK_OPT* check_opt);
 int mysql_optimize_table(THD* thd, TABLE_LIST* table_list,
 			 HA_CHECK_OPT* check_opt);
+int mysql_assign_to_keycache(THD* thd, TABLE_LIST* table_list);
 int mysql_preload_keys(THD* thd, TABLE_LIST* table_list);
+int reassign_keycache_tables(THD* thd, KEY_CACHE_VAR* src_cache, 
+                             char *dest_name, bool remove_fl);
 
 bool check_simple_select();
 
@@ -797,6 +804,7 @@ extern pthread_mutex_t LOCK_mysql_create_db,LOCK_Acl,LOCK_open,
        LOCK_delayed_status, LOCK_delayed_create, LOCK_crypt, LOCK_timezone,
        LOCK_slave_list, LOCK_active_mi, LOCK_manager,
        LOCK_global_system_variables, LOCK_user_conn;
+       LOCK_global_system_variables, LOCK_assign;
 extern rw_lock_t	LOCK_grant;
 extern pthread_cond_t COND_refresh, COND_thread_count, COND_manager;
 extern pthread_attr_t connection_attrib;
diff --git a/sql/opt_range.cc b/sql/opt_range.cc
index 5b1e2c98001..7376c2e24bb 100644
--- a/sql/opt_range.cc
+++ b/sql/opt_range.cc
@@ -890,6 +890,7 @@ static SEL_TREE *
 get_mm_parts(PARAM *param, Field *field, Item_func::Functype type, 
 	     Item *value, Item_result cmp_type)
 {
+  bool ne_func= FALSE;
   DBUG_ENTER("get_mm_parts");
   if (field->table != param->table)
     DBUG_RETURN(0);
@@ -927,6 +928,14 @@ get_mm_parts(PARAM *param, Field *field, Item_func::Functype type,
       tree->keys[key_part->key]=sel_add(tree->keys[key_part->key],sel_arg);
     }
   }
+
+  if (ne_func)
+  {
+    SEL_TREE *tree2= get_mm_parts(param, field, Item_func::GT_FUNC,
+                                  value, cmp_type);
+    if (tree2)
+      tree= tree=tree_or(param,tree,tree2);
+  }
   DBUG_RETURN(tree);
 }
 
diff --git a/sql/set_var.h b/sql/set_var.h
index 812bd6c9420..76db478c50d 100644
--- a/sql/set_var.h
+++ b/sql/set_var.h
@@ -30,6 +30,11 @@ class set_var;
 typedef struct system_variables SV;
 extern TYPELIB bool_typelib, delay_key_write_typelib, sql_mode_typelib;
 
+extern ulonglong dflt_key_buff_size;
+extern uint dflt_key_cache_block_size;
+extern uint dflt_key_cache_division_limit;
+extern uint dflt_key_cache_age_threshold;
+
 enum enum_var_type
 {
   OPT_DEFAULT, OPT_SESSION, OPT_GLOBAL
@@ -541,15 +546,71 @@ public:
   byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
 };
 
-class sys_var_key_buffer_size :public sys_var
+class sys_var_key_cache_param :public sys_var
 {
+protected:
+  uint offset;
 public:
-  sys_var_key_buffer_size(const char *name_arg)
+  sys_var_key_cache_param(const char *name_arg)
     :sys_var(name_arg)
-  {}
+  {
+    offset= 0;
+  }
+  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
+};
+
+class sys_var_key_buffer_size :public sys_var_key_cache_param
+{
+public:
+  sys_var_key_buffer_size(const char *name_arg)
+    :sys_var_key_cache_param(name_arg)
+  {
+    offset= offsetof(KEY_CACHE_VAR, buff_size);
+  }
   bool update(THD *thd, set_var *var);
   SHOW_TYPE type() { return SHOW_LONGLONG; }
-  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING *base);
+  bool check_default(enum_var_type type) { return 1; }
+  bool is_struct() { return 1; }
+};
+
+class sys_var_key_cache_block_size :public sys_var_key_cache_param
+{
+public:
+  sys_var_key_cache_block_size(const char *name_arg)
+    :sys_var_key_cache_param(name_arg)
+  {
+    offset= offsetof(KEY_CACHE_VAR, block_size);
+  }
+  bool update(THD *thd, set_var *var);
+  SHOW_TYPE type() { return SHOW_LONG; }
+  bool check_default(enum_var_type type) { return 1; }
+  bool is_struct() { return 1; }
+};
+
+class sys_var_key_cache_division_limit :public sys_var_key_cache_param
+{
+public:
+  sys_var_key_cache_division_limit(const char *name_arg)
+    :sys_var_key_cache_param(name_arg)
+  {
+    offset= offsetof(KEY_CACHE_VAR, division_limit);
+  }
+  bool update(THD *thd, set_var *var);
+  SHOW_TYPE type() { return SHOW_LONG; }
+  bool check_default(enum_var_type type) { return 1; }
+  bool is_struct() { return 1; }
+};
+
+class sys_var_key_cache_age_threshold :public sys_var_key_cache_param
+{
+public:
+  sys_var_key_cache_age_threshold(const char *name_arg)
+    :sys_var_key_cache_param(name_arg)
+  {
+    offset= offsetof(KEY_CACHE_VAR, age_threshold);
+  }
+  bool update(THD *thd, set_var *var);
+  SHOW_TYPE type() { return SHOW_LONG; }
   bool check_default(enum_var_type type) { return 1; }
   bool is_struct() { return 1; }
 };
@@ -734,5 +795,6 @@ gptr find_named(I_List<NAMED_LIST> *list, const char *name, uint length,
 void delete_elements(I_List<NAMED_LIST> *list, void (*free_element)(gptr));
 
 /* key_cache functions */
-KEY_CACHE *get_or_create_key_cache(const char *name, uint length);
+KEY_CACHE_VAR *get_or_create_key_cache(const char *name, uint length);
 void free_key_cache(gptr key_cache);
+bool process_key_caches(int (* func) (KEY_CACHE_VAR *));