42 #include <drizzled/option.h>
43 #include <drizzled/error.h>
44 #include <drizzled/gettext.h>
45 #include <drizzled/data_home.h>
46 #include <drizzled/set_var.h>
47 #include <drizzled/session.h>
48 #include <drizzled/session/times.h>
49 #include <drizzled/sql_base.h>
50 #include <drizzled/lock.h>
51 #include <drizzled/item/uint.h>
52 #include <drizzled/item/null.h>
53 #include <drizzled/item/float.h>
54 #include <drizzled/item/string.h>
55 #include <drizzled/plugin.h>
56 #include <drizzled/version.h>
57 #include <drizzled/internal/m_string.h>
58 #include <drizzled/pthread_globals.h>
59 #include <drizzled/charset.h>
60 #include <drizzled/transaction_services.h>
61 #include <drizzled/constrained_value.h>
63 #include <drizzled/typelib.h>
64 #include <drizzled/plugin/storage_engine.h>
65 #include <drizzled/system_variables.h>
66 #include <drizzled/catalog/instance.h>
79 extern bool timed_mutexes;
82 extern plugin::StorageEngine *myisam_engine;
83 extern bool timed_mutexes;
85 extern struct option my_long_options[];
86 extern const charset_info_st *character_set_filesystem;
87 extern size_t my_thread_stack_size;
89 typedef map<string, sys_var *> SystemVariableMap;
90 static SystemVariableMap system_variable_map;
91 extern char *opt_drizzle_tmpdir;
93 extern TYPELIB tx_isolation_typelib;
97 static size_t revno= DRIZZLE_VC_REVNO;
98 static size_t release_id= DRIZZLE_RELEASE_ID;
101 const char *bool_type_names[]= {
"OFF",
"ON", NULL };
102 TYPELIB bool_typelib=
104 array_elements(bool_type_names)-1,
"", bool_type_names, NULL
107 static bool set_option_bit(Session*, set_var*);
108 static bool set_option_autocommit(Session*, set_var*);
109 static int check_pseudo_thread_id(Session*, set_var*);
111 static void fix_tx_isolation(Session*, sql_var_t);
112 static int check_completion_type(Session*, set_var*);
114 static void fix_session_mem_root(Session*, sql_var_t);
115 void throw_bounds_warning(Session*,
bool fixed,
bool unsignd,
const std::string &name, int64_t);
116 static unsigned char *get_error_count(Session*);
117 static unsigned char *get_warning_count(Session*);
129 static sys_var_session_uint64_t
130 sys_auto_increment_increment(
"auto_increment_increment", &drizzle_system_variables::auto_increment_increment);
131 static sys_var_session_uint64_t
132 sys_auto_increment_offset(
"auto_increment_offset", &drizzle_system_variables::auto_increment_offset);
134 static sys_var_fs_path sys_basedir(
"basedir", basedir);
135 static sys_var_fs_path sys_pid_file(
"pid_file", pid_file);
136 static sys_var_fs_path sys_plugin_dir(
"plugin_dir", plugin_dir);
138 static sys_var_size_t_ptr sys_thread_stack_size(
"thread_stack", &my_thread_stack_size);
139 static sys_var_constrained_value_readonly<uint32_t> sys_back_log(
"back_log", back_log);
141 static sys_var_session_uint64_t sys_bulk_insert_buff_size(
"bulk_insert_buffer_size", &drizzle_system_variables::bulk_insert_buff_size);
142 static sys_var_session_uint32_t sys_completion_type(
"completion_type", &drizzle_system_variables::completion_type, check_completion_type);
143 static sys_var_collation_sv
144 sys_collation_server(
"collation_server", &drizzle_system_variables::collation_server, &default_charset_info);
145 static sys_var_fs_path sys_datadir(
"datadir", getDataHome());
147 static sys_var_session_uint64_t sys_join_buffer_size(
"join_buffer_size", &drizzle_system_variables::join_buff_size);
148 static sys_var_session_uint32_t sys_max_allowed_packet(
"max_allowed_packet", &drizzle_system_variables::max_allowed_packet);
149 static sys_var_session_uint64_t sys_max_error_count(
"max_error_count", &drizzle_system_variables::max_error_count);
150 static sys_var_session_uint64_t sys_max_heap_table_size(
"max_heap_table_size", &drizzle_system_variables::max_heap_table_size);
151 static sys_var_session_uint64_t sys_pseudo_thread_id(
"pseudo_thread_id", &drizzle_system_variables::pseudo_thread_id, 0, check_pseudo_thread_id);
152 static sys_var_session_ha_rows sys_max_join_size(
"max_join_size", &drizzle_system_variables::max_join_size, fix_max_join_size);
153 static sys_var_session_uint64_t sys_max_seeks_for_key(
"max_seeks_for_key", &drizzle_system_variables::max_seeks_for_key);
154 static sys_var_session_uint64_t sys_max_length_for_sort_data(
"max_length_for_sort_data", &drizzle_system_variables::max_length_for_sort_data);
155 static sys_var_session_size_t sys_max_sort_length(
"max_sort_length", &drizzle_system_variables::max_sort_length);
156 static sys_var_uint64_t_ptr sys_max_write_lock_count(
"max_write_lock_count", &max_write_lock_count);
157 static sys_var_session_uint64_t sys_min_examined_row_limit(
"min_examined_row_limit", &drizzle_system_variables::min_examined_row_limit);
159 static sys_var_session_bool sys_optimizer_prune_level(
"optimizer_prune_level", &drizzle_system_variables::optimizer_prune_level);
160 static sys_var_session_uint32_t sys_optimizer_search_depth(
"optimizer_search_depth", &drizzle_system_variables::optimizer_search_depth);
162 static sys_var_session_uint64_t sys_preload_buff_size(
"preload_buffer_size", &drizzle_system_variables::preload_buff_size);
163 static sys_var_session_uint32_t sys_read_buff_size(
"read_buffer_size", &drizzle_system_variables::read_buff_size);
164 static sys_var_session_uint32_t sys_read_rnd_buff_size(
"read_rnd_buffer_size", &drizzle_system_variables::read_rnd_buff_size);
165 static sys_var_session_uint32_t sys_div_precincrement(
"div_precision_increment", &drizzle_system_variables::div_precincrement);
167 static sys_var_session_size_t sys_range_alloc_block_size(
"range_alloc_block_size", &drizzle_system_variables::range_alloc_block_size);
169 static sys_var_session_bool sys_replicate_query(
"replicate_query", &drizzle_system_variables::replicate_query);
171 static sys_var_session_uint32_t sys_query_alloc_block_size(
"query_alloc_block_size", &drizzle_system_variables::query_alloc_block_size, NULL, fix_session_mem_root);
172 static sys_var_session_uint32_t sys_query_prealloc_size(
"query_prealloc_size", &drizzle_system_variables::query_prealloc_size, NULL, fix_session_mem_root);
173 static sys_var_readonly sys_tmpdir(
"tmpdir", OPT_GLOBAL, SHOW_CHAR, get_tmpdir);
175 static sys_var_fs_path sys_secure_file_priv(
"secure_file_priv", secure_file_priv);
176 static sys_var_const_str_ptr sys_scheduler(
"scheduler", (
char**)&opt_scheduler);
178 static sys_var_uint32_t_ptr sys_server_id(
"server_id", &server_id);
180 static sys_var_const_string sys_server_uuid(
"server_uuid", server_uuid);
182 static sys_var_session_size_t sys_sort_buffer(
"sort_buffer_size", &drizzle_system_variables::sortbuff_size);
184 static sys_var_size_t_ptr_readonly sys_transaction_message_threshold(
"transaction_message_threshold", &transaction_message_threshold);
186 static sys_var_session_storage_engine sys_storage_engine(
"storage_engine", &drizzle_system_variables::storage_engine);
187 static sys_var_size_t_ptr sys_table_def_size(
"table_definition_cache", &table_def_size);
188 static sys_var_uint64_t_ptr sys_table_cache_size(
"table_open_cache", &table_cache_size);
189 static sys_var_uint64_t_ptr sys_table_lock_wait_timeout(
"table_lock_wait_timeout", &table_lock_wait_timeout);
190 static sys_var_session_enum sys_tx_isolation(
"tx_isolation",
191 &drizzle_system_variables::tx_isolation,
192 &tx_isolation_typelib,
195 static sys_var_session_uint64_t sys_tmp_table_size(
"tmp_table_size",
196 &drizzle_system_variables::tmp_table_size);
197 static sys_var_bool_ptr sys_timed_mutexes(
"timed_mutexes", &internal::timed_mutexes);
198 static sys_var_const_str sys_version(
"version", version().c_str());
200 static sys_var_const_str sys_version_comment(
"version_comment", COMPILATION_COMMENT);
201 static sys_var_const_str sys_version_compile_machine(
"version_compile_machine", HOST_CPU);
202 static sys_var_const_str sys_version_compile_os(
"version_compile_os", HOST_OS);
203 static sys_var_const_str sys_version_compile_vendor(
"version_compile_vendor", HOST_VENDOR);
207 sys_var_session_bit sys_autocommit(
"autocommit", 0, set_option_autocommit, OPTION_NOT_AUTOCOMMIT, 1);
208 static sys_var_session_bit sys_big_selects(
"sql_big_selects", 0, set_option_bit, OPTION_BIG_SELECTS);
209 static sys_var_session_bit sys_sql_warnings(
"sql_warnings", 0, set_option_bit, OPTION_WARNINGS);
210 static sys_var_session_bit sys_sql_notes(
"sql_notes", 0, set_option_bit, OPTION_SQL_NOTES);
211 static sys_var_session_bit sys_buffer_results(
"sql_buffer_result", 0, set_option_bit, OPTION_BUFFER_RESULT);
212 static sys_var_session_bit sys_foreign_key_checks(
"foreign_key_checks", 0, set_option_bit, OPTION_NO_FOREIGN_KEY_CHECKS, 1);
213 static sys_var_session_bit sys_unique_checks(
"unique_checks", 0, set_option_bit, OPTION_RELAXED_UNIQUE_CHECKS, 1);
216 static sys_var_session_ha_rows sys_select_limit(
"sql_select_limit", &drizzle_system_variables::select_limit);
217 static sys_var_timestamp sys_timestamp(
"timestamp");
218 static sys_var_last_insert_id
219 sys_last_insert_id(
"last_insert_id");
224 static sys_var_last_insert_id sys_identity(
"identity");
226 static sys_var_session_lc_time_names sys_lc_time_names(
"lc_time_names");
240 static sys_var_readonly sys_error_count(
"error_count", OPT_SESSION, SHOW_INT, get_error_count);
241 static sys_var_readonly sys_warning_count(
"warning_count", OPT_SESSION, SHOW_INT, get_warning_count);
243 sys_var_session_uint64_t sys_group_concat_max_len(
"group_concat_max_len", &drizzle_system_variables::group_concat_max_len);
246 static sys_var_const_string sys_hostname(
"hostname", getServerHostname());
248 static sys_var_const_str sys_revid(
"vc_revid", DRIZZLE_VC_REVID);
249 static sys_var_const_str sys_branch(
"vc_branch", DRIZZLE_VC_BRANCH);
250 static sys_var_size_t_ptr_readonly sys_revno(
"vc_revno", &revno);
251 static sys_var_size_t_ptr_readonly sys_release_id(
"vc_release_id", &release_id);
253 bool sys_var::check(Session *session, set_var *var)
257 int res= (*check_func)(session, var);
259 my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), getName().c_str(), var->value->str_value.ptr());
266 bool sys_var_str::check(Session *session, set_var *var)
271 int res= (*check_func)(session, var);
273 my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), getName().c_str(), var->value->str_value.ptr());
277 bool sys_var_std_string::check(Session *session, set_var *var)
282 if ((*check_func)(session, var))
284 my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), getName().c_str(), var->value->str_value.ptr());
301 if (type != OPT_GLOBAL)
303 if (session->
variables.max_join_size == HA_POS_ERROR)
304 session->
options|= OPTION_BIG_SELECTS;
306 session->
options&= ~OPTION_BIG_SELECTS;
317 if (var->type == OPT_DEFAULT && (session->server_status & SERVER_STATUS_IN_TRANS))
319 my_error(ER_CANT_CHANGE_TX_ISOLATION, MYF(0));
329 static void fix_tx_isolation(Session *session, sql_var_t type)
331 if (type == OPT_SESSION)
332 session->session_tx_isolation= (enum_tx_isolation) session->variables.tx_isolation;
335 static int check_completion_type(Session *, set_var *var)
337 int64_t val= var->value->val_int();
338 if (val < 0 || val > 2)
341 my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), var->var->getName().c_str(), internal::llstr(val, buf));
348 static void fix_session_mem_root(Session *session, sql_var_t type)
350 if (type != OPT_GLOBAL)
351 session->mem.reset_defaults(session->variables.query_alloc_block_size, session->variables.query_prealloc_size);
355 void throw_bounds_warning(Session *session,
bool fixed,
bool unsignd,
const std::string &name, int64_t val)
359 char buf[DECIMAL_LONGLONG_DIGITS];
362 internal::ullstr((uint64_t) val, buf);
364 internal::llstr(val, buf);
366 push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_ERROR,
367 ER_TRUNCATED_WRONG_VALUE, ER(ER_TRUNCATED_WRONG_VALUE), name.c_str(), buf);
370 uint64_t fix_unsigned(Session *session, uint64_t num,
const option& option_limits)
373 uint64_t out= getopt_ull_limit_value(num, option_limits, &fixed);
375 throw_bounds_warning(session, fixed,
true, option_limits.name, (int64_t) num);
380 static size_t fix_size_t(Session *session,
size_t num,
const option& option_limits)
383 size_t out= (size_t)getopt_ull_limit_value(num, option_limits, &fixed);
385 throw_bounds_warning(session, fixed,
true, option_limits.name, (int64_t) num);
389 bool sys_var_uint32_t_ptr::check(Session *, set_var *var)
395 bool sys_var_uint32_t_ptr::update(Session *session, set_var *var)
397 uint64_t tmp= var->getInteger();
398 boost::mutex::scoped_lock scopedLock(session->catalog().systemVariableLock());
402 uint32_t newvalue= (uint32_t) fix_unsigned(session, tmp, *option_limits);
403 if (static_cast<uint64_t>(newvalue) == tmp)
408 *value=
static_cast<uint32_t
>(tmp);
415 void sys_var_uint32_t_ptr::set_default(Session *session, sql_var_t)
418 boost::mutex::scoped_lock scopedLock(session->catalog().systemVariableLock());
419 *value= (uint32_t)getopt_ull_limit_value((uint32_t) option_limits->def_value, *option_limits, ¬_used);
423 bool sys_var_uint64_t_ptr::update(Session *session, set_var *var)
425 uint64_t tmp= var->getInteger();
426 boost::mutex::scoped_lock scopedLock(session->catalog().systemVariableLock());
430 uint64_t newvalue= fix_unsigned(session, tmp, *option_limits);
443 void sys_var_uint64_t_ptr::set_default(Session *session, sql_var_t)
445 if (have_default_value)
447 *value= default_value;
452 boost::mutex::scoped_lock scopedLock(session->catalog().systemVariableLock());
453 *value= getopt_ull_limit_value((uint64_t) option_limits->def_value, *option_limits, ¬_used);
458 bool sys_var_size_t_ptr::update(Session *session, set_var *var)
460 size_t tmp= size_t(var->getInteger());
462 boost::mutex::scoped_lock scopedLock(session->catalog().systemVariableLock());
465 *value= fix_size_t(session, tmp, *option_limits);
473 void sys_var_size_t_ptr::set_default(Session *session, sql_var_t)
476 boost::mutex::scoped_lock scopedLock(session->catalog().systemVariableLock());
477 *value= (size_t)getopt_ull_limit_value((
size_t) option_limits->def_value, *option_limits, ¬_used);
480 bool sys_var_bool_ptr::check(Session *session, set_var *var)
482 return check_enum(session, var, &bool_typelib);
485 bool sys_var_bool_ptr::update(Session *, set_var *var)
487 *value= bool(var->getInteger());
492 void sys_var_bool_ptr::set_default(Session *, sql_var_t)
494 *value= default_value;
501 bool sys_var_session_uint32_t::check(Session *session, set_var *var)
504 return (check_func && (*check_func)(session, var));
507 bool sys_var_session_uint32_t::update(Session *session, set_var *var)
509 uint64_t tmp= var->getInteger();
512 if ((uint32_t) tmp > max_system_variables.*offset)
514 throw_bounds_warning(session,
true,
true, getName(), (int64_t) tmp);
515 tmp= max_system_variables.*offset;
519 tmp= (uint32_t) fix_unsigned(session, tmp, *option_limits);
520 else if (tmp > UINT32_MAX)
523 throw_bounds_warning(session,
true,
true, getName(), int64_t(var->getInteger()));
526 if (var->type == OPT_GLOBAL)
527 global_system_variables.*offset= (uint32_t) tmp;
529 session->variables.*offset= (uint32_t) tmp;
535 void sys_var_session_uint32_t::set_default(Session *session, sql_var_t type)
537 if (type == OPT_GLOBAL)
541 global_system_variables.*offset=
542 (uint32_t) getopt_ull_limit_value((uint32_t) option_limits->def_value, *option_limits, ¬_used);
545 session->variables.*offset= global_system_variables.*offset;
549 unsigned char *sys_var_session_uint32_t::value_ptr(Session *session, sql_var_t type)
551 return type == OPT_GLOBAL
552 ? (
unsigned char*) &(global_system_variables.*offset)
553 : (unsigned char*) &(session->variables.*offset);
557 bool sys_var_session_ha_rows::update(Session *session, set_var *var)
559 uint64_t tmp= var->getInteger();
562 if ((ha_rows) tmp > max_system_variables.*offset)
563 tmp= max_system_variables.*offset;
566 tmp= (ha_rows) fix_unsigned(session, tmp, *option_limits);
567 if (var->type == OPT_GLOBAL)
570 boost::mutex::scoped_lock scopedLock(session->catalog().systemVariableLock());
571 global_system_variables.*offset= (ha_rows) tmp;
575 session->variables.*offset= (ha_rows) tmp;
582 void sys_var_session_ha_rows::set_default(Session *session, sql_var_t type)
584 if (type == OPT_GLOBAL)
588 boost::mutex::scoped_lock scopedLock(session->catalog().systemVariableLock());
589 global_system_variables.*offset=
590 (ha_rows) getopt_ull_limit_value((ha_rows) option_limits->def_value, *option_limits, ¬_used);
594 session->variables.*offset= global_system_variables.*offset;
599 unsigned char *sys_var_session_ha_rows::value_ptr(Session *session, sql_var_t type)
601 return type == OPT_GLOBAL
602 ? (
unsigned char*) &(global_system_variables.*offset)
603 : (unsigned char*) &(session->variables.*offset);
606 bool sys_var_session_uint64_t::check(Session *session, set_var *var)
609 return (check_func && (*check_func)(session, var));
612 bool sys_var_session_uint64_t::update(Session *session, set_var *var)
614 uint64_t tmp= var->getInteger();
616 if (tmp > max_system_variables.*offset)
618 throw_bounds_warning(session,
true,
true, getName(), (int64_t) tmp);
619 tmp= max_system_variables.*offset;
623 tmp= fix_unsigned(session, tmp, *option_limits);
624 if (var->type == OPT_GLOBAL)
627 boost::mutex::scoped_lock scopedLock(session->catalog().systemVariableLock());
628 global_system_variables.*offset= (uint64_t) tmp;
632 session->variables.*offset= (uint64_t) tmp;
639 void sys_var_session_uint64_t::set_default(Session *session, sql_var_t type)
641 if (type == OPT_GLOBAL)
644 boost::mutex::scoped_lock scopedLock(session->catalog().systemVariableLock());
645 global_system_variables.*offset=
646 getopt_ull_limit_value((uint64_t) option_limits->def_value, *option_limits, ¬_used);
650 session->variables.*offset= global_system_variables.*offset;
655 unsigned char *sys_var_session_uint64_t::value_ptr(Session *session, sql_var_t type)
657 return type == OPT_GLOBAL
658 ? (
unsigned char*) &(global_system_variables.*offset)
659 : (unsigned char*) &(session->variables.*offset);
662 bool sys_var_session_size_t::check(Session *session, set_var *var)
665 return (check_func && (*check_func)(session, var));
668 bool sys_var_session_size_t::update(Session *session, set_var *var)
670 size_t tmp= size_t(var->getInteger());
672 if (tmp > max_system_variables.*offset)
673 tmp= max_system_variables.*offset;
676 tmp= fix_size_t(session, tmp, *option_limits);
677 if (var->type == OPT_GLOBAL)
680 boost::mutex::scoped_lock scopedLock(session->catalog().systemVariableLock());
681 global_system_variables.*offset= tmp;
685 session->variables.*offset= tmp;
692 void sys_var_session_size_t::set_default(Session *session, sql_var_t type)
694 if (type == OPT_GLOBAL)
697 boost::mutex::scoped_lock scopedLock(session->catalog().systemVariableLock());
698 global_system_variables.*offset=
699 (size_t)getopt_ull_limit_value((
size_t) option_limits->def_value, *option_limits, ¬_used);
703 session->variables.*offset= global_system_variables.*offset;
708 unsigned char *sys_var_session_size_t::value_ptr(Session *session, sql_var_t type)
710 return type == OPT_GLOBAL
711 ? (
unsigned char*) &(global_system_variables.*offset)
712 : (unsigned char*) &(session->variables.*offset);
715 bool sys_var_session_bool::check(Session *session, set_var *var)
717 return check_enum(session, var, &bool_typelib);
720 bool sys_var_session_bool::update(Session *session, set_var *var)
722 if (var->type == OPT_GLOBAL)
723 global_system_variables.*offset= bool(var->getInteger());
725 session->variables.*offset= bool(var->getInteger());
731 void sys_var_session_bool::set_default(Session *session, sql_var_t type)
733 if (type == OPT_GLOBAL)
734 global_system_variables.*offset= (bool) option_limits->def_value;
736 session->variables.*offset= global_system_variables.*offset;
740 unsigned char *sys_var_session_bool::value_ptr(Session *session, sql_var_t type)
742 return type == OPT_GLOBAL
743 ? (
unsigned char*) &(global_system_variables.*offset)
744 : (unsigned char*) &(session->variables.*offset);
748 bool sys_var::check_enum(Session *, set_var *var,
const TYPELIB *enum_names)
750 char buff[STRING_BUFFER_USUAL_SIZE];
752 String str(buff,
sizeof(buff), system_charset_info), *res;
754 if (var->value->result_type() == STRING_RESULT)
756 res= var->value->val_str(&str);
763 uint64_t tmp_val= enum_names->find_type(res->ptr(), res->length(),
true);
769 var->setValue(tmp_val-1);
773 uint64_t tmp= var->value->val_int();
774 if (tmp >= enum_names->count)
776 internal::llstr(tmp,buff);
785 my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), name.c_str(), value);
800 if (check_type(var_type))
802 if (var_type != OPT_DEFAULT)
804 my_error(ER_INCORRECT_GLOBAL_LOCAL_VAR, MYF(0), name.c_str(), var_type == OPT_GLOBAL ?
"SESSION" :
"GLOBAL");
808 var_type= OPT_GLOBAL;
810 boost::mutex::scoped_lock lock(session->catalog().systemVariableLock());
816 uint32_t value= *(uint*) value_ptr(session, var_type);
821 int64_t value= *(int64_t*) value_ptr(session, var_type);
826 double value= *(
double*) value_ptr(session, var_type);
832 ha_rows value= *(ha_rows*) value_ptr(session, var_type);
833 return new Item_int((uint64_t) value);
837 size_t value= *(
size_t*) value_ptr(session, var_type);
838 return new Item_int((uint64_t) value);
842 int32_t value= *(
bool*) value_ptr(session, var_type);
847 if (
const char *str= *(
char**) value_ptr(session, var_type))
849 uint32_t length= strlen(str);
850 return new Item_string(session->mem.
strdup(str, length), length, system_charset_info, DERIVATION_SYSCONST);
853 tmp->collation.set(system_charset_info, DERIVATION_SYSCONST);
858 if (
const char* str= (
char*) value_ptr(session, var_type))
861 tmp->collation.set(system_charset_info, DERIVATION_SYSCONST);
865 my_error(ER_VAR_CANT_BE_READ, MYF(0), name.c_str());
873 if (var->type == OPT_GLOBAL)
874 global_system_variables.*offset= var->getInteger();
876 session->
variables.*offset= var->getInteger();
881 void sys_var_session_enum::set_default(Session *session, sql_var_t type)
883 if (type == OPT_GLOBAL)
884 global_system_variables.*offset= (uint32_t) option_limits->def_value;
886 session->variables.*offset= global_system_variables.*offset;
890 unsigned char *sys_var_session_enum::value_ptr(Session *session, sql_var_t type)
892 uint32_t tmp= type == OPT_GLOBAL ? global_system_variables.*offset : session->variables.*offset;
893 return (
unsigned char*) enum_names->type_names[tmp];
896 bool sys_var_session_bit::check(Session *session, set_var *var)
898 return check_enum(session, var, &bool_typelib) || (check_func && (*check_func)(session, var));
901 bool sys_var_session_bit::update(Session *session, set_var *var)
903 return (*update_func)(session, var);
907 unsigned char *sys_var_session_bit::value_ptr(Session *session, sql_var_t)
913 session->sys_var_tmp.bool_value= (session->options & bit_flag) ? !reverse : reverse;
914 return (
unsigned char*) &session->sys_var_tmp.bool_value;
918 bool sys_var_collation_sv::update(Session *session, set_var *var)
920 const charset_info_st *tmp;
922 if (var->value->result_type() == STRING_RESULT)
924 char buff[STRING_BUFFER_USUAL_SIZE];
925 String str(buff,
sizeof(buff), system_charset_info), *res;
926 if (!(res=var->value->val_str(&str)))
928 boost::throw_exception(invalid_option_value(var->var->getName()) << invalid_value(std::string(
"NULL")));
931 if (!(tmp=get_charset_by_name(res->c_ptr())))
933 my_error(ER_UNKNOWN_COLLATION, MYF(0), res->c_ptr());
934 boost::throw_exception(invalid_option_value(var->var->getName()) << invalid_value(std::string(res->c_ptr())));
940 if (!(tmp=get_charset((
int) var->value->val_int())))
943 internal::int10_to_str((
int) var->value->val_int(), buf, -10);
944 my_error(ER_UNKNOWN_COLLATION, MYF(0), buf);
945 boost::throw_exception(invalid_option_value(var->var->getName()) << invalid_value(boost::lexical_cast<std::string>(var->value->val_int())));
949 if (var->type == OPT_GLOBAL)
950 global_system_variables.*offset= tmp;
953 session->variables.*offset= tmp;
959 void sys_var_collation_sv::set_default(Session *session, sql_var_t type)
961 if (type == OPT_GLOBAL)
962 global_system_variables.*offset= *global_default;
965 session->variables.*offset= global_system_variables.*offset;
970 unsigned char *sys_var_collation_sv::value_ptr(Session *session, sql_var_t type)
972 const charset_info_st *cs= type == OPT_GLOBAL ? global_system_variables.*offset : session->variables.*offset;
973 return cs ? (
unsigned char*) cs->name : (
unsigned char*)
"NULL";
978 bool sys_var_timestamp::update(Session *session, set_var *var)
980 session->times.set_time(time_t(var->getInteger()));
985 void sys_var_timestamp::set_default(Session *session, sql_var_t)
987 session->times.resetUserTime();
991 unsigned char *sys_var_timestamp::value_ptr(Session *session, sql_var_t)
993 session->sys_var_tmp.int32_t_value= (int32_t) session->times.getCurrentTimestampEpoch();
994 return (
unsigned char*) &session->sys_var_tmp.int32_t_value;
998 bool sys_var_last_insert_id::update(Session *session, set_var *var)
1000 session->first_successful_insert_id_in_prev_stmt= var->getInteger();
1005 unsigned char *sys_var_last_insert_id::value_ptr(Session *session, sql_var_t)
1011 session->sys_var_tmp.uint64_t_value=
1012 session->read_first_successful_insert_id_in_prev_stmt();
1013 return (
unsigned char*) &session->sys_var_tmp.uint64_t_value;
1016 bool sys_var_session_lc_time_names::update(Session *session, set_var *var)
1018 MY_LOCALE *locale_match;
1020 if (var->value->result_type() == INT_RESULT)
1022 if (!(locale_match= my_locale_by_number((uint32_t) var->value->val_int())))
1024 char buf[DECIMAL_LONGLONG_DIGITS];
1025 internal::int10_to_str((
int) var->value->val_int(), buf, -10);
1026 my_printf_error(ER_UNKNOWN_ERROR,
"Unknown locale: '%s'", MYF(0), buf);
1033 String str(buff,
sizeof(buff), &my_charset_utf8_general_ci), *res;
1034 if (!(res=var->value->val_str(&str)))
1036 my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), name.c_str(),
"NULL");
1039 const char *locale_str= res->c_ptr();
1040 if (!(locale_match= my_locale_by_name(locale_str)))
1042 my_printf_error(ER_UNKNOWN_ERROR,
1043 "Unknown locale: '%s'", MYF(0), locale_str);
1048 if (var->type == OPT_GLOBAL)
1049 global_system_variables.lc_time_names= locale_match;
1051 session->variables.lc_time_names= locale_match;
1056 unsigned char *sys_var_session_lc_time_names::value_ptr(Session *session, sql_var_t type)
1058 return type == OPT_GLOBAL
1059 ? (
unsigned char *) global_system_variables.lc_time_names->name
1060 : (
unsigned char *) session->variables.lc_time_names->name;
1064 void sys_var_session_lc_time_names::set_default(Session *session, sql_var_t type)
1066 if (type == OPT_GLOBAL)
1067 global_system_variables.lc_time_names= my_default_lc_time_names;
1069 session->variables.lc_time_names= global_system_variables.lc_time_names;
1081 bool sys_var_microseconds::update(Session *session, set_var *var)
1083 double num= var->value->val_real();
1084 int64_t microseconds;
1085 if (num > (
double) option_limits->max_value)
1086 num= (double) option_limits->max_value;
1087 if (num < (
double) option_limits->min_value)
1088 num= (
double) option_limits->min_value;
1089 microseconds= (int64_t) (num * 1000000.0 + 0.5);
1090 if (var->type == OPT_GLOBAL)
1092 boost::mutex::scoped_lock scopedLock(session->catalog().systemVariableLock());
1093 (global_system_variables.*offset)= microseconds;
1096 session->variables.*offset= microseconds;
1101 void sys_var_microseconds::set_default(Session *session, sql_var_t type)
1103 int64_t microseconds= (int64_t) (option_limits->def_value * 1000000.0);
1104 if (type == OPT_GLOBAL)
1106 boost::mutex::scoped_lock scopedLock(session->catalog().systemVariableLock());
1107 global_system_variables.*offset= microseconds;
1110 session->variables.*offset= microseconds;
1117 static bool set_option_bit(Session *session, set_var *var)
1119 sys_var_session_bit *sys_var= ((sys_var_session_bit*) var->var);
1120 if ((var->getInteger() != 0) == sys_var->reverse)
1121 session->options&= ~sys_var->bit_flag;
1123 session->options|= sys_var->bit_flag;
1128 static bool set_option_autocommit(Session *session, set_var *var)
1133 uint64_t org_options= session->options;
1134 uint64_t new_options= session->options;
1136 if (var->getInteger() != 0)
1137 new_options&= ~((sys_var_session_bit*) var->var)->bit_flag;
1139 new_options|= ((sys_var_session_bit*) var->var)->bit_flag;
1141 if ((org_options ^ new_options) & OPTION_NOT_AUTOCOMMIT)
1143 if ((org_options & OPTION_NOT_AUTOCOMMIT))
1145 success= session->endActiveTransaction();
1147 session->options&= ~(uint64_t) (OPTION_BEGIN);
1148 session->server_status|= SERVER_STATUS_AUTOCOMMIT;
1152 session->server_status&= ~SERVER_STATUS_AUTOCOMMIT;
1156 if (var->getInteger() != 0)
1157 session->options&= ~((sys_var_session_bit*) var->var)->bit_flag;
1159 session->options|= ((sys_var_session_bit*) var->var)->bit_flag;
1164 static int check_pseudo_thread_id(Session *, set_var *var)
1170 static unsigned char *get_warning_count(Session *session)
1172 session->sys_var_tmp.uint32_t_value=
1173 (session->warn_count[(uint32_t) DRIZZLE_ERROR::WARN_LEVEL_NOTE] +
1174 session->warn_count[(uint32_t) DRIZZLE_ERROR::WARN_LEVEL_ERROR] +
1175 session->warn_count[(uint32_t) DRIZZLE_ERROR::WARN_LEVEL_WARN]);
1176 return (
unsigned char*) &session->sys_var_tmp.uint32_t_value;
1179 static unsigned char *get_error_count(Session *session)
1181 session->sys_var_tmp.uint32_t_value=
1182 session->warn_count[(uint32_t) DRIZZLE_ERROR::WARN_LEVEL_ERROR];
1183 return (
unsigned char*) &session->sys_var_tmp.uint32_t_value;
1203 assert(drizzle_tmpdir.size());
1204 return (
unsigned char*)drizzle_tmpdir.c_str();
1229 uint32_t length= strlen(name);
1230 for (; opt->name; opt++)
1232 if (not getopt_compare_strings(opt->name, name, length) and not opt->name[length])
1238 return opt->value ? opt : NULL;
1260 drizzle_show_var* enumerate_sys_vars(Session *session)
1262 drizzle_show_var *result=
new (session->mem) drizzle_show_var[system_variable_map.size() + 1];
1263 drizzle_show_var *show= result;
1264 BOOST_FOREACH(SystemVariableMap::const_reference iter, system_variable_map)
1266 sys_var *var= iter.second;
1267 show->name= var->getName().c_str();
1268 show->value= (
char*) var;
1269 show->type= SHOW_SYS;
1274 memset(show, 0,
sizeof(drizzle_show_var));
1278 void add_sys_var_to_list(sys_var *var)
1280 string lower_name(var->getName());
1281 boost::to_lower(lower_name);
1284 if (system_variable_map.count(lower_name))
1286 errmsg_printf(error::ERROR, _(
"Variable named %s already exists!\n"), var->getName().c_str());
1290 pair<SystemVariableMap::iterator, bool> ret= system_variable_map.insert(make_pair(lower_name, var));
1291 if (ret.second ==
false)
1293 errmsg_printf(error::ERROR, _(
"Could not add Variable: %s\n"), var->getName().c_str());
1298 void add_sys_var_to_list(sys_var *var,
struct option *long_options)
1300 add_sys_var_to_list(var);
1301 var->setOptionLimits(
find_option(long_options, var->getName().c_str()));
1319 add_sys_var_to_list(&sys_auto_increment_increment, my_long_options);
1320 add_sys_var_to_list(&sys_auto_increment_offset, my_long_options);
1321 add_sys_var_to_list(&sys_autocommit, my_long_options);
1322 add_sys_var_to_list(&sys_back_log, my_long_options);
1323 add_sys_var_to_list(&sys_basedir, my_long_options);
1324 add_sys_var_to_list(&sys_big_selects, my_long_options);
1325 add_sys_var_to_list(&sys_branch, my_long_options);
1326 add_sys_var_to_list(&sys_buffer_results, my_long_options);
1327 add_sys_var_to_list(&sys_bulk_insert_buff_size, my_long_options);
1328 add_sys_var_to_list(&sys_collation_server, my_long_options);
1329 add_sys_var_to_list(&sys_completion_type, my_long_options);
1330 add_sys_var_to_list(&sys_datadir, my_long_options);
1331 add_sys_var_to_list(&sys_div_precincrement, my_long_options);
1332 add_sys_var_to_list(&sys_error_count, my_long_options);
1333 add_sys_var_to_list(&sys_foreign_key_checks, my_long_options);
1334 add_sys_var_to_list(&sys_group_concat_max_len, my_long_options);
1335 add_sys_var_to_list(&sys_hostname, my_long_options);
1336 add_sys_var_to_list(&sys_identity, my_long_options);
1337 add_sys_var_to_list(&sys_join_buffer_size, my_long_options);
1338 add_sys_var_to_list(&sys_last_insert_id, my_long_options);
1339 add_sys_var_to_list(&sys_lc_time_names, my_long_options);
1340 add_sys_var_to_list(&sys_max_allowed_packet, my_long_options);
1341 add_sys_var_to_list(&sys_max_error_count, my_long_options);
1342 add_sys_var_to_list(&sys_max_heap_table_size, my_long_options);
1343 add_sys_var_to_list(&sys_max_join_size, my_long_options);
1344 add_sys_var_to_list(&sys_max_length_for_sort_data, my_long_options);
1345 add_sys_var_to_list(&sys_max_seeks_for_key, my_long_options);
1346 add_sys_var_to_list(&sys_max_sort_length, my_long_options);
1347 add_sys_var_to_list(&sys_max_write_lock_count, my_long_options);
1348 add_sys_var_to_list(&sys_min_examined_row_limit, my_long_options);
1349 add_sys_var_to_list(&sys_optimizer_prune_level, my_long_options);
1350 add_sys_var_to_list(&sys_optimizer_search_depth, my_long_options);
1351 add_sys_var_to_list(&sys_pid_file, my_long_options);
1352 add_sys_var_to_list(&sys_plugin_dir, my_long_options);
1353 add_sys_var_to_list(&sys_preload_buff_size, my_long_options);
1354 add_sys_var_to_list(&sys_pseudo_thread_id, my_long_options);
1355 add_sys_var_to_list(&sys_query_alloc_block_size, my_long_options);
1356 add_sys_var_to_list(&sys_query_prealloc_size, my_long_options);
1357 add_sys_var_to_list(&sys_range_alloc_block_size, my_long_options);
1358 add_sys_var_to_list(&sys_read_buff_size, my_long_options);
1359 add_sys_var_to_list(&sys_read_rnd_buff_size, my_long_options);
1360 add_sys_var_to_list(&sys_release_id, my_long_options);
1361 add_sys_var_to_list(&sys_replicate_query, my_long_options);
1362 add_sys_var_to_list(&sys_revid, my_long_options);
1363 add_sys_var_to_list(&sys_revno, my_long_options);
1364 add_sys_var_to_list(&sys_scheduler, my_long_options);
1365 add_sys_var_to_list(&sys_secure_file_priv, my_long_options);
1366 add_sys_var_to_list(&sys_select_limit, my_long_options);
1367 add_sys_var_to_list(&sys_server_id, my_long_options);
1368 add_sys_var_to_list(&sys_server_uuid, my_long_options);
1369 add_sys_var_to_list(&sys_sort_buffer, my_long_options);
1370 add_sys_var_to_list(&sys_sql_notes, my_long_options);
1371 add_sys_var_to_list(&sys_sql_warnings, my_long_options);
1372 add_sys_var_to_list(&sys_storage_engine, my_long_options);
1373 add_sys_var_to_list(&sys_table_cache_size, my_long_options);
1374 add_sys_var_to_list(&sys_table_def_size, my_long_options);
1375 add_sys_var_to_list(&sys_table_lock_wait_timeout, my_long_options);
1376 add_sys_var_to_list(&sys_thread_stack_size, my_long_options);
1377 add_sys_var_to_list(&sys_timed_mutexes, my_long_options);
1378 add_sys_var_to_list(&sys_timestamp, my_long_options);
1379 add_sys_var_to_list(&sys_tmp_table_size, my_long_options);
1380 add_sys_var_to_list(&sys_tmpdir, my_long_options);
1381 add_sys_var_to_list(&sys_transaction_message_threshold, my_long_options);
1382 add_sys_var_to_list(&sys_tx_isolation, my_long_options);
1383 add_sys_var_to_list(&sys_unique_checks, my_long_options);
1384 add_sys_var_to_list(&sys_version, my_long_options);
1385 add_sys_var_to_list(&sys_version_comment, my_long_options);
1386 add_sys_var_to_list(&sys_version_compile_machine, my_long_options);
1387 add_sys_var_to_list(&sys_version_compile_os, my_long_options);
1388 add_sys_var_to_list(&sys_version_compile_vendor, my_long_options);
1389 add_sys_var_to_list(&sys_warning_count, my_long_options);
1391 catch (std::exception&)
1393 errmsg_printf(error::ERROR, _(
"Failed to initialize system variables"));
1413 if (sys_var* ptr= find_ptr2(system_variable_map, boost::to_lower_copy(name)))
1415 my_error(ER_UNKNOWN_SYSTEM_VARIABLE, MYF(0), name.c_str());
1424 unsigned char *sys_var_session_storage_engine::value_ptr(Session *session, sql_var_t type)
1426 plugin::StorageEngine *engine= type == OPT_GLOBAL
1427 ? global_system_variables.*offset
1428 : session->variables.*offset;
1429 return (
unsigned char *) session->mem.strdup(engine->getName());
1433 void sys_var_session_storage_engine::set_default(Session *session, sql_var_t type)
1435 plugin::StorageEngine *new_value, **value;
1436 if (type == OPT_GLOBAL)
1438 value= &(global_system_variables.*offset);
1439 new_value= myisam_engine;
1443 value= &(session->variables.*offset);
1444 new_value= global_system_variables.*offset;
1451 bool sys_var_session_storage_engine::update(Session *session, set_var *var)
1453 char buff[STRING_BUFFER_USUAL_SIZE];
1454 const char *name_value;
1455 String str(buff,
sizeof(buff), &my_charset_utf8_general_ci), *res;
1457 plugin::StorageEngine *tmp= NULL;
1458 plugin::StorageEngine **value= NULL;
1460 if (var->value->result_type() == STRING_RESULT)
1462 res= var->value->val_str(&str);
1463 if (res == NULL || res->ptr() == NULL)
1470 const std::string engine_name(res->ptr());
1471 tmp= plugin::StorageEngine::findByName(*session, engine_name);
1474 name_value= res->c_ptr();
1481 name_value=
"unknown";
1484 value= &(global_system_variables.*offset);
1485 if (var->type != OPT_GLOBAL)
1486 value= &(session->variables.*offset);
1493 my_error(ER_UNKNOWN_STORAGE_ENGINE, MYF(0), name_value);
static int check_tx_isolation(Session *, set_var *)
TODO: Rename this file - func.h is stupid.
static unsigned char * get_tmpdir(Session *)
Visibility Control Macros.
sys_var * find_sys_var(const std::string &name)
static void fix_max_join_size(Session *, sql_var_t)
drizzle_system_variables & variables
char * strdup(const char *)
Duplicate a null-terminated string into memory allocated from within the specified Root...
static option * find_option(struct option *opt, const char *name)