database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-07-30 16:24:05 +03:00
Code Activity

Manual merge

Browse Source 
include/my_base.h:
  Auto merged
include/my_global.h:
  Auto merged
include/my_sys.h:
  Auto merged
myisam/mi_check.c:
  Auto merged
myisam/mi_extra.c:
  Auto merged
myisam/mi_locking.c:
  Auto merged
myisam/myisamchk.c:
  Auto merged
myisam/myisamdef.h:
  Auto merged
mysql-test/r/key_cache.result:
  Auto merged
mysql-test/t/key_cache.test:
  Auto merged
sql/ha_myisam.cc:
  Auto merged
sql/handler.cc:
  Auto merged
sql/handler.h:
  Auto merged
sql/item_cmpfunc.h:
  Auto merged
sql/mysql_priv.h:
  Auto merged
sql/opt_range.cc:
  Auto merged
sql/set_var.h:
  Auto merged
sql/sql_base.cc:
  Auto merged
sql/sql_parse.cc:
  Auto merged
sql/sql_table.cc:
  Auto merged
sql/table.h:
  Auto merged
This commit is contained in:
unknown
2003-08-26 00:13:22 -07:00
parent 3b799e8fd8 b9a90dffb6
commit f6758b47fb
59 changed files with 2630 additions and 772 deletions
Download Patch File Download Diff File Expand all files Collapse all files

226
sql/set_var.cc
View File

@ -59,6 +59,11 @@
#include "ha_innodb.h"
#endif
ulonglong dflt_key_buff_size;
uint dflt_key_cache_block_size;
uint dflt_key_cache_division_limit;
uint dflt_key_cache_age_threshold;
static HASH system_variable_hash;
const char *bool_type_names[]= { "OFF", "ON", NullS };
TYPELIB bool_typelib=
@ -90,7 +95,7 @@ static void fix_myisam_max_extra_sort_file_size(THD *thd, enum_var_type type);
static void fix_myisam_max_sort_file_size(THD *thd, enum_var_type type);
static void fix_max_binlog_size(THD *thd, enum_var_type type);
static void fix_max_relay_log_size(THD *thd, enum_var_type type);
static KEY_CACHE *create_key_cache(const char *name, uint length);
static KEY_CACHE_VAR *create_key_cache(const char *name, uint length);
void fix_sql_mode_var(THD *thd, enum_var_type type);
static byte *get_error_count(THD *thd);
static byte *get_warning_count(THD *thd);
@ -139,6 +144,11 @@ sys_var_thd_ulong sys_interactive_timeout("interactive_timeout",
sys_var_thd_ulong sys_join_buffer_size("join_buffer_size",
&SV::join_buff_size);
sys_var_key_buffer_size sys_key_buffer_size("key_buffer_size");
sys_var_key_cache_block_size sys_key_cache_block_size("key_cache_block_size");
sys_var_key_cache_division_limit
sys_key_cache_division_limit("key_cache_division_limit");
sys_var_key_cache_age_threshold
sys_key_cache_age_threshold("key_cache_age_threshold");
sys_var_bool_ptr sys_local_infile("local_infile",
&opt_local_infile);
sys_var_thd_bool sys_log_warnings("log_warnings", &SV::log_warnings);
@ -397,6 +407,9 @@ sys_var *sys_variables[]=
&sys_interactive_timeout,
&sys_join_buffer_size,
&sys_key_buffer_size,
&sys_key_cache_block_size,
&sys_key_cache_division_limit,
&sys_key_cache_age_threshold,
&sys_last_insert_id,
&sys_local_infile,
&sys_log_binlog,
@ -556,6 +569,12 @@ struct show_var_st init_vars[]= {
{sys_interactive_timeout.name,(char*) &sys_interactive_timeout, SHOW_SYS},
{sys_join_buffer_size.name, (char*) &sys_join_buffer_size, SHOW_SYS},
{sys_key_buffer_size.name, (char*) &sys_key_buffer_size, SHOW_SYS},
{sys_key_cache_block_size.name, (char*) &sys_key_cache_block_size,
SHOW_SYS},
{sys_key_cache_division_limit.name, (char*) &sys_key_cache_division_limit,
SHOW_SYS},
{sys_key_cache_age_threshold.name, (char*) &sys_key_cache_age_threshold,
SHOW_SYS},
{"language", language, SHOW_CHAR},
{"large_files_support", (char*) &opt_large_files, SHOW_BOOL},
{sys_local_infile.name, (char*) &sys_local_infile, SHOW_SYS},
@ -1475,78 +1494,136 @@ void sys_var_collation_connection::set_default(THD *thd, enum_var_type type)
}
bool sys_var_key_buffer_size::update(THD *thd, set_var *var)
{
ulonglong tmp= var->value->val_int();
NAMED_LIST *list;
LEX_STRING *base_name= &var->base;
static LEX_STRING default_key_cache_base= {(char *) DEFAULT_KEY_CACHE_NAME, 7};
static KEY_CACHE_VAR zero_key_cache= { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
static KEY_CACHE_VAR *get_key_cache(LEX_STRING *cache_name)
{
if (!cache_name || !cache_name->str || !cache_name->length ||
cache_name->str == default_key_cache_base.str ||
(cache_name->length == default_key_cache_base.length &&
!memcmp(cache_name->str, default_key_cache_base.str,
default_key_cache_base.length)))
cache_name= &default_key_cache_base;
return ((KEY_CACHE_VAR*) find_named(&key_caches,
cache_name->str, cache_name->length));
}
byte *sys_var_key_cache_param::value_ptr(THD *thd, enum_var_type type,
LEX_STRING *base)
{
KEY_CACHE_VAR *key_cache= get_key_cache(base);
if (!key_cache)
key_cache= &zero_key_cache;
return (byte*) key_cache + offset ;
}
bool sys_var_key_buffer_size::update(THD *thd, set_var *var
ulonglong tmp= var->value->val_int();
base_name= &default_key_cache_base;
KEY_CACHE_VAR *key_cache= get_key_cache(base_name);
if (!base_name->length)
{
/* We are using SET KEY_BUFFER_SIZE=# */
base_name->str= (char*) "default";
base_name->length= 7;
}
KEY_CACHE *key_cache= (KEY_CACHE*) find_named(&key_caches, base_name->str,
base_name->length, &list);
KEY_CACHE *key_cache= (KEY_CACHE*) find_named(&key_caches, base_name.str,
base_name.length);
if (!key_cache)
{
if (!tmp) // Tried to delete cache
return 0; // Ok, nothing to do
if (!(key_cache= create_key_cache(base_name->str,
base_name->length)))
base_name->length)
return 1;
}
if (!tmp) // Zero size means delete
{
/* Don't delete the default key cache */
if (base_name->length != 7 || memcmp(base_name->str, "default", 7))
if (!key_cache->cache)
return 0;
/* Delete not default key caches */
if (key_cache != &dflt_key_cache_var)
{
/*
QQ: Here we should move tables that is using the found key cache
to the default key cache
Move tables using this key cache to the default key cache
and remove this key cache if no tables are assigned to it
*/
delete list;
my_free((char*) key_cache, MYF(0));
return 0;
return (reassign_keycache_tables(thd, key_cache,
default_key_cache_base.str, 1));
}
return 0;
}
key_cache->size= (ulonglong) getopt_ull_limit_value(tmp, option_limits);
key_cache->buff_size= (ulonglong) getopt_ull_limit_value(tmp, option_limits);
/* QQ: Needs to be updated when we have multiple key caches */
keybuff_size= key_cache->size;
ha_resize_key_cache();
if (!key_cache->cache)
return (bool)(ha_key_cache(key_cache));
else
return (bool)(ha_resize_key_cache(key_cache));
}
bool sys_var_key_cache_block_size::update(THD *thd, set_var *var)
{
ulong tmp= var->value->val_int();
if (!base_name.length)
base_name= &default_key_cache_base;
KEY_CACHE_VAR *key_cache= get_key_cache(base_name);
if (!key_cache && !(key_cache= create_key_cache(base_name->str,
base_name->length)))
return 1;
key_cache->block_size= (ulong) getopt_ull_limit_value(tmp, option_limits);
if (key_cache->cache)
/* Do not build a new key cache here */
return (bool) (ha_resize_key_cache(key_cache));
return 0;
}
static ulonglong zero=0;
byte *sys_var_key_buffer_size::value_ptr(THD *thd, enum_var_type type,
LEX_STRING *base)
bool sys_var_key_cache_division_limit::update(THD *thd, set_var *var)
{
const char *name;
uint length;
KEY_CACHE *key_cache;
NAMED_LIST *not_used;
ulong tmp= var->value->val_int();
if (!base->str)
{
name= "default";
length= 7;
}
else
{
name= base->str;
length= base->length;
}
key_cache= (KEY_CACHE*) find_named(&key_caches, name, length, &not_used);
if (!key_cache)
return (byte*) &zero;
return (byte*) &key_cache->size;
if (!base_name.length)
base_name= &default_key_cache_base;
KEY_CACHE_VAR *key_cache= get_key_cache(base_name);
if (!key_cache && !(key_cache= create_key_cache(base_name->str,
base_name->length)))
return 1;
key_cache->division_limit=
(ulong) getopt_ull_limit_value(tmp, option_limits);
if (key_cache->cache)
/* Do not build a new key cache here */
return (bool) (ha_change_key_cache_param(key_cache));
return 0;
}
bool sys_var_key_age_threshold::update(THD *thd, set_var *var)
{
ulong tmp= var->value->val_int();
if (!base_name.length)
base_name= &default_key_cache_base;
KEY_CACHE_VAR *key_cache= get_key_cache(base_name);
if (!key_cache && !(key_cache= create_key_cache(base_name->str,
base_name->length)))
return 1;
key_cache->division_limit=
(ulong) getopt_ull_limit_value(tmp, option_limits);
if (key_cache->cache)
/* Do not build a new key cache here */
return (bool) (ha_change_key_cache_param(key_cache));
return 0;
}
/*****************************************************************************
@ -2141,29 +2218,41 @@ void delete_elements(I_List<NAMED_LIST> *list, void (*free_element)(gptr))
/* Key cache functions */
static KEY_CACHE *create_key_cache(const char *name, uint length)
static KEY_CACHE_VAR *create_key_cache(const char *name, uint length)
{
KEY_CACHE *key_cache;
KEY_CACHE_VAR *key_cache;
DBUG_PRINT("info",("Creating key cache: %.*s length: %d", length, name,
length));
if ((key_cache= (KEY_CACHE*) my_malloc(sizeof(KEY_CACHE),
MYF(MY_ZEROFILL | MY_WME))))
if (length != default_key_cache_base.length ||
memcmp(name, default_key_cache_base.str, length))
{
if (!new NAMED_LIST(&key_caches, name, length, (gptr) key_cache))
if ((key_cache= (KEY_CACHE_VAR*) my_malloc(sizeof(KEY_CACHE_VAR),
MYF(MY_ZEROFILL | MY_WME))))
{
my_free((char*) key_cache, MYF(0));
key_cache= 0;
if (!new NAMED_LIST(&key_caches, name, length, (gptr) key_cache))
{
my_free((char*) key_cache, MYF(0));
key_cache= 0;
}
}
}
else
{
key_cache= &dflt_key_cache_var;
if (!new NAMED_LIST(&key_caches, name, length, (gptr) key_cache))
key_cache= 0;
}
return key_cache;
}
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)
{
NAMED_LIST *not_used;
KEY_CACHE *key_cache= (KEY_CACHE*) find_named(&key_caches, name,
length, &not_used);
LEX_STRING key_cache_name;
key_cache_name.str= (char *) name;
key_cache_name.length= length;
KEY_CACHE_VAR *key_cache= get_key_cache(&key_cache_name);
if (!key_cache)
key_cache= create_key_cache(name, length);
return key_cache;
@ -2172,7 +2261,22 @@ KEY_CACHE *get_or_create_key_cache(const char *name, uint length)
void free_key_cache(gptr key_cache)
{
my_free(key_cache, MYF(0));
if (key_cache != (gptr) &dflt_key_cache_var)
my_free(key_cache, MYF(0));
}
bool process_key_caches(int (* func) (KEY_CACHE_VAR *))
{
I_List_iterator<NAMED_LIST> it(key_caches);
NAMED_LIST *element;
while ((element= it++))
{
KEY_CACHE_VAR *key_cache= (KEY_CACHE_VAR *) element->data;
if (key_cache != &dflt_key_cache_var)
func(key_cache);
}
return 0;
}