← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/set_var.cc

  • Committer: Brian Aker
  • Date: 2009-05-30 20:14:43 UTC
  • mfrom: (1022.2.42 mordred)
  • Revision ID: brian@gaz-20090530201443-snmrokl1n7xkppb0
Merge Monty

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/set_var.cc
66
66
#include <drizzled/item/null.h>
67
67
#include <drizzled/item/float.h>
68
68
 
 
69
#include "drizzled/registry.h"
69
70
#include <map>
70
71
#include <algorithm>
71
72
 
76
77
extern size_t my_thread_stack_size;
77
78
 
78
79
static DYNAMIC_ARRAY fixed_show_vars;
79
 
static map<const string, sys_var *> system_variable_hash;
 
80
static drizzled::Registry<sys_var *> system_variable_hash;
80
81
extern char *opt_drizzle_tmpdir;
81
82
 
82
83
const char *bool_type_names[]= { "OFF", "ON", NULL };
110
111
static bool get_unsigned32(Session *session, set_var *var);
111
112
static bool get_unsigned64(Session *session, set_var *var);
112
113
bool throw_bounds_warning(Session *session, bool fixed, bool unsignd,
113
 
                          const char *name, int64_t val);
 
114
                          const std::string &name, int64_t val);
114
115
static KEY_CACHE *create_key_cache(const char *name, uint32_t length);
115
116
static unsigned char *get_error_count(Session *session);
116
117
static unsigned char *get_warning_count(Session *session);
404
405
 
405
406
  if ((res=(*check_func)(session, var)) < 0)
406
407
    my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0),
407
 
             name, var->value->str_value.ptr());
 
408
             name.c_str(), var->value->str_value.ptr());
408
409
  return res;
409
410
}
410
411
 
462
463
  if (val < 0 || val > 2)
463
464
  {
464
465
    char buf[64];
465
 
    my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), var->var->name, llstr(val, buf));
 
466
    my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0),
 
467
             var->var->name.c_str(), llstr(val, buf));
466
468
    return 1;
467
469
  }
468
470
  return 0;
534
536
 
535
537
 
536
538
bool throw_bounds_warning(Session *session, bool fixed, bool unsignd,
537
 
                          const char *name, int64_t val)
 
539
                          const std::string &name, int64_t val)
538
540
{
539
541
  if (fixed)
540
542
  {
547
549
 
548
550
    push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_ERROR,
549
551
                        ER_TRUNCATED_WRONG_VALUE,
550
 
                        ER(ER_TRUNCATED_WRONG_VALUE), name, buf);
 
552
                        ER(ER_TRUNCATED_WRONG_VALUE), name.c_str(), buf);
551
553
  }
552
554
  return false;
553
555
}
1003
1005
  return 0;
1004
1006
 
1005
1007
err:
1006
 
  my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), name, value);
 
1008
  my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), name.c_str(), value);
1007
1009
  return 1;
1008
1010
}
1009
1011
 
1071
1073
  return 0;
1072
1074
 
1073
1075
err:
1074
 
  my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), name, buff);
 
1076
  my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), name.c_str(), buff);
1075
1077
  return 1;
1076
1078
}
1077
1079
 
1091
1093
    if (var_type != OPT_DEFAULT)
1092
1094
    {
1093
1095
      my_error(ER_INCORRECT_GLOBAL_LOCAL_VAR, MYF(0),
1094
 
               name, var_type == OPT_GLOBAL ? "SESSION" : "GLOBAL");
 
1096
               name.c_str(), var_type == OPT_GLOBAL ? "SESSION" : "GLOBAL");
1095
1097
      return 0;
1096
1098
    }
1097
1099
    /* As there was no local variable, return the global value */
1184
1186
    return tmp;
1185
1187
  }
1186
1188
  default:
1187
 
    my_error(ER_VAR_CANT_BE_READ, MYF(0), name);
 
1189
    my_error(ER_VAR_CANT_BE_READ, MYF(0), name.c_str());
1188
1190
  }
1189
1191
  return 0;
1190
1192
}
1261
1263
    String str(buff,sizeof(buff), system_charset_info), *res;
1262
1264
    if (!(res=var->value->val_str(&str)))
1263
1265
    {
1264
 
      my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), name, "NULL");
 
1266
      my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), name.c_str(), "NULL");
1265
1267
      return 1;
1266
1268
    }
1267
1269
    if (!(tmp=get_charset_by_name(res->c_ptr())))
1630
1632
    String str(buff, sizeof(buff), &my_charset_utf8_general_ci), *res;
1631
1633
    if (!(res=var->value->val_str(&str)))
1632
1634
    {
1633
 
      my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), name, "NULL");
 
1635
      my_error(ER_WRONG_VALUE_FOR_VAR, MYF(0), name.c_str(), "NULL");
1634
1636
      return 1;
1635
1637
    }
1636
1638
    const char *locale_str= res->c_ptr();
1879
1881
 
1880
1882
  for (var= first; var; var= var->next)
1881
1883
  {
1882
 
    /* Make a temp string to hold this and then make it lower so that matching
1883
 
     * happens case-insensitive.
1884
 
     */
1885
 
    string var_name(var->name);
1886
 
    transform(var_name.begin(), var_name.end(), var_name.begin(), ::tolower);
1887
 
    var->name_length= var_name.length();
1888
1884
 
1889
1885
    /* this fails if there is a conflicting variable name. */
1890
 
    if (system_variable_hash.count(var_name) == 0)
 
1886
    if (system_variable_hash.add(var))
1891
1887
    {
1892
 
      system_variable_hash[var_name]= var;
 
1888
      return 1;
1893
1889
    } 
1894
 
    else
1895
 
    {
1896
 
      for (; first != var; first= first->next)
1897
 
      {
1898
 
        /*
1899
 
         * This is slightly expensive, since we have to do the transform 
1900
 
         * _again_ but should rarely happen unless there is a pretty
1901
 
         * major problem in the code
1902
 
         */
1903
 
        var_name= first->name;
1904
 
        transform(var_name.begin(), var_name.end(),
1905
 
                  var_name.begin(), ::tolower);
1906
 
        system_variable_hash.erase(var_name);
1907
 
      }
1908
 
      return 1;
1909
 
    }
1910
1890
    if (long_options)
1911
 
      var->option_limits= find_option(long_options, var->name);
 
1891
      var->option_limits= find_option(long_options, var->name.c_str());
1912
1892
  }
1913
1893
  return 0;
1914
1894
 
1930
1910
int mysql_del_sys_var_chain(sys_var *first)
1931
1911
{
1932
1912
  int result= 0;
1933
 
  string var_name;
1934
1913
 
1935
1914
  /* A write lock should be held on LOCK_system_variables_hash */
1936
1915
  for (sys_var *var= first; var; var= var->next)
1937
1916
  {
1938
 
    var_name= var->name;
1939
 
    transform(var_name.begin(), var_name.end(),
1940
 
              var_name.begin(), ::tolower);
1941
 
    result|= system_variable_hash.erase(var_name);
 
1917
    system_variable_hash.remove(var);
1942
1918
  }
1943
1919
 
1944
1920
  return result;
1970
1946
    SHOW_VAR *show= result + fixed_count;
1971
1947
    memcpy(result, fixed_show_vars.buffer, fixed_count * sizeof(SHOW_VAR));
1972
1948
 
1973
 
    map<string, sys_var *>::iterator iter;
 
1949
    drizzled::Registry<sys_var *>::const_iterator iter;
1974
1950
    for(iter= system_variable_hash.begin();
1975
1951
        iter != system_variable_hash.end();
1976
1952
        iter++)
1977
1953
    {
1978
 
      sys_var *var= (*iter).second;
1979
 
      show->name= var->name;
 
1954
      sys_var *var= *iter;
 
1955
      show->name= var->name.c_str();
1980
1956
      show->value= (char*) var;
1981
1957
      show->type= SHOW_SYS;
1982
1958
      show++;
2087
2063
    This function is only called from the sql_plugin.cc.
2088
2064
    A lock on LOCK_system_variable_hash should be held
2089
2065
  */
2090
 
  string lower_var(str);
2091
 
  transform(lower_var.begin(), lower_var.end(), lower_var.begin(), ::tolower);
2092
 
  map<string, sys_var *>::iterator result_iter=
2093
 
    system_variable_hash.find(lower_var);
2094
 
  if (result_iter == system_variable_hash.end())
 
2066
  sys_var *result= system_variable_hash.find(str);
 
2067
  if (result == NULL)
2095
2068
  {
2096
2069
    if (no_error)
2097
2070
    {
2104
2077
    }
2105
2078
  }
2106
2079
 
2107
 
  return (*result_iter).second;
 
2080
  return result;
2108
2081
}
2109
2082
 
2110
2083
 
2160
2133
{
2161
2134
  if (var->is_readonly())
2162
2135
  {
2163
 
    my_error(ER_INCORRECT_GLOBAL_LOCAL_VAR, MYF(0), var->name, "read only");
 
2136
    my_error(ER_INCORRECT_GLOBAL_LOCAL_VAR, MYF(0),
 
2137
             var->name.c_str(), "read only");
2164
2138
    return -1;
2165
2139
  }
2166
2140
  if (var->check_type(type))
2167
2141
  {
2168
2142
    int err= type == OPT_GLOBAL ? ER_LOCAL_VARIABLE : ER_GLOBAL_VARIABLE;
2169
 
    my_error(err, MYF(0), var->name);
 
2143
    my_error(err, MYF(0), var->name.c_str());
2170
2144
    return -1;
2171
2145
  }
2172
2146
  /* value is a NULL pointer if we are using SET ... = DEFAULT */
2174
2148
  {
2175
2149
    if (var->check_default(type))
2176
2150
    {
2177
 
      my_error(ER_NO_DEFAULT, MYF(0), var->name);
 
2151
      my_error(ER_NO_DEFAULT, MYF(0), var->name.c_str());
2178
2152
      return -1;
2179
2153
    }
2180
2154
    return 0;
2185
2159
    return -1;
2186
2160
  if (var->check_update_type(value->result_type()))
2187
2161
  {
2188
 
    my_error(ER_WRONG_TYPE_FOR_VAR, MYF(0), var->name);
 
2162
    my_error(ER_WRONG_TYPE_FOR_VAR, MYF(0), var->name.c_str());
2189
2163
    return -1;
2190
2164
  }
2191
2165
  return var->check(session, this) ? -1 : 0;