← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sys_var.cc

  • Committer: Lee Bieber
  • Date: 2011-03-18 04:10:25 UTC
  • mfrom: (2241.1.2 build)
  • Revision ID: kalebral@gmail.com-20110318041025-1xoj1azy6zobhnbm
Merge Stewart - refactoring of default values
Merge Olaf - more refactoring

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sys_var.cc
38
38
 
39
39
*/
40
40
 
41
 
#include "config.h"
42
 
#include "drizzled/option.h"
43
 
#include "drizzled/error.h"
44
 
#include "drizzled/gettext.h"
45
 
#include "drizzled/tztime.h"
46
 
#include "drizzled/data_home.h"
47
 
#include "drizzled/set_var.h"
48
 
#include "drizzled/session.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/strfunc.h"
58
 
#include "drizzled/internal/m_string.h"
59
 
#include "drizzled/pthread_globals.h"
60
 
#include "drizzled/charset.h"
61
 
#include "drizzled/transaction_services.h"
62
 
#include "drizzled/constrained_value.h"
63
 
#include "drizzled/visibility.h"
64
 
#include "drizzled/plugin/storage_engine.h"
 
41
#include <config.h>
 
42
#include <drizzled/option.h>
 
43
#include <drizzled/error.h>
 
44
#include <drizzled/gettext.h>
 
45
#include <drizzled/tztime.h>
 
46
#include <drizzled/data_home.h>
 
47
#include <drizzled/set_var.h>
 
48
#include <drizzled/session.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>
 
62
#include <drizzled/visibility.h>
 
63
#include <drizzled/typelib.h>
 
64
#include <drizzled/plugin/storage_engine.h>
65
65
 
66
66
#include <cstdio>
67
67
#include <map>
91
91
 
92
92
extern TYPELIB tx_isolation_typelib;
93
93
 
 
94
namespace
 
95
{
 
96
static size_t revno= DRIZZLE7_VC_REVNO;
 
97
static size_t release_id= DRIZZLE7_RELEASE_ID;
 
98
}
 
99
 
94
100
const char *bool_type_names[]= { "OFF", "ON", NULL };
95
101
TYPELIB bool_typelib=
96
102
{
218
224
 
219
225
static sys_var_session_storage_engine sys_storage_engine("storage_engine",
220
226
                                       &drizzle_system_variables::storage_engine);
221
 
static sys_var_const_str        sys_system_time_zone("system_time_zone",
222
 
                                             system_time_zone);
223
227
static sys_var_size_t_ptr       sys_table_def_size("table_definition_cache",
224
228
                                             &table_def_size);
225
229
static sys_var_uint64_t_ptr     sys_table_cache_size("table_open_cache",
308
312
sys_var_session_uint64_t sys_group_concat_max_len("group_concat_max_len",
309
313
                                                  &drizzle_system_variables::group_concat_max_len);
310
314
 
311
 
sys_var_session_time_zone sys_time_zone("time_zone");
312
 
 
313
315
/* Global read-only variable containing hostname */
314
 
static sys_var_const_str        sys_hostname("hostname", glob_hostname);
 
316
static sys_var_const_string sys_hostname("hostname", getServerHostname());
 
317
 
 
318
static sys_var_const_str sys_revid("vc_revid", DRIZZLE7_VC_REVID);
 
319
static sys_var_const_str sys_branch("vc_branch", DRIZZLE7_VC_BRANCH);
 
320
static sys_var_size_t_ptr_readonly sys_revno("vc_revno", &revno);
 
321
static sys_var_size_t_ptr_readonly sys_release_id("vc_release_id", &release_id);
315
322
 
316
323
bool sys_var::check(Session *session, set_var *var)
317
324
{
859
866
      goto err;
860
867
    }
861
868
 
862
 
    uint64_t tmp_val= find_type(enum_names, res->ptr(), res->length(),1);
 
869
    uint64_t tmp_val= enum_names->find_type(res->ptr(), res->length(), true);
863
870
    if (tmp_val == 0)
864
871
    {
865
872
      value= res->c_ptr();
1161
1168
  return (unsigned char*) &session->sys_var_tmp.uint64_t_value;
1162
1169
}
1163
1170
 
1164
 
 
1165
 
bool sys_var_session_time_zone::update(Session *session, set_var *var)
1166
 
{
1167
 
  char buff[MAX_TIME_ZONE_NAME_LENGTH];
1168
 
  String str(buff, sizeof(buff), &my_charset_utf8_general_ci);
1169
 
  String *res= var->value->val_str(&str);
1170
 
 
1171
 
  Time_zone *tmp= my_tz_find(session, res);
1172
 
  if (tmp == NULL)
1173
 
  {
1174
 
    boost::throw_exception(invalid_option_value(var->var->getName()) << invalid_value(std::string(res ? res->c_ptr() : "NULL")));
1175
 
    return 1;
1176
 
  }
1177
 
  /* We are using Time_zone object found during check() phase. */
1178
 
  if (var->type == OPT_GLOBAL)
1179
 
  {
1180
 
    boost::mutex::scoped_lock scopedLock(session->catalog().systemVariableLock());
1181
 
    global_system_variables.time_zone= tmp;
1182
 
  }
1183
 
  else
1184
 
  {
1185
 
    session->variables.time_zone= tmp;
1186
 
  }
1187
 
 
1188
 
  return 0;
1189
 
}
1190
 
 
1191
 
 
1192
 
unsigned char *sys_var_session_time_zone::value_ptr(Session *session,
1193
 
                                                    sql_var_t type,
1194
 
                                                    const LEX_STRING *)
1195
 
{
1196
 
  /*
1197
 
    We can use ptr() instead of c_ptr() here because String contaning
1198
 
    time zone name is guaranteed to be zero ended.
1199
 
  */
1200
 
  if (type == OPT_GLOBAL)
1201
 
    return (unsigned char *)(global_system_variables.time_zone->get_name()->ptr());
1202
 
  else
1203
 
  {
1204
 
    /*
1205
 
      This is an ugly fix for replication: we don't replicate properly queries
1206
 
      invoking system variables' values to update tables; but
1207
 
      CONVERT_TZ(,,@@session.time_zone) is so popular that we make it
1208
 
      replicable (i.e. we tell the binlog code to store the session
1209
 
      timezone). If it's the global value which was used we can't replicate
1210
 
      (binlog code stores session value only).
1211
 
    */
1212
 
    return (unsigned char *)(session->variables.time_zone->get_name()->ptr());
1213
 
  }
1214
 
}
1215
 
 
1216
 
 
1217
 
void sys_var_session_time_zone::set_default(Session *session, sql_var_t type)
1218
 
{
1219
 
  boost::mutex::scoped_lock scopedLock(session->catalog().systemVariableLock());
1220
 
  if (type == OPT_GLOBAL)
1221
 
  {
1222
 
    if (default_tz_name)
1223
 
    {
1224
 
      String str(default_tz_name, &my_charset_utf8_general_ci);
1225
 
      /*
1226
 
        We are guaranteed to find this time zone since its existence
1227
 
        is checked during start-up.
1228
 
      */
1229
 
      global_system_variables.time_zone= my_tz_find(session, &str);
1230
 
    }
1231
 
    else
1232
 
      global_system_variables.time_zone= my_tz_SYSTEM;
1233
 
  }
1234
 
  else
1235
 
    session->variables.time_zone= global_system_variables.time_zone;
1236
 
}
1237
 
 
1238
 
 
1239
 
 
1240
1171
bool sys_var_session_lc_time_names::update(Session *session, set_var *var)
1241
1172
{
1242
1173
  MY_LOCALE *locale_match;
1499
1430
    SystemVariableMap::const_iterator iter= system_variable_map.begin();
1500
1431
    while (iter != system_variable_map.end())
1501
1432
    {
1502
 
      sys_var *var= (*iter).second;
 
1433
      sys_var *var= iter->second;
1503
1434
      show->name= var->getName().c_str();
1504
1435
      show->value= (char*) var;
1505
1436
      show->type= SHOW_SYS;
1522
1453
            lower_name.begin(), ::tolower);
1523
1454
 
1524
1455
  /* this fails if there is a conflicting variable name. */
1525
 
  if (system_variable_map.find(lower_name) != system_variable_map.end())
 
1456
  if (system_variable_map.count(lower_name))
1526
1457
  {
1527
1458
    errmsg_printf(error::ERROR, _("Variable named %s already exists!\n"),
1528
1459
                  var->getName().c_str());
1566
1497
    add_sys_var_to_list(&sys_back_log, my_long_options);
1567
1498
    add_sys_var_to_list(&sys_basedir, my_long_options);
1568
1499
    add_sys_var_to_list(&sys_big_selects, my_long_options);
 
1500
    add_sys_var_to_list(&sys_branch, my_long_options);
1569
1501
    add_sys_var_to_list(&sys_buffer_results, my_long_options);
1570
1502
    add_sys_var_to_list(&sys_bulk_insert_buff_size, my_long_options);
1571
1503
    add_sys_var_to_list(&sys_collation_server, my_long_options);
1600
1532
    add_sys_var_to_list(&sys_range_alloc_block_size, my_long_options);
1601
1533
    add_sys_var_to_list(&sys_read_buff_size, my_long_options);
1602
1534
    add_sys_var_to_list(&sys_read_rnd_buff_size, my_long_options);
 
1535
    add_sys_var_to_list(&sys_release_id, my_long_options);
1603
1536
    add_sys_var_to_list(&sys_replicate_query, my_long_options);
 
1537
    add_sys_var_to_list(&sys_revid, my_long_options);
 
1538
    add_sys_var_to_list(&sys_revno, my_long_options);
1604
1539
    add_sys_var_to_list(&sys_scheduler, my_long_options);
1605
1540
    add_sys_var_to_list(&sys_secure_file_priv, my_long_options);
1606
1541
    add_sys_var_to_list(&sys_select_limit, my_long_options);
1609
1544
    add_sys_var_to_list(&sys_sql_notes, my_long_options);
1610
1545
    add_sys_var_to_list(&sys_sql_warnings, my_long_options);
1611
1546
    add_sys_var_to_list(&sys_storage_engine, my_long_options);
1612
 
    add_sys_var_to_list(&sys_system_time_zone, my_long_options);
1613
1547
    add_sys_var_to_list(&sys_table_cache_size, my_long_options);
1614
1548
    add_sys_var_to_list(&sys_table_def_size, my_long_options);
1615
1549
    add_sys_var_to_list(&sys_table_lock_wait_timeout, my_long_options);
1616
1550
    add_sys_var_to_list(&sys_thread_stack_size, my_long_options);
1617
 
    add_sys_var_to_list(&sys_time_zone, my_long_options);
1618
1551
    add_sys_var_to_list(&sys_timed_mutexes, my_long_options);
1619
1552
    add_sys_var_to_list(&sys_timestamp, my_long_options);
1620
1553
    add_sys_var_to_list(&sys_tmp_table_size, my_long_options);
1657
1590
 
1658
1591
  sys_var *result= NULL;
1659
1592
 
1660
 
  SystemVariableMap::iterator iter= system_variable_map.find(lower_name);
1661
 
  if (iter != system_variable_map.end())
1662
 
  {
1663
 
    result= (*iter).second;
1664
 
  } 
 
1593
  if (SystemVariableMap::mapped_type* ptr= find_ptr(system_variable_map, lower_name))
 
1594
    result= *ptr;
1665
1595
 
1666
1596
  if (result == NULL)
1667
1597
  {